Drivlina#

Introduktion #

VEX IQ (2:a generationen)-roboten använder en drivlina för att köra och vrida. En drivlina består av motorer och hjul som samverkar för att förflytta roboten.

En konfigurerad drivlina kan använda en ansluten Gyrosensor, hjärnans inbyggda Tröghetssensor, eller ingen sensor alls. När en sensor används använder drivlinan den för att hjälpa roboten att röra sig och svänga exakt. I början av varje projekt kalibrerar drivlinan sensorn automatiskt. Håll roboten stilla i cirka 2 sekunder under kalibreringen, så att roboten kan röra sig och svänga korrekt.

Den här sidan använder drivetrain som exempelnamn för drivlina. Ersätt det med ditt eget konfigurerade namn efter behov.

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.
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.
calibrate_drivetrain — Kalibrerar sensorn som är konfigurerad med drivlinan.

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 — Anger hur lång tid 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.
set_turn_threshold — Anger hur nära roboten måste komma en målvinkel innan en sväng är klar.
set_turn_constant — Ändrar hur kraftigt roboten korrigerar sina svängar.

Getters — Kontrollera rörelsestatus.

heading — Returnerar robotens aktuella kurs från 0 till 359 grader.
rotation — Returnerar robotens aktuella rotation.
velocity — Returnerar hur snabbt roboten kör.
current — Returnerar hur mycket elektrisk ström drivlinan använder.
is_moving — Returnerar om roboten rör sig, som ett booleskt värde.
is_done — Returnerar om roboten är klar med sin rörelse, som ett booleskt värde.
is_turning — Returnerar om roboten roterar, som ett booleskt värde.
power — Returnerar hur snabbt drivlinan förbrukar energi.
torque — Returnerar hur mycket vridmoment drivlinan använder.
efficiency — Returnerar hur effektivt drivlinan använder ström.
temperature — Returnerar hur varm drivlinan är.

Konstruktörer — Skapa och konfigurera drivlinan manuellt.

DriveTrain — Skapar en drivlina utan gyrosensor eller tröghetssensor.
SmartDrive — Skapar en drivlina med en gyrosensor eller tröghetssensor.

Å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, velocity, units)

Parametrar	Beskrivning
`direction`	Robotens rörelseriktning: `FORWARD` eller `REVERSE`.
`velocity`	Valfritt. Hastigheten att köra med är från 0 % till 100 % när `PERCENT`, från 0 till 120 rpm när `RPM`, eller från 0 till 720 grader per sekund när `VelocityUnits.DPS`används. Detta kan vara ett heltal `integer` eller ett decimaltal (`float`). Om ingen hastighet anges kör roboten med den aktuella körhastigheten.
`units`	Valfritt. Hastighetsenheten: `PERCENT` (standard), `RPM` (varv per minut) eller `VelocityUnits.DPS` (grader per sekund).

# Drive forward then stop
drivetrain.drive(FORWARD)
wait(2, SECONDS)
drivetrain.stop()

# Drive slowly in reverse then stop
drivetrain.drive(REVERSE, 20, PERCENT)
wait(2, SECONDS)
drivetrain.stop()

drive_for #

drive_for flyttar roboten framåt eller bakåt ett visst avstånd. Projektet väntar tills roboten är klar innan nästa kodrad körs.

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

Parametrar	Beskrivning
`direction`	Robotens rörelseriktning: `FORWARD` eller `REVERSE`.
`distance`	Sträckan roboten kör. Detta kan vara ett heltal `integer` eller ett decimaltal (`float`).
`units`	Valfritt. Avståndsenheten: `INCHES` (standard), `MM` (millimeter) eller `DistanceUnits.CM` (centimeter).
`velocity`	Valfritt. Hastigheten att köra med är från 0 % till 100 % när `PERCENT`, från 0 till 120 rpm när `RPM`, eller från 0 till 720 grader per sekund när `VelocityUnits.DPS`används. Detta kan vara ett heltal `integer` eller ett decimaltal (`float`). Om ingen hastighet anges kör roboten med den aktuella körhastigheten.
`units_v`	Valfritt. Hastighetsenheten: `RPM` (varv per minut, standard), `PERCENT`eller `VelocityUnits.DPS` (grader per sekund).
`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.

# Drive forward and backward
drivetrain.drive_for(FORWARD, 10)
drivetrain.drive_for(REVERSE, 10)

# Quickly drive forward and backward
drivetrain.drive_for(FORWARD, 200, MM, 100, PERCENT)
drivetrain.drive_for(REVERSE, 200, MM, 100, PERCENT)

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 eller stanna.

Usage:
drivetrain.turn(direction, velocity, units)

Parametrar	Beskrivning
`direction`	Riktningen roboten svänger: `LEFT` eller `RIGHT`.
`velocity`	Valfritt. Hastigheten att rotera med är från 0 % till 100 % när `PERCENT`, från 0 till 120 rpm när `RPM`, eller från 0 till 720 grader per sekund när `VelocityUnits.DPS`används. Detta kan vara ett heltal `integer` eller ett decimaltal (`float`). Om ingen hastighet anges roterar roboten med den aktuella rotationshastigheten.
`units`	Valfritt. Hastighetsenheten: `RPM` (varv per minut, standard), `PERCENT`eller `VelocityUnits.DPS` (grader per sekund).

# Turn right and left, then stop
drivetrain.turn(RIGHT)
wait(2, SECONDS)
drivetrain.turn(LEFT)
wait(2, SECONDS)
drivetrain.stop()

# Quickly turn right and left, then stop
drivetrain.turn(RIGHT, 100, PERCENT)
wait(2, SECONDS)
drivetrain.turn(LEFT, 100, PERCENT)
wait(2, SECONDS)
drivetrain.stop()

turn_for #

turn_for vrider roboten åt vänster eller höger ett visst antal grader eller varv. Vridningen är relativ till robotens aktuella position. Projektet väntar tills roboten är klar med att vrida sig innan nästa kodrad körs.

Usage:
drivetrain.turn_for(direction, angle, units, velocity, units_v, wait)

Parametrar	Beskrivning
`direction`	Riktningen roboten svänger: `LEFT` eller `RIGHT`.
`angle`	Hur mycket roboten roterar. Detta kan vara ett heltal `integer` eller ett decimaltal (`float`).
`units`	Valfritt. Vridenheten: `DEGREES` (standard) eller `TURNS`Ett varv är lika med 360 grader.
`velocity`	Valfritt. Hastigheten att rotera med är från 0 % till 100 % när `PERCENT`, från 0 till 120 rpm när `RPM`, eller från 0 till 720 grader per sekund när `VelocityUnits.DPS`används. Detta kan vara ett heltal `integer` eller ett decimaltal (`float`). Om ingen hastighet anges roterar roboten med den aktuella rotationshastigheten.
`units_v`	Valfritt. Hastighetsenheten: `RPM` (varv per minut, standard), `PERCENT`eller `VelocityUnits.DPS` (grader per sekund).
`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.

# Turn the robot right and left
drivetrain.turn_for(RIGHT, 90, DEGREES)
wait(1, SECONDS)
drivetrain.turn_for(LEFT, 90, DEGREES)

# Quickly turn the robot right and left
drivetrain.turn_for(RIGHT, 90, DEGREES, 100, PERCENT)
wait(1, SECONDS)
drivetrain.turn_for(LEFT, 90, DEGREES, 100, PERCENT)

turn_to_heading #

En kurs är den riktning roboten ä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.

Robotens startriktning är 0 grader.

Projektet väntar tills roboten är klar med att snurra innan nästa kodrad körs.

Usage:
drivetrain.turn_to_heading(angle, units, velocity, units_v, wait)

Parametrar	Beskrivning
`angle`	Riktningen roboten ska vara vänd mot, i grader. Detta kan vara ett heltal `integer` eller ett decimaltal (`float`) från -359 till 359.
`units`	Valfritt. Kursenheten: `DEGREES` (standard).
`velocity`	Valfritt. Hastigheten att rotera med är från 0 % till 100 % när `PERCENT`, från 0 till 120 rpm när `RPM`, eller från 0 till 720 grader per sekund när `VelocityUnits.DPS`används. Detta kan vara ett heltal `integer` eller ett decimaltal (`float`). Om ingen hastighet anges roterar roboten med den aktuella rotationshastigheten.
`units_v`	Valfritt. Hastighetsenheten: `PERCENT` (standard), `RPM` (varv per minut) eller `VelocityUnits.DPS` (grader per sekund).
`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.

# Turn to face the cardinal directions
drivetrain.turn_to_heading(90, DEGREES)
wait(1, SECONDS)
drivetrain.turn_to_heading(180, DEGREES)
wait(1, SECONDS)
drivetrain.turn_to_heading(270, DEGREES)
wait(1, SECONDS)
drivetrain.turn_to_heading(0, DEGREES)

# Turn twice slowly
drivetrain.turn_to_heading(90, DEGREES, 20, PERCENT)
wait(1, SECONDS)
drivetrain.turn_to_heading(180, DEGREES, 20, PERCENT)

turn_to_rotation #

turn_to_rotation vrider roboten till en specifik rotation.

Rotation är hur mycket roboten har roterat, mätt i grader eller varv. I början av ett projekt sätts rotationsvärdet till 0 grader. Rotation kan också ställas in med metoden 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.

Projektet väntar tills roboten är klar med att snurra innan nästa kodrad körs.

Usage:
drivetrain.turn_to_rotation(angle, units, velocity, units_v, wait)

Parametrar	Beskrivning
`angle`	Rotationsvärdet, i grader eller varv, som roboten kommer att vända sig till. Detta kan vara ett heltal `integer` eller ett decimaltal (`float`).
`units`	Valfritt. Rotationsenheten: `DEGREES` (standard) eller `TURNS`Ett varv är lika med 360 grader.
`velocity`	Valfritt. Hastigheten att rotera med är från 0 % till 100 % när `PERCENT`, från 0 till 120 rpm när `RPM`, eller från 0 till 720 grader per sekund när `VelocityUnits.DPS`används. Detta kan vara ett heltal `integer` eller ett decimaltal (`float`). Om ingen hastighet anges roterar roboten med den aktuella rotationshastigheten.
`units_v`	Valfritt. Hastighetsenheten: `PERCENT` (standard), `RPM` (varv per minut) eller `VelocityUnits.DPS` (grader per sekund).
`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.

# Turn left, then spin in a circle
# clockwise and face right
drivetrain.turn_to_rotation(-90, DEGREES)
wait(1, SECONDS)
drivetrain.turn_to_rotation(450, DEGREES)

# Turn left then slowly spin in a
# circle clockwise
drivetrain.turn_to_rotation(-90, DEGREES)
wait(1, SECONDS)
drivetrain.turn_to_rotation(450, DEGREES, 20, PERCENT)

stop #

stop stoppar robotens rörelse.

Usage:
drivetrain.stop(mode)

Parametrar	Beskrivning
`mode`	Valfritt. Hur roboten stannar: `BRAKE` (standard), `BRAKE`eller `COAST` `COAST` — Stannar omedelbart. `HOLD` — Saktar ner till stopp. `HOLD` — Stannar omedelbart och håller hjulens position.

Parametrar

Beskrivning

mode

Valfritt. Hur roboten stannar: BRAKE (standard), BRAKEeller COAST

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

# Drive forward then stop
drivetrain.drive(FORWARD)
wait(2, SECONDS)
drivetrain.stop()

# Drive forward and coast to a stop
drivetrain.set_drive_velocity(100, PERCENT)
drivetrain.drive(FORWARD)
wait(2, SECONDS)
drivetrain.stop(COAST)

calibrate_drivetrain #

calibrate_drivetrain är en inbyggd funktion som kalibrerar gyrosensorn eller tröghetssensorn som konfigurerats med drivlinan.

Kalibrering hjälper sensorn att mäta rörelse korrekt. Håll roboten stilla i cirka 2 sekunder under kalibreringen. Om roboten rör sig under kalibreringen kanske sensorn inte mäter rörelse korrekt.

Projektet väntar tills kalibreringen är klar innan nästa kodrad körs.

Obs! Den här funktionen kan inte användas inuti VS Code.

Usage:
calibrate_drivetrain()

Parametrar	Beskrivning
	Den här funktionen har inga parametrar.

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 den kan vara mer precis.

Usage:
drivetrain.set_drive_velocity(velocity, units)

Parametrar	Beskrivning
`velocity`	Hastigheten att köra med är från 0 % till 100 % när `PERCENT`används, från 0 till 120 rpm när `RPM`används, eller från 0 till 720 grader per sekund när `VelocityUnits.DPS`används. Detta kan vara ett heltal `integer` eller ett decimaltal (`float`).
`units`	Valfritt. Hastighetsenheten: `PERCENT` (standard), `RPM` (varv per minut) eller `VelocityUnits.DPS` (grader per sekund).

# Drive forward at different velocities
# Default velocity
drivetrain.drive_for(FORWARD, 150, MM)
wait(1, SECONDS)
# Drive slower
drivetrain.set_drive_velocity(20, PERCENT)
drivetrain.drive_for(FORWARD, 150, MM)
wait(1, SECONDS)
# Drive faster
drivetrain.set_drive_velocity(100, PERCENT)
drivetrain.drive_for(FORWARD, 150, MM)

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 exakt. En lägre hastighet gör att roboten roterar långsammare, men den kan vara mer exakt.

Usage:
drivetrain.set_turn_velocity(velocity, units)

Parametrar	Beskrivning
`velocity`	Hastigheten att rotera med från 0% till 100% när `PERCENT`, från 0 till 120 rpm när `RPM`, eller från 0 till 720 grader per sekund när `VelocityUnits.DPS`används. Detta kan vara ett heltal `integer` eller ett decimaltal (`float`).
`units`	Valfritt. Hastighetsenheten: `PERCENT` (standard), `RPM` (varv per minut) eller `VelocityUnits.DPS` (grader per sekund).

# Turn at different velocities
# Default velocity
drivetrain.turn_for(RIGHT, 360)
wait(1, SECONDS)
# Turn slower
drivetrain.set_turn_velocity(20, PERCENT)
drivetrain.turn_for(RIGHT, 360)
wait(1, SECONDS)
# Turn faster
drivetrain.set_turn_velocity(100, PERCENT)
drivetrain.turn_for(RIGHT, 360)

set_stopping #

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

Usage:
drivetrain.set_stopping(mode)

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

Parametrar

Beskrivning

mode

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.

set_timeout #

set_timeout anger hur lång tid 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 positivt `integer` eller ett decimaltal (`float`).
`units`	Valfritt. Tidsenhet: `MSEC` (millisekunder, standard) eller `SECONDS`.

# Turn right after driving forward
drivetrain.set_timeout(1, SECONDS)
drivetrain.drive_for(FORWARD, 25, INCHES)
drivetrain.turn_for(RIGHT, 90)

set_heading #

En kurs är den riktning roboten är vänd i, 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(heading, units)

Parametrar	Beskrivning
`heading`	Kursvärdet, i grader eller svängar, som ska ställas in för roboten. Detta kan vara ett heltal `integer` eller ett decimaltal (`float`).
`units`	Valfritt. Kursenheten: `DEGREES` (standard) eller `TURNS`Ett varv är lika med 360 grader.

# Face the new 0 degrees
drivetrain.set_heading(90, DEGREES)
drivetrain.turn_to_heading(0, DEGREES)

set_rotation #

Rotation är hur mycket roboten har roterat, mätt i grader eller varv. 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(rotation, units)

Parametrar	Beskrivning
`rotation`	Rotationsvärdet, i grader eller varv, som ska ställas in för roboten. Detta kan vara ett heltal `integer` eller ett decimaltal (`float`).
`units`	Valfritt. Rotationsenheten: `DEGREES` (standard) eller `TURNS`Ett varv är lika med 360 grader.

# Spin counterclockwise two times
drivetrain.set_rotation(720, DEGREES)
drivetrain.turn_to_rotation(0, DEGREES)

set_turn_threshold #

set_turn_threshold anger hur nära roboten måste komma en målvinkel innan en sväng är klar.

En mindre tröskel kan göra svängar mer exakta, men det kan ta längre tid för roboten att slutföra svängen. En större tröskel kan göra att svängar slutförs snabbare, men de kan vara mindre exakta.

Usage:
drivetrain.set_turn_threshold(value)

Parametrar	Beskrivning
`value`	Svängtröskeln, i grader. Detta kan vara ett heltal `integer` eller ett decimaltal (`float`). Standardsvängtröskeln är 1 grad.

# Set the turn threshold to 5 degrees
drivetrain.set_turn_threshold(5)

set_turn_constant #

set_turn_constant ändrar hur kraftigt roboten korrigerar sina svängar.

Ett högre värde gör att roboten korrigerar svängarna kraftigare. Ett lägre värde gör att roboten korrigerar svängarna mjukare. Standardvärdet är 1,0.

Usage:
drivetrain.set_turn_constant(value)

Parametrar	Beskrivning
`value`	Vridkonstanten. Detta kan vara ett decimaltal (`float`) från 0,1 till 4,0. Standardvärdet är 1,0.

# Increase the turn constant to 2.0
drivetrain.set_turn_constant(2.0)

Getters #

heading #

En kurs är den riktning roboten är vänd i, mätt i grader. heading returnerar robotens aktuella kurs från 0 till 359 grader.

Robotens startriktning är 0 grader.

Usage:
drivetrain.heading(units)

Parametrar	Beskrivning
`units`	Valfritt. Enheten att returnera kursen i: `DEGREES` (standard) eller `TURNS`Ett varv är lika med 360 grader.

# Display the heading after turning
drivetrain.turn_for(RIGHT, 450, DEGREES)
brain.screen.print("Heading: ")
brain.screen.print(drivetrain.heading())

rotation #

Rotation är hur mycket roboten har roterat, mätt i grader eller varv. I början av ett projekt sätts rotationsvärdet till 0 grader. 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.

Usage:
drivetrain.rotation(units)

Parametrar	Beskrivning
`units`	Valfritt. Enheten att returnera rotationen i: `DEGREES` (standard) eller `TURNS`Ett varv är lika med 360 grader.

# Display the rotation after turning
drivetrain.turn_for(RIGHT, 450, DEGREES)
brain.screen.print("Rotation: ")
brain.screen.print(drivetrain.rotation())

velocity #

velocity returnerar hur snabbt roboten kör.

Den kan returnera hastighet som en procentandel från -100 % till 100 %, i RPM från -127 varv/min till 127 varv/min, eller i VelocityUnits.DPSEtt positivt värde betyder att roboten kör framåt. Ett negativt värde betyder att roboten kör bakåt.

Usage:
drivetrain.velocity(units)

Parametrar	Beskrivning
`units`	Valfritt. Enheten att returnera hastighet i: `PERCENT` (standard), `RPM` (varv per minut) eller `VelocityUnits.DPS` (grader per sekund).

current #

current returnerar hur mycket elektrisk ström drivlinan använder, mätt i ampere (ampere). Ström är mängden elektricitet som flyter genom drivlinan.

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

Detta kan användas för att kontrollera om drivlinan har problem under en rörelse. Om strömmen förblir hög kan drivlinan bli varmare eller använda strömmen mindre effektivt.

Usage:
drivetrain.current(units)

Parametrar	Beskrivning
`units`	Valfritt. Enheten att returnera ström i: `CurrentUnits.AMP` (ampere, standard).

is_moving #

is_moving returnerar huruvida roboten rör 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ör sig.
False — Roboten rör sig inte.

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

Usage:
drivetrain.is_moving()

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

is_done #

is_done 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 drivlinmetoder som har parametern wait : drive_for, turn_for, turn_to_heading och turn_to_rotation.

Usage:
drivetrain.is_done()

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

is_turning #

is_turning returnerar huruvida roboten roterar, 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 snurrar.
False — Roboten snurrar inte.

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

Usage:
drivetrain.is_turning()

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

power #

power returnerar hur mycket effekt drivlinan använder, mätt i watt. Effekt visar hur snabbt drivlinan förbrukar energi.

Ett högre effektvärde innebär att drivlinan förbrukar energi snabbare. Detta kan hända när roboten trycker mot ett föremål eller försöker röra sig när den har fastnat.

Detta kan användas för att jämföra rörelser eller kontrollera om drivlinan har problem. Om effekten förblir hög kan drivlinan bli varmare eller använda energi mindre effektivt.

Usage:
drivetrain.power()

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

torque #

Vridmomentet visar hur hårt drivlinan kan trycka eller dra medan hjulen spinner.

torque returnerar hur mycket vridmoment drivlinan använder, mätt i Newtonmeter (Nm) eller tumpund (InLb).

Ett högre vridmomentvärde innebär att drivlinan trycker eller drar hårdare. Detta kan hända när roboten trycker mot ett föremål eller försöker röra sig när den har fastnat.

Detta kan användas för att kontrollera om drivlinan har problem eller för att jämföra hur mycket tryck olika rörelser behöver.

Usage:
drivetrain.torque(units)

Parametrar	Beskrivning
`units`	Valfritt. Enheten som vridmoment ska returneras i: `TorqueUnits.NM` (newtonmeter, standard) eller `TorqueUnits.INLB` (tumpund).

efficiency #

efficiency returnerar hur effektivt drivlinan använder kraft, som en procentandel från 0 % till 100 %.

Verkningsgrad visar hur mycket av drivlinans kraft som används för rörelse. Ett högre verkningsgradsvärde innebär att mer av drivlinans kraft används för rörelse. Ett lägre verkningsgradsvärde kan uppstå när drivlinan arbetar hårt men inte rör sig särskilt mycket, som när roboten har fastnat eller trycker mot ett föremål.

Detta kan användas för att jämföra rörelser eller kontrollera om drivlinan slösar kraft istället för att använda den till rörelse.

Usage:
drivetrain.efficiency()

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

temperature #

temperature returnerar drivlinans medeltemperatur i den valda temperaturenheten.

Temperaturen visar hur varma drivlinans motorer är. En högre temperatur innebär att motorerna blir varmare medan de arbetar. Motorerna bör hålla sig under 55 °C för att fortsätta arbeta med full prestanda.

Om motorerna blir för varma sänker de sin maximala ström för att skydda sig själva. Vid 70 °C slutar motorerna att gå tills de har svalnat.

Detta kan användas för att kontrollera om drivlinan blir för varm under upprepade rörelser, långa körningar eller när den trycker mot ett föremål.

Usage:
drivetrain.temperature(units)

Parametrar	Beskrivning
`units`	Valfritt. Enheten som temperaturen ska returneras i: `TemperatureUnits.CELSIUS` (standard) eller `TemperatureUnits.FAHRENHEIT`.

Konstruktörer #

Konstruktorer används för att skapa DriveTrain och SmartDrive objekt i kod. Detta är användbart när man konfigurerar en drivlina utan att använda fönstret Enheter.

Minst två Motor eller MotorGroup objekt måste skapas innan en drivlina skapas.

DriveTrain #

DriveTrain skapar en drivlina utan en tröghetssensor eller gyrosensor.

Usage:
DriveTrain(lm, rm, wheelTravel, trackWidth, wheelBase, units, externalGearRatio)

Parameter	Beskrivning
`lm`	Vänster motor eller motorgrupp.
`rm`	Höger motor eller motorgrupp.
`wheelTravel`	Valfritt. Drivlinans hjulomkrets. Standardvärdet är 300 millimeter.
`trackWidth`	Valfritt. Bredden mellan vänster och höger hjul. Standardinställningen är 320 millimeter.
`wheelBase`	Valfritt. Avståndet mellan fram- och bakhjulen. Standardvärdet är 320 millimeter.
`units`	Valfritt. Enheten för `wheelTravel`, `trackWidth`och `wheelBase`: `MM` (standard), `INCHES`eller `DistanceUnits.CM` (centimeter).
`externalGearRatio`	Valfritt. Utväxlingsförhållandet som används för att justera körsträckor om kugghjul används. Detta kan vara ett heltal `integer` eller ett decimaltal (`float`). Standardvärdet är 1,0.

# Create left and right drive motor objects
left_drive_smart = Motor(Ports.PORT1, 1.0, False)
right_drive_smart = Motor(Ports.PORT2, 1.0, True)

'''
Create a Drivetrain with the following values:
wheelTravel: 200
trackWidth: 173
wheelBase: 76
units: MM
externalGearRatio: 1
'''
drivetrain = DriveTrain(left_drive_smart, right_drive_smart, 200, 173, 76, MM, 1)

# Create two motor group objects for left and right motors
left_motor_a = Motor(Ports.PORT1, 1.0, False)
left_motor_b = Motor(Ports.PORT2, 1.0, False)
left_drive_smart = MotorGroup(left_motor_a, left_motor_b)

right_motor_a = Motor(Ports.PORT3, 1.0, True)
right_motor_b = Motor(Ports.PORT4, 1.0, True)
right_drive_smart = MotorGroup(right_motor_a, right_motor_b)

'''
Create a Drivetrain with the following values:
wheelTravel: 200
trackWidth: 173
wheelBase: 76
units: MM
externalGearRatio: 1
'''
drivetrain = DriveTrain(left_drive_smart, right_drive_smart, 200, 173, 76, MM, 1)

SmartDrive #

SmartDrive skapar en drivlina konfigurerad med en Tröghetssensor eller Gyrosensor.

Usage:
SmartDrive(lm, rm, g, wheelTravel, trackWidth, wheelBase, units, externalGearRatio)

Parameter	Beskrivning
`lm`	Vänster motor eller motorgrupp.
`rm`	Höger motor eller motorgrupp.
`g`	Den Tröghetssensor eller Gyrosensor som används av drivlinan.
`wheelTravel`	Valfritt. Drivlinans hjulomkrets. Standardvärdet är 300 millimeter.
`trackWidth`	Valfritt. Bredden mellan vänster och höger hjul. Standardinställningen är 320 millimeter.
`wheelBase`	Valfritt. Avståndet mellan fram- och bakhjulen. Standardvärdet är 320 millimeter.
`units`	Valfritt. Enheten för `wheelTravel`, `trackWidth`och `wheelBase`: `MM` (millimeter, standard) eller `INCHES`.
`externalGearRatio`	Valfritt. Utväxlingsförhållandet som används för att justera körsträckor om kugghjul används. Detta kan vara ett heltal `integer` eller ett decimaltal (`float`). Standardvärdet är 1,0.

# Create the Inertial Sensor
brain_inertial = Inertial()

# Make left and right drive motors
left_drive_smart = Motor(Ports.PORT1, 1.0, False)
right_drive_smart = Motor(Ports.PORT6, 1.0, True)

# Create a SmartDrive object with wheelTravel 200
drivetrain = SmartDrive(left_drive_smart, right_drive_smart, brain_inertial, 200)

Om du skapar en smart drivlina med flera motorer måste du skapa motorerna separat innan du grupperar dem i en motorgrupp.

# Create the Inertial Sensor
brain_inertial = Inertial()

# Create two motor groups for left and right motors
left_motor_a = Motor(Ports.PORT1, 1.0, False)
left_motor_b = Motor(Ports.PORT2, 1.0, False)
left_drive_smart = MotorGroup(left_motor_a, left_motor_b)

right_motor_a = Motor(Ports.PORT5, 1.0, True)
right_motor_b = Motor(Ports.PORT6, 1.0, True)
right_drive_smart = MotorGroup(right_motor_a, right_motor_b)

# Create a SmartDrive object with wheelTravel 200 mm
drivetrain = SmartDrive(left_drive_smart, right_drive_smart, brain_inertial, 200)