Drivlina#

Introduktion #

Drivlinan inkluderar hjul och motorer som styr hur roboten kör och svänger. Drivlinor kan hittas i byggen som Code Base 2.0, Super Car eller en specialbyggd robot.

Drivlinor använder tröghetssensorn i hjärnan för att upptäcka krascher och hjälpa roboten att röra sig och svänga exakt. I början av varje projekt kalibrerar drivlinan tröghetssensorn automatiskt. Håll roboten stilla i cirka 2 sekunder under kalibreringen, så att roboten kan röra sig och svänga korrekt.

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

Åtgärder — Flytta och vrid roboten.

drive — Rör roboten framåt eller bakåt i all oändlighet.
drive_for — Rör roboten framåt eller bakåt ett visst avstånd.
drive_until — Rör roboten framåt tills ögonsensorn detekterar ett föremål eller roboten detekterar en krasch.
turn — Svänger roboten åt vänster eller höger för alltid.
turn_for — Svänger roboten åt vänster eller höger ett visst antal grader.
turn_to_heading — Vrider roboten mot en specifik kurs från -359 till 359 grader. Roboten kommer att svänga den kortaste riktningen för att nå målkursen.
turn_to_rotation — Vrider roboten till en specifik rotation.
stop — Stoppar robotens rörelse.

Mutatorer — Justera drivlinans inställningar.

set_drive_velocity — Anger för roboten hur snabbt den ska köra.
set_turn_velocity — Anger för roboten hur snabbt den ska svänga.
set_stopping — Anger hur roboten kommer att stanna: genom att bromsa, frihjula eller hålla.
set_timeout — Ställer in hur länge roboten ska försöka slutföra en rörelse.
set_heading — Ändrar robotens nuvarande kurs till en ny kurs.
set_rotation — Ändrar robotens aktuella rotation till en ny rotation.

Getters — Kontrollera rörelsestatus.

get_heading — Returnerar robotens aktuella kurs från 0 till 359 grader.
get_rotation — Returnerar robotens aktuella rotation.
get_velocity — Returnerar hur snabbt roboten kör, som en procentandel från -100 % till 100 %.
get_yaw — Returnerar robotens aktuella girning.
get_roll — Returnerar robotens aktuella kast.
get_pitch — Returnerar robotens aktuella tonhöjd.
get_crashed — Returnerar om roboten har upptäckt en krasch, som ett booleskt värde.
is_stopped — Returnerar om roboten är klar med sin rörelse, som ett booleskt värde.

Åtgärder #

drive #

drive rör roboten framåt eller bakåt för alltid. Roboten fortsätter att röra sig tills den får en annan åtgärd, som att vända eller stanna.

Usage:
drivetrain.drive(direction)

Parametrar	Beskrivning
`direction`	Robotens rörelseriktning: `FORWARD` eller `REVERSE`.

# Build Used: Code Base 2.0
def main():
    # Drive forward then stop
    drivetrain.drive(FORWARD)
    wait(2, SECONDS)
    drivetrain.stop()

# Start threads — Do not delete
start_thread(main)

drive_for #

drive_for flyttar roboten framåt eller bakåt ett visst avstånd.

Usage:
drivetrain.drive_for(direction, distance, units, wait)

Parametrar	Beskrivning
`direction`	Robotens rörelseriktning: `FORWARD` eller `REVERSE`.
`distance`	Den sträcka roboten kör. Detta kan vara ett heltal eller ett decimaltal.
`units`	Valfritt. Avståndsenheten: `MM` (millimeter, standard) eller `INCHES`.
`wait`	Valfritt. `wait=True` (standard) gör att projektet väntar tills roboten är klar innan nästa kodrad körs. `wait=False` gör att nästa kodrad körs direkt.

# Build Used: Code Base 2.0
def main():
    # Drive back and forth
    drivetrain.drive_for(FORWARD, 100, MM)
    drivetrain.drive_for(REVERSE, 4, INCHES)
    

# Start threads — Do not delete
start_thread(main)

drive_until #

drive_until flyttar roboten framåt tills ögonsensorn detekterar ett föremål eller roboten detekterar en krock.

Usage:
drivetrain.drive_until(condition, wait)

Parametrar	Beskrivning
`condition`	Villkoret som stoppar roboten: `OBJECT` eller `CRASH`.
`wait`	Valfritt. `wait=True` (standard) gör att projektet väntar tills roboten är klar innan nästa kodrad körs. `wait=False` gör att nästa kodrad körs direkt.

# Build Used: Code Base 2.0
def main():
    # Turn right after a crash
    drivetrain.drive_until(CRASH)
    drivetrain.turn_for(RIGHT, 90)

# Start threads — Do not delete
start_thread(main)

turn #

turn vrider roboten åt vänster eller höger för alltid. Roboten fortsätter att vrida tills den får en annan åtgärd, som att köra till stopp.

Usage:
drivetrain.turn(direction)

Parametrar	Beskrivning
`direction`	Riktningen roboten svänger: `LEFT` eller `RIGHT`.

# Build Used: Code Base 2.0
def main():
    # Turn right and left, then stop
    drivetrain.turn(RIGHT)
    wait(2, SECONDS)
    drivetrain.turn(LEFT)
    wait(2, SECONDS)
    drivetrain.stop()

# Start threads — Do not delete
start_thread(main)

turn_for #

turn_for vrider roboten åt vänster eller höger ett visst antal grader. Vridningen är relativ till robotens aktuella position.

Usage:
drivetrain.turn_for(direction, angle, wait)

Parametrar	Beskrivning
`direction`	Riktningen roboten svänger: `LEFT` eller `RIGHT`.
`angle`	Antalet grader som roboten roterar. Detta kan vara ett heltal eller ett decimaltal.
`wait`	Valfritt. `wait=True` (standard) gör att projektet väntar tills roboten är klar med att vända innan nästa kodrad körs. `wait=False` gör att nästa kodrad körs direkt.

# Build Used: Code Base 2.0
def main():
    # Turn right then left
    drivetrain.turn_for(RIGHT, 90)
    drivetrain.turn_for(LEFT, 90)

# Start threads — Do not delete
start_thread(main)

turn_to_heading #

En kurs är den riktning robotens hjärna är vänd mot, mätt i grader. turn_to_heading vrider roboten så att den är vänd mot en specifik kurs från -359 till 359 grader. Roboten kommer att svänga den kortaste riktningen för att nå målkursen.

Startriktningen är 0 grader.

En VEX GO Code Base 2.0 som visar riktningar: 0 grader framåt, 90 grader höger, 180 grader bakåt och 270 grader vänster.

Usage:
drivetrain.turn_to_heading(angle, wait)

Parametrar	Beskrivning
`angle`	Riktningen som roboten ska vara vänd som ett heltal, från -359 till 359 grader.
`wait`	Valfritt. `wait=True` (standard) gör att projektet väntar tills roboten är klar med att vända innan nästa kodrad körs. `wait=False` gör att nästa kodrad körs direkt.

# Build Used: Code Base 2.0
def main():
    # Turn to face the cardinal directions
    drivetrain.turn_to_heading(90)
    wait(1, SECONDS)
    drivetrain.turn_to_heading(180)
    wait(1, SECONDS)
    drivetrain.turn_to_heading(270)
    wait(1, SECONDS)
    drivetrain.turn_to_heading(0)

# Start threads — Do not delete
start_thread(main)

turn_to_rotation #

turn_to_rotation vrider roboten till en specifik rotation.

Rotation är hur mycket roboten har roterat, mätt i grader. I början av ett projekt sätts rotationsvärdet till 0 grader. Rotation kan också ställas in med set_rotation.

Rotationsvärdena är absoluta. Det betyder att rotationsriktningen beror på robotens aktuella rotation. Att vrida åt höger ökar rotationen och att vrida åt vänster minskar rotationen.

Om roboten till exempel startar vid 0 grader och du roterar 720 grader, kommer den att svänga höger två gånger. Om du sedan roterar 360 grader, kommer den att svänga vänster en gång, eftersom 360 är mindre än 720.

En VEX GO Code Base 2.0 som visar pilar som roterar åt höger och vänster. Vänsterpilen visar "minus" och högerpilen visar "plus".

Usage:
drivetrain.turn_to_rotation(angle, wait)

Parametrar	Beskrivning
`angle`	Rotationsvärdet, i grader, som roboten kommer att vända sig till. Detta kan vara ett heltal.
`wait`	Valfritt. `wait=True` (standard) gör att projektet väntar tills roboten är klar med att vända innan nästa kodrad körs. `wait=False` gör att nästa kodrad körs direkt.

# Build Used: Code Base 2.0
def main():
    # Make one full turn to the right
    drivetrain.turn_to_rotation(360)
    # Make another full turn to the right
    drivetrain.turn_to_rotation(720)
    # Make one full turn to the left, returning to 360 degrees
    drivetrain.turn_to_rotation(360)
# Start threads — Do not delete
start_thread(main)

stop #

stop stoppar robotens rörelse.

Usage:
drivetrain.stop()

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

# Build Used: Code Base 2.0
def main():
    # Drive forward then stop
    drivetrain.drive(FORWARD)
    wait(2, SECONDS)
    drivetrain.stop()

# Start threads — Do not delete
start_thread(main)

Mutatorer #

set_drive_velocity #

set_drive_velocity anger hur snabbt roboten ska köra. En högre procentandel gör att roboten kör snabbare och en lägre procentandel gör att roboten kör långsammare.

Varje projekt börjar med att roboten kör med 50 % hastighet som standard.

Obs: En högre hastighet gör att roboten kör snabbare, men den kan vara mindre precis. En lägre hastighet gör att roboten kör långsammare, men är mer precis.

Usage:
drivetrain.set_drive_velocity(velocity)

Parametrar	Beskrivning
`velocity`	Hastigheten att köra med från 0 % till 100 %.

# Build Used: Code Base 2.0
def main():
    # Drive at different velocities
    drivetrain.drive_for(FORWARD, 100, MM)
    wait(1, SECONDS)
    # Drive slow
    drivetrain.set_drive_velocity(20)
    drivetrain.drive_for(FORWARD, 100, MM)
    wait(1, SECONDS)
    # Drive fast
    drivetrain.set_drive_velocity(100)
    drivetrain.drive_for(FORWARD, 100, MM)

# Start threads — Do not delete
start_thread(main)

set_turn_velocity #

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

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

Obs: En högre hastighet gör att roboten roterar snabbare, men den kan vara mindre precis. En lägre hastighet gör att roboten roterar långsammare, men är mer precis.

Usage:
drivetrain.set_turn_velocity(velocity)

Parametrar	Beskrivning
`velocity`	Hastigheten att rotera med från 0 % till 100 %.

# Build Used: Code Base 2.0
def main():
    # Turn at different velocities
    drivetrain.turn_for(RIGHT, 180)
    wait(1, SECONDS)
    # Turn fast
    drivetrain.set_turn_velocity(100)
    drivetrain.turn_for(RIGHT, 180)

# Start threads — Do not delete
start_thread(main)

set_stopping #

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

Usage:
drivetrain.set_stopping(brake)

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

Parametrar

Beskrivning

brake

Hur roboten kommer att stanna:

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

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

# Build Used: Code Base 2.0
def main():
    # Drive, then coast to a stop
    drivetrain.set_drive_velocity(100)
    drivetrain.set_stopping(COAST)
    drivetrain.drive(FORWARD)
    wait(2, SECONDS)
    drivetrain.stop()

# Start threads — Do not delete
start_thread(main)

set_timeout #

set_timeout anger hur länge roboten ska försöka slutföra en rörelse. Om roboten 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 roboten fastnar i en rörelse.

Usage:
drivetrain.set_timeout(value, units)

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

# Build Used: Code Base 2.0
def main():
    # Drive as far as possible for 1 second before turning right
    drivetrain.set_timeout(1, SECONDS)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    drivetrain.turn_for(RIGHT, 90)

# Start threads — Do not delete
start_thread(main)

set_heading #

En kurs är den riktning robotens hjärna är vänd mot, mätt i grader. set_heading ändrar robotens nuvarande kurs till ett nytt kursvärde.

Om roboten till exempel har vänt sig åt höger och kursen ställs in på 0 grader, blir den högervända positionen den nya 0 grader. Roboten kan då vända sig till andra positioner baserat på den nya kursen.

Usage:
drivetrain.set_heading(value)

Parametrar	Beskrivning
`value`	Kursvärdet, i grader, som ska ställas in för roboten. Detta kan vara ett heltal från 0 till 359.

# Build Used: Code Base 2.0
def main():
    # Face the new 0 degree heading
    drivetrain.set_heading(90)
    drivetrain.turn_to_heading(0)

# Start threads — Do not delete
start_thread(main)

set_rotation #

Rotation är hur mycket roboten har roterat, mätt i grader. I början av ett projekt sätts rotationsvärdet till 0 grader. set_rotation ändrar robotens aktuella rotation till ett nytt värde.

Om roboten till exempel har gjort två hela varv åt höger blir dess rotationsvärde 720 grader. Om rotationen ställs in på 0 grader återställs den rotationen från 720 till 0 grader. Sedan kan roboten vända sig till rotationer baserat på det nya värdet.

Usage:
drivetrain.set_rotation(value)

Parametrar	Beskrivning
`value`	Rotationsvärdet, i grader, som ska ställas in för roboten. Detta kan vara ett heltal.

# Build Used: Code Base 2.0
def main():
    # Spin counterclockwise two times
    drivetrain.set_rotation(720)
    drivetrain.turn_to_rotation(0)

# Start threads — Do not delete
start_thread(main)

Getters #

get_heading #

En kurs är den riktning robotens hjärna är vänd mot, mätt i grader. get_heading returnerar den kursen från 0 till 359 grader.

Robotens startriktning är 0 grader.

En VEX GO-hjärna som visar riktningar: 0 grader framåt, 90 grader höger, 180 grader bakåt och 270 grader vänster.

Usage:
drivetrain.get_heading()

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

# Build Used: Code Base 2.0
def main():
    # Display the heading while turning
    monitor_sensor("drivetrain.get_heading")
    drivetrain.turn_for(RIGHT, 450)


# Start threads — Do not delete
start_thread(main)

get_rotation #

Rotation är hur mycket roboten har roterat, mätt i grader. I början av ett projekt sätts rotationsvärdet till 0 grader. get_rotation returnerar robotens aktuella rotation.

Att vrida åt höger ökar rotationen, och att vrida åt vänster minskar rotationen. Om du till exempel gör två hela varv åt höger får du en rotation på 720 grader.

En VEX GO Code Base 2.0 som visar pilar som roterar åt höger och vänster. Vänsterpilen visar "minus" och högerpilen visar "plus".

Usage:
drivetrain.get_rotation()

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

# Build Used: Code Base 2.0
def main():
    # Display the rotation while turning
    monitor_sensor("drivetrain.get_rotation")
    drivetrain.turn_for(RIGHT, 450)


# Start threads — Do not delete
start_thread(main)

get_velocity #

get_velocity returnerar hur snabbt roboten kör, som en procentandel från -100% till 100%.

Ett positivt värde betyder att roboten kör framåt. Ett negativt värde betyder att roboten kör bakåt.

Usage:
drivetrain.get_velocity()

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

# Build Used: Code Base 2.0
def main():
    # Display the velocity of the robot before and while moving
    console.print("Start: ")
    console.print(drivetrain.get_velocity())
    console.new_line()
    drivetrain.drive(FORWARD)
    wait(0.5, SECONDS)
    console.print("Moving: ")
    console.print(drivetrain.get_velocity())
    drivetrain.stop()


# Start threads — Do not delete
start_thread(main)

get_yaw #

Girning är hur mycket roboten har svängt åt vänster eller höger från sin startposition, mätt i grader. get_yaw returnerar robotens aktuella girningsvärde.

Att svänga åt höger ökar girvärdet, och att svänga åt vänster minskar girvärdet.

Usage:
drivetrain.get_yaw()

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

# Build Used: Super Code Base 2.0
def main():
    # Change the LED color based on the yaw while
    # moving the robot by hand
    monitor_sensor("drivetrain.get_yaw")
    while True:
        if drivetrain.get_yaw() > 0:
            bumper.set_color(GREEN)
        elif drivetrain.get_yaw() < 0:
            bumper.set_color(RED)
        else:
            bumper.set_color(NONE)

# Start threads — Do not delete
start_thread(main)

get_roll #

Roll är hur mycket roboten lutar åt vänster eller höger, mätt i grader. get_roll returnerar robotens aktuella rollvärde.

Med hjärnan vänd framåt ökar lutningen åt vänster rullvärdet, och lutningen åt höger minskar rullvärdet.

Usage:
drivetrain.get_roll()

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

# Build Used: Super Code Base 2.0
def main():
    # Change the LED color based on the roll while
    # moving the robot by hand
    monitor_sensor("drivetrain.get_roll")
    while True:
        if drivetrain.get_roll() > 0:
            bumper.set_color(GREEN)
        elif drivetrain.get_roll() < 0:
            bumper.set_color(RED)
        else:
            bumper.set_color(NONE)

# Start threads — Do not delete
start_thread(main)

get_pitch #

Lutning är hur mycket roboten lutar framåt eller bakåt, mätt i grader. get_pitch returnerar robotens aktuella lutningsvärde.

Med hjärnan vänd framåt ökar tonhöjden om du lutar framåt, och om du lutar bakåt minskar den tonhöjden.

Usage:
drivetrain.get_pitch()

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

# Build Used: Super Code Base 2.0
def main():
    # Change the LED color based on the pitch while
    # moving the robot by hand
    monitor_sensor("drivetrain.get_pitch")
    while True:
        if drivetrain.get_pitch() > 0:
            bumper.set_color(GREEN)
        elif drivetrain.get_pitch() < 0:
            bumper.set_color(RED)
        else:
            bumper.set_color(NONE)

# Start threads — Do not delete
start_thread(main)

get_crashed #

get_crashed returnerar om roboten har upptäckt en krasch, som ett booleskt värde.

True — En krasch har upptäckts.
False — Ingen krasch har upptäckts.

Usage:
drivetrain.get_crashed()

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

# Build Used: Super Code Base 2.0
def main():
    # Drive until a crash
    drivetrain.drive(FORWARD)
    while not drivetrain.get_crashed():
        wait(50, MSEC)
    drivetrain.stop()
    drivetrain.turn_for(RIGHT, 90)

# Start threads — Do not delete
start_thread(main)

is_stopped #

is_stopped returnerar huruvida roboten är klar med att röra sig, som ett booleskt värde. Detta kan användas för att styra tidpunkten för andra beteenden baserat på robotens rörelse.

True — Roboten är klar med sin rörelse.
False — Roboten rör sig fortfarande.

Den här metoden fungerar tillsammans med följande drivlinametoder som har parametern wait : drive_for, drive_until, turn_for, turn_to_heading och turn_to_rotation.

Usage:
drivetrain.is_stopped()

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

# Build Used: Code Base 2.0
def main():
    # Turn when the drivetrain is done moving forward
    drivetrain.drive_for(FORWARD, 100, MM, wait=False)
    wait(0.25, SECONDS)
    while True:
        if drivetrain.is_stopped():
            drivetrain.turn_for(RIGHT, 180)
            break
        else:
            console.print("Still moving...")
            wait(0.1, SECONDS)
            console.clear()

# Start threads — Do not delete
start_thread(main)