Rörelse#

Introduktion #

Motorer styr hur delar av en robot rör sig. Motorer kan användas för att lyfta en arm, vrida en klo, snurra ett hjul eller flytta en annan del av en byggnad. Två motorer kan arbeta tillsammans som en drivlina för att röra och vrida hela roboten.

Varje motor konfigureras i fönstret Enheter. Beroende på versionen kan motornamnen ändras. Till exempel har Competition Advanced 2.0-versionen en motor med namnet arm_motorEn anpassad robot kan använda olika motornamn.

Som standard roterar FORWARD en motor moturs och REVERSE roterar en motor medurs. Om en motor är inställd på bakåt i Enhetsfönstret kommer dessa riktningar att växlas.

En VEX GO-motor som visar framåtriktningen indikerad med ett plustecken och en pil som indikerar att den roterar åt vänster eller moturs.

En VEX GO-motor som visar bakåtriktningen indikerad med ett minustecken och en pil som indikerar att den roterar åt höger eller medurs.

Det finns många sätt att koda motorer. Nedan följer en lista över alla rörelsemetoder:

Åtgärder — Stoppa och snurra motorer.

spin — Snurrar en motor framåt eller bakåt i all oändlighet.
spin_for — Snurrar en motor ett visst avstånd.
spin_to_position — Roterar en motor till en specifik position.
stop — Stoppar en motor från att snurra.

Mutatorer — Justera motorinställningar.

set_velocity — Anger hur snabbt motorn ska snurra.
set_max_torque — Anger hur hårt en motor tillåts trycka medan den roterar.
set_position — Ändrar motorns aktuella position till ett nytt värde.
set_stopping — Ställer in hur en motor ska stanna: genom att bromsa, frihjula eller hålla.
set_timeout — Anger hur lång tid en motor ska försöka slutföra en rörelse.

Getters — Kontrollera motorstatus.

get_position — Returnerar motorns aktuella position.
get_velocity — Returnerar hur snabbt motorn snurrar, som en procentandel från -100 % till 100 %.
get_current — Returnerar hur mycket ström motorn använder från batteriet, som en procentandel från 0 % till 100 %.
is_stopped — Returnerar om motorn har slutat röra sig, som ett booleskt värde.
is_moving — Returnerar om motorn snurrar, som ett booleskt värde.

Åtgärder #

spin #

spin snurrar en motor framåt eller bakåt för alltid. Motorn fortsätter att snurra tills den får en annan åtgärd, som att snurra i en annan riktning eller stanna.

Usage:
arm_motor.spin(direction)

Parametrar	Beskrivning
`direction`	Motorns rotationsriktning: `FORWARD` eller `REVERSE`.

# Build Used: Competition Advanced 2.0
def main():
    # Raise the ArmMotor, then stop
    arm_motor.spin(REVERSE)
    wait(1, SECONDS)
    arm_motor.stop()

# Start threads — Do not delete
start_thread(main)

spin_for #

spin_for snurrar en motor ett visst avstånd. Rotationen är relativ till motorns aktuella position. Projektet väntar tills motorn har snurrat klart innan nästa kodrad körs.

Usage:
arm_motor.spin_for(direction, angle, units, wait)

Parametrar	Beskrivning
`direction`	Motorns rotationsriktning: `FORWARD` eller `REVERSE`.
`angle`	Avståndet motorn snurrar. `DEGREES` använd heltal. `TURNS` kan använda heltal eller decimaler.
`units`	Valfritt. Avståndsenheten: `DEGREES` (standard) eller `TURNS`.
`wait`	Valfritt. `wait=True` (standard) gör att projektet väntar tills motorn har snurrat klart innan nästa kodrad körs. `wait=False` gör att nästa kodrad körs direkt.

# Build Used: Competition Advanced 2.0
def main():
    # Raise and lower the ArmMotor
    arm_motor.spin_for(REVERSE, 180, DEGREES)
    wait(1, SECONDS)
    arm_motor.spin_for(FORWARD, 180, DEGREES)

# Start threads — Do not delete
start_thread(main)

spin_to_position #

spin_to_position snurrar en motor till en specifik position.

En motors position är hur långt den har snurrat, mätt i DEGREES eller TURNSEtt varv är lika med 360 grader. I början av ett projekt är motorpositionen inställd på 0 grader. Motorpositionen kan också ställas in med metoden set_position.

Positionsvärdena är absoluta. Det betyder att rotationsriktningen beror på motorns aktuella position.

Om motorn till exempel startar vid 0 grader och snurrar till en position på 720 grader, snurrar den framåt två varv. Om den sedan snurrar till en position på 360 grader, snurrar den bakåt ett varv, eftersom 360 är mindre än 720.

Usage:
arm_motor.spin_to_position(angle, units, wait)

Parametrar	Beskrivning
`angle`	Positionsvärdet som motorn kommer att rotera till. `DEGREES` använd heltal. `TURNS` kan använda heltal eller decimaler.
`units`	Valfritt. Positionsenheten: `DEGREES` (standard) eller `TURNS`.
`wait`	Valfritt. `wait=True` (standard) gör att projektet väntar tills motorn har snurrat klart innan nästa kodrad körs. `wait=False` gör att nästa kodrad körs direkt.

# Build Used: Competition Advanced 2.0
def main():
    # Return ArmMotor to 0 degrees after raising
    arm_motor.spin_for(REVERSE, 180, DEGREES)
    wait(1, SECONDS)
    arm_motor.spin_to_position(0, DEGREES)

# Start threads — Do not delete
start_thread(main)

stop #

stop stoppar en motor från att snurra.

Usage:
arm_motor.stop()

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

# Build Used: Competition Advanced 2.0
def main():
    # Raise the ArmMotor
    arm_motor.spin(REVERSE)
    wait(1, SECONDS)
    arm_motor.stop()

# Start threads — Do not delete
start_thread(main)

Mutatorer #

set_velocity #

set_velocity anger hur snabbt en motor ska snurra. En högre procentandel gör att motorn snurrar snabbare och en lägre procentandel gör att motorn snurrar långsammare.

Varje projekt börjar med att varje motor roterar med 50 % hastighet som standard.

Obs! En högre hastighet gör att motorn snurrar snabbare, men den kan vara mindre exakt. En lägre hastighet gör att motorn snurrar långsammare, men den kan vara mer exakt.

Usage:
arm_motor.set_velocity(velocity)

Parametrar	Beskrivning
`velocity`	Hastigheten att rotera med från 0% till 100%. Detta kan vara ett heltal `integer` eller ett decimaltal (`float`).

# Build Used: Competition Advanced 2.0
def main():
    # Move the ArmMotor at different velocities
    arm_motor.spin_for(REVERSE, 180, DEGREES)
    wait(1, SECONDS)
    # Move slow
    arm_motor.set_velocity(20)
    arm_motor.spin_for(FORWARD, 180, DEGREES)
    wait(1, SECONDS)
    # Move fast
    arm_motor.set_velocity(100)
    arm_motor.spin_for(REVERSE, 180, DEGREES)

# Start threads — Do not delete
start_thread(main)

set_max_torque #

Vridmoment är en rotationskraft. Det visar hur hårt en motor kan trycka eller dra när den snurrar.

set_max_torque ställer in det högsta vridmoment som en motor tillåts använda.

En högre procentandel låter motorn trycka hårdare, som när man lyfter ett tungt föremål. En lägre procentandel begränsar hur hårt motorn kan trycka. Detta kan hjälpa till att skydda roboten om motorn fastnar eller når slutet av hur långt den kan röra sig.

Varje projekt börjar med att varje motors vridmoment är 50 % som standard.

Usage:
arm_motor.set_max_torque(value)

Parametrar	Beskrivning
`value`	Det maximala vridmomentet som motorn kan använda är från 0 % till 100 %. Detta kan vara ett heltal `integer` eller ett decimaltal (`float`).

# Build Used: Competition Advanced 2.0
def main():
    # Move the ArmMotor at different torques
    arm_motor.spin_for(REVERSE, 180, DEGREES)
    wait(1, SECONDS)
    # Move with less torque
    arm_motor.set_max_torque(20)
    arm_motor.spin_for(FORWARD, 180, DEGREES)
    wait(1, SECONDS)
    # Move with maximum torque
    arm_motor.set_max_torque(100)
    arm_motor.spin_for(REVERSE, 180, DEGREES)

# Start threads — Do not delete
start_thread(main)

set_position #

En motors position är hur långt den har snurrat, mätt i DEGREES eller TURNSEtt varv är lika med 360 grader. set_position ändrar motorns nuvarande position till ett nytt värde.

Om till exempel en motor har snurrat 180 grader, kommer en position som ställs in på 0 grader att återställas från 180 grader till 0 grader. Motorn kan sedan snurra till positioner baserat på det nya värdet.

Usage:
arm_motor.set_position(position, units)

Parametrar	Beskrivning
`position`	Positionsvärdet som ska ställas in för motorn. `DEGREES` använd heltal. `TURNS` kan använda heltal eller decimaler.
`units`	Valfritt. Positionsenheten: `DEGREES` (standard) eller `TURNS`.

# Build Used: Competition Advanced 2.0
def main():
    # Return ArmMotor to 0 degrees after raising
    arm_motor.set_position(0, DEGREES)
    arm_motor.spin_for(REVERSE, 180, DEGREES)
    wait(1, SECONDS)
    arm_motor.spin_to_position(0, DEGREES)

# Start threads — Do not delete
start_thread(main)

set_stopping #

set_stopping anger hur en motor ska stanna: genom att bromsa, frihjula eller hålla.

Usage:
arm_motor.set_stopping(mode)

Parametrar	Beskrivning
`mode`	Hur motorn kommer att stanna: `BRAKE` — Stannar omedelbart. `COAST` — Saktar ner till stopp. `HOLD` — Stannar omedelbart och håller motorns position.

Parametrar

Beskrivning

mode

Hur motorn kommer att stanna:

BRAKE — Stannar omedelbart.
COAST — Saktar ner till stopp.
HOLD — Stannar omedelbart och håller motorns position.

Om till exempel en Competition Advanced 2.0-version används och arm_motor är satt till HOLD, kommer motorn att hålla armen i dess nuvarande position tills en annan armrörelse sker. Det betyder att motorn kommer att arbeta mot gravitationen för att hålla armen i luften om motorn stoppades med armen upplyft.

Om denna metod inte används kommer motorn att använda BRAKE vid stopp.

# Build Used: Competition Advanced 2.0
def main():
    # Move the ArmMotor, then coast to a stop
    arm_motor.set_velocity(20)
    arm_motor.set_stopping(COAST)
    arm_motor.spin(REVERSE)
    wait(1, SECONDS)
    arm_motor.stop()

# Start threads — Do not delete
start_thread(main)

set_timeout #

set_timeout anger hur lång tid en motor ska försöka slutföra en rörelse. Om motorn inte kan slutföra inom den tiden kommer den att sluta försöka och gå vidare till nästa kodrad. Detta förhindrar att motorn fastnar i en rörelse.

Usage:
arm_motor.set_timeout(value, units)

Parametrar	Beskrivning
`value`	Den tid motorn kan försöka slutföra en rörelse. Detta kan vara ett positivt `integer` eller ett decimaltal (`float`).
`units`	Valfritt. Tidsenhet: `SECONDS` (standard) eller `MSEC` (millisekunder).

# Build Used: Competition Advanced 2.0
def main():
    # Move ArmMotor as far as possible for 1 second before resetting
    arm_motor.set_position(0, DEGREES)
    arm_motor.set_timeout(1, SECONDS)
    arm_motor.spin_for(REVERSE, 180, DEGREES)
    arm_motor.spin_to_position(0, DEGREES)

# Start threads — Do not delete
start_thread(main)

Getters #

get_position #

En motors position är hur långt den har snurrat, mätt i DEGREES eller TURNS. Ett varv är lika med 360 grader. get_position returnerar motorns aktuella position.

I början av ett projekt är motorpositionen inställd på 0 grader. Om motorn snurrar ett varv framåt blir positionen 360 grader eller 1 varv. Om motorn snurrar åt andra hållet blir positionen negativ.

Usage:
arm_motor.get_position(units)

Parametrar	Beskrivning
`units`	Valfritt. Enheten för att returnera motorpositionen i: `DEGREES` (standard) eller `TURNS`.

# Build Used: Competition Advanced 2.0
def main():
    # Display how far the ArmMotor moves after one second
    arm_motor.set_position(0, DEGREES)
    console.print("Start: ")
    console.print(arm_motor.get_position(DEGREES))
    console.new_line()
    arm_motor.spin(REVERSE)
    wait(1, SECONDS)
    arm_motor.stop()
    console.print("After: ")
    console.print(arm_motor.get_position(DEGREES))

# Start threads — Do not delete
start_thread(main)

get_velocity #

get_velocity returnerar hur snabbt motorn snurrar, som en procentandel från -100% till 100%.

Ett positivt värde betyder att motorn roterar framåt. Ett negativt värde betyder att motorn roterar bakåt.

Usage:
arm_motor.get_velocity()

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

# Build Used: Competition Advanced 2.0
def main():
    # Display the ArmMotor's velocity when it moves
    console.print("Resting: ")
    console.print(arm_motor.get_velocity())
    console.new_line()
    arm_motor.spin(REVERSE)
    wait(1, SECONDS)
    console.print("Moving: ")
    console.print(arm_motor.get_velocity())
    arm_motor.stop()

# Start threads — Do not delete
start_thread(main)

get_current #

get_current returnerar hur mycket ström motorn använder från batteriet, som en procentandel från 0% till 100%.

Ett högre strömvärde innebär att motorn använder mer ström. Detta kan hända när motorn lyfter något tungt, trycker mot ett föremål eller försöker röra sig när den har fastnat.

Usage:
arm_motor.get_current()

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

# Build Used: Competition Advanced 2.0
def main():
    # Display the motor's current when it moves
    console.print("Resting: ")
    console.print(arm_motor.get_current())
    console.new_line()
    arm_motor.spin(REVERSE)
    wait(1, SECONDS)
    console.print("Moving: ")
    console.print(arm_motor.get_current())
    arm_motor.stop()

# Start threads — Do not delete
start_thread(main)

is_stopped #

is_stopped returnerar om motorn har slutat röra sig, som ett booleskt värde. Detta kan användas för att styra tidpunkten för andra beteenden baserat på motorns rörelse.

True — Motorn är klar med att röra sig.
False — Motorn rör sig fortfarande.

Den här metoden fungerar tillsammans med följande rörelsemetoder som har parametern wait : spin_for och spin_to_position.

Usage:
arm_motor.is_stopped()

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

# Build Used: Competition Advanced 2.0
def main():
    # Turn the Eye Sensor's light on while ArmMotor is moving
    arm_motor.spin_for(REVERSE, 180, DEGREES, wait=False)
    wait(0.1, SECONDS)
    while True:
        if arm_motor.is_stopped():
            eye.set_light(OFF)
        else:
            eye.set_light(ON)

# Start threads — Do not delete
start_thread(main)

is_moving #

is_moving returnerar huruvida motorn snurrar, som ett booleskt värde. Detta kan användas för att styra tidpunkten för andra beteenden baserat på motorns rörelse.

True — Motorn snurrar.
False — Motorn snurrar inte.

Den här metoden fungerar tillsammans med följande rörelsemetoder som har parametern wait : spin_for och spin_to_position.

Usage:
arm_motor.is_moving()

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

# Build Used: Competition Advanced 2.0
def main():
    # Turn the Eye Sensor's light on while ArmMotor is moving
    arm_motor.spin_for(REVERSE, 180, DEGREES, wait=False)
    wait(0.1, SECONDS)
    while True:
        if arm_motor.is_moving():
            eye.set_light(ON)
        else:
            eye.set_light(OFF)

# Start threads — Do not delete
start_thread(main)