Aandrijving#

Invoering #

De VEX IQ (2e generatie) robot gebruikt een aandrijfmechanisme om te rijden en te draaien. Een aandrijfmechanisme bestaat uit motoren en wielen die samenwerken om de robot te bewegen.

Een geconfigureerde aandrijving kan gebruikmaken van een aangesloten Gyroscoopsensor, de ingebouwde Inertiesensor van de Brain, of helemaal geen sensor. Wanneer een sensor wordt gebruikt, gebruikt de aandrijving deze om de robot nauwkeurig te laten bewegen en draaien. Aan het begin van elk project kalibreert de aandrijving de sensor automatisch. Houd de robot tijdens de kalibratie ongeveer 2 seconden stil, zodat de robot correct kan bewegen en draaien.

Op deze pagina wordt drivetrain als voorbeeld van een aandrijflijnnaam gebruikt. Vervang dit door uw eigen geconfigureerde naam indien nodig.

Er zijn veel manieren om de aandrijflijn te programmeren. Hieronder vindt u een lijst met alle methoden voor het programmeren van de aandrijflijn:

Acties — Beweeg en draai de robot.

drive — Laat de robot oneindig vooruit of achteruit bewegen.
drive_for — Verplaatst de robot vooruit of achteruit over een specifieke afstand.
turn — Draait de robot permanent naar links of rechts.
turn_for — Draait de robot naar links of rechts over een specifiek aantal graden.
turn_to_heading — Draait de robot naar een specifieke richting tussen -359 en 359 graden. De robot draait in de kortste richting om de doelrichting te bereiken.
turn_to_rotation — Draait de robot naar een specifieke rotatie.
stop — Stopt de beweging van de robot.
calibrate_drivetrain — Kalibreert de sensor die is geconfigureerd met de aandrijflijn.

Mutators — Aandrijfinstellingen aanpassen.

set_drive_velocity — Vertelt de robot hoe snel hij moet rijden.
set_turn_velocity — Vertelt de robot hoe snel hij moet draaien.
set_stopping — Geeft aan hoe de robot stopt met bewegen: door te remmen, uit te rollen of te wachten.
set_timeout — Stelt in hoeveel tijd de robot nodig heeft om een beweging te voltooien.
set_heading — Wijzigt de huidige richting van de robot naar een nieuwe richting.
set_rotation — Wijzigt de huidige rotatie van de robot naar een nieuwe rotatie.
set_turn_threshold — Geeft aan hoe dicht de robot bij een doelhoek moet komen voordat een bocht is voltooid.
set_turn_constant — Wijzigt hoe sterk de robot zijn bochten corrigeert.

Getters — Controleer de bewegingsstatus.

heading — Geeft de huidige richting van de robot weer, van 0 tot 359 graden.
rotation — Geeft de huidige rotatie van de robot terug.
velocity — Geeft aan hoe snel de robot rijdt.
current — Geeft aan hoeveel elektrische stroom de aandrijflijn verbruikt.
is_moving — Geeft als Booleaanse waarde aan of de robot beweegt.
is_done — Geeft als Booleaanse waarde aan of de robot klaar is met bewegen.
is_turning — Geeft als Booleaanse waarde aan of de robot aan het draaien is.
power — Geeft aan hoe snel de aandrijving energie verbruikt.
torque — Geeft aan hoeveel koppel de aandrijflijn gebruikt.
efficiency — Geeft aan hoe efficiënt de aandrijflijn energie gebruikt.
temperature — Geeft aan hoe warm de aandrijflijn is.

Constructeurs — Maak en configureer handmatig de aandrijflijn.

DriveTrain — Creëert een aandrijflijn zonder gyroscoopsensor of traagheidssensor.
SmartDrive — Creëert een aandrijflijn met een gyroscoopsensor of traagheidssensor.

Acties #

drive #

drive de robot beweegt oneindig vooruit of achteruit. De robot blijft bewegen totdat er een andere actie wordt gegeven, zoals draaien of stoppen.

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

Parameters	Beschrijving
`direction`	De richting waarin de robot beweegt: `FORWARD` of `REVERSE`.
`velocity`	Optioneel. De snelheid waarmee gereden moet worden, van 0% tot 100% bij gebruik van `PERCENT`, van 0 tot 120 rpm bij gebruik van `RPM`, of van 0 tot 720 graden per seconde bij gebruik van `VelocityUnits.DPS`Dit kan een `integer` of een decimaal getal (`float`) zijn. Als er geen snelheid wordt opgegeven, rijdt de robot met de huidige rijsnelheid.
`units`	Optioneel. De snelheidseenheid: `PERCENT` (standaard), `RPM` (rotaties per minuut) of `VelocityUnits.DPS` (graden per seconde).

# 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 verplaatst de robot vooruit of achteruit over een bepaalde afstand. Het project wacht tot de robot klaar is met bewegen voordat de volgende regel code wordt uitgevoerd.

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

Parameters	Beschrijving
`direction`	De richting waarin de robot beweegt: `FORWARD` of `REVERSE`.
`distance`	De afstand die de robot aflegt. Dit kan een geheel getal `integer` ) of een decimaal getal (`float` ) zijn.
`units`	Optioneel. De afstandseenheid: `INCHES` (standaard), `MM` (millimeter) of `DistanceUnits.CM` (centimeter).
`velocity`	Optioneel. De snelheid waarmee gereden moet worden, van 0% tot 100% bij gebruik van `PERCENT`, van 0 tot 120 rpm bij gebruik van `RPM`, of van 0 tot 720 graden per seconde bij gebruik van `VelocityUnits.DPS`Dit kan een `integer` of een decimaal getal (`float`) zijn. Als er geen snelheid wordt opgegeven, rijdt de robot met de huidige rijsnelheid.
`units_v`	Optioneel. De snelheidseenheid: `RPM` (rotaties per minuut, standaard), `PERCENT`of `VelocityUnits.DPS` (graden per seconde).
`wait`	Optioneel. `wait=True` (standaard) zorgt ervoor dat het project wacht totdat de robot klaar is met bewegen voordat de volgende regel code wordt uitgevoerd. `wait=False` zorgt ervoor dat de volgende regel code direct wordt uitgevoerd.

# 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 de robot draait oneindig naar links of rechts. De robot blijft draaien totdat er een andere actie wordt uitgevoerd, zoals rijden of stoppen.

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

Parameters	Beschrijving
`direction`	De richting waarin de robot draait: `LEFT` of `RIGHT`.
`velocity`	Optioneel. De draaisnelheid kan worden ingesteld van 0% tot 100% bij gebruik van `PERCENT`, van 0 tot 120 rpm bij gebruik van `RPM`, of van 0 tot 720 graden per seconde bij gebruik van `VelocityUnits.DPS`Dit kan een `integer` of een decimaal getal (`float`) zijn. Als er geen snelheid wordt opgegeven, draait de robot met de huidige draaisnelheid.
`units`	Optioneel. De snelheidseenheid: `RPM` (rotaties per minuut, standaard), `PERCENT`of `VelocityUnits.DPS` (graden per seconde).

# 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 draait de robot naar links of rechts over een specifiek aantal graden of omwentelingen. De draaiing is relatief ten opzichte van de huidige positie van de robot. Het project wacht totdat de robot klaar is met draaien voordat de volgende regel code wordt uitgevoerd.

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

Parameters	Beschrijving
`direction`	De richting waarin de robot draait: `LEFT` of `RIGHT`.
`angle`	De draaihoek van de robot. Dit kan een geheel getal `integer` of een decimaal getal (`float` ) zijn.
`units`	Optioneel. De draai-eenheid: `DEGREES` (standaard) of `TURNS`Eén draai is gelijk aan 360 graden.
`velocity`	Optioneel. De draaisnelheid kan worden ingesteld van 0% tot 100% bij gebruik van `PERCENT`, van 0 tot 120 rpm bij gebruik van `RPM`, of van 0 tot 720 graden per seconde bij gebruik van `VelocityUnits.DPS`Dit kan een `integer` of een decimaal getal (`float`) zijn. Als er geen snelheid wordt opgegeven, draait de robot met de huidige draaisnelheid.
`units_v`	Optioneel. De snelheidseenheid: `RPM` (rotaties per minuut, standaard), `PERCENT`of `VelocityUnits.DPS` (graden per seconde).
`wait`	Optioneel. `wait=True` (standaard) zorgt ervoor dat het project wacht totdat de robot klaar is met draaien voordat de volgende regel code wordt uitgevoerd. `wait=False` zorgt ervoor dat de volgende regel code direct wordt uitgevoerd.

# 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 #

Een koers is de richting waarin de robot kijkt, gemeten in graden. turn_to_heading draait de robot in een specifieke richting tussen -359 en 359 graden. De robot draait in de kortste richting om de doelkoers te bereiken.

De beginrichting van de robot is 0 graden.

Het project wacht tot de robot klaar is met draaien voordat de volgende regel code wordt uitgevoerd.

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

Parameters	Beschrijving
`angle`	De richting waarin de robot moet kijken, in graden. Dit kan een geheel getal `integer` of een decimaal getal (`float`) zijn van -359 tot 359.
`units`	Optioneel. De richtingseenheid: `DEGREES` (standaard).
`velocity`	Optioneel. De draaisnelheid kan worden ingesteld van 0% tot 100% bij gebruik van `PERCENT`, van 0 tot 120 rpm bij gebruik van `RPM`, of van 0 tot 720 graden per seconde bij gebruik van `VelocityUnits.DPS`Dit kan een `integer` of een decimaal getal (`float`) zijn. Als er geen snelheid wordt opgegeven, draait de robot met de huidige draaisnelheid.
`units_v`	Optioneel. De snelheidseenheid: `PERCENT` (standaard), `RPM` (rotaties per minuut) of `VelocityUnits.DPS` (graden per seconde).
`wait`	Optioneel. `wait=True` (standaard) zorgt ervoor dat het project wacht totdat de robot klaar is met draaien voordat de volgende regel code wordt uitgevoerd. `wait=False` zorgt ervoor dat de volgende regel code direct wordt uitgevoerd.

# 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 draait de robot naar een specifieke rotatie.

Rotatie is de mate waarin de robot is gedraaid, gemeten in graden of omwentelingen. Aan het begin van een project wordt de rotatiewaarde ingesteld op 0 graden. Rotatie kan ook worden ingesteld met behulp van de methode set_rotation.

De rotatiewaarden zijn absoluut. Dit betekent dat de draairichting afhangt van de huidige rotatie van de robot. Naar rechts draaien vergroot de rotatie, naar links draaien verkleint de rotatie.

Als de robot bijvoorbeeld begint bij 0 graden en je draait hem 720 graden, dan draait hij twee keer naar rechts. Als je hem vervolgens 360 graden draait, draait hij één keer naar links, omdat 360 minder is dan 720.

Het project wacht tot de robot klaar is met draaien voordat de volgende regel code wordt uitgevoerd.

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

Parameters	Beschrijving
`angle`	De rotatiewaarde, in graden of omwentelingen, waarnaar de robot zal draaien. Dit kan een geheel getal `integer` of een decimaal getal (`float` ) zijn.
`units`	Optioneel. De rotatie-eenheid: `DEGREES` (standaard) of `TURNS`Eén omwenteling is gelijk aan 360 graden.
`velocity`	Optioneel. De draaisnelheid kan worden ingesteld van 0% tot 100% bij gebruik van `PERCENT`, van 0 tot 120 rpm bij gebruik van `RPM`, of van 0 tot 720 graden per seconde bij gebruik van `VelocityUnits.DPS`Dit kan een `integer` of een decimaal getal (`float`) zijn. Als er geen snelheid wordt opgegeven, draait de robot met de huidige draaisnelheid.
`units_v`	Optioneel. De snelheidseenheid: `PERCENT` (standaard), `RPM` (rotaties per minuut) of `VelocityUnits.DPS` (graden per seconde).
`wait`	Optioneel. `wait=True` (standaard) zorgt ervoor dat het project wacht totdat de robot klaar is met draaien voordat de volgende regel code wordt uitgevoerd. `wait=False` zorgt ervoor dat de volgende regel code direct wordt uitgevoerd.

# 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 stopt de beweging van de robot.

Usage:
drivetrain.stop(mode)

Parameters	Beschrijving
`mode`	Optioneel. Hoe de robot stopt: `BRAKE` (standaard), `BRAKE`of `COAST` `COAST` — Stopt onmiddellijk. `HOLD` — Vertraagt tot stilstand. `HOLD` — Stopt onmiddellijk en houdt de wielen in positie.

Parameters

Beschrijving

mode

Optioneel. Hoe de robot stopt: BRAKE (standaard), BRAKEof COAST

COAST — Stopt onmiddellijk.
HOLD — Vertraagt tot stilstand.
HOLD — Stopt onmiddellijk en houdt de wielen in positie.

# 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 is een ingebouwde functie die de gyroscoopsensor of traagheidssensor kalibreert die met de aandrijflijn is geconfigureerd.

Kalibratie zorgt ervoor dat de sensor beweging correct meet. Houd de robot tijdens de kalibratie ongeveer 2 seconden stil. Als de robot beweegt tijdens de kalibratie, meet de sensor de beweging mogelijk niet correct.

Het project wacht tot de kalibratie is voltooid voordat de volgende regel code wordt uitgevoerd.

Let op: Deze functie kan niet binnen VS Code worden gebruikt.

Usage:
calibrate_drivetrain()

Parameters	Beschrijving
	Deze functie heeft geen parameters.

Mutators #

set_drive_velocity #

set_drive_velocity vertelt de robot hoe snel hij moet rijden. Een hoger percentage zorgt ervoor dat de robot sneller rijdt en een lager percentage zorgt ervoor dat de robot langzamer rijdt.

Elk project begint standaard met de robot die op 50% van zijn maximale snelheid rijdt.

Let op: Een hogere snelheid zorgt ervoor dat de robot sneller rijdt, maar mogelijk minder nauwkeurig. Een lagere snelheid zorgt ervoor dat de robot langzamer rijdt, maar mogelijk nauwkeuriger.

Usage:
drivetrain.set_drive_velocity(velocity, units)

Parameters	Beschrijving
`velocity`	De snelheid waarmee gereden moet worden, van 0% tot 100% bij gebruik van `PERCENT`, van 0 tot 120 rpm bij gebruik van `RPM`, of van 0 tot 720 graden per seconde bij gebruik van `VelocityUnits.DPS`Dit kan een `integer` of een decimaal getal (`float` ) zijn.
`units`	Optioneel. De snelheidseenheid: `PERCENT` (standaard), `RPM` (rotaties per minuut) of `VelocityUnits.DPS` (graden per seconde).

# 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 vertelt de robot hoe snel hij moet draaien. Een hoger percentage zorgt ervoor dat de robot sneller draait en een lager percentage zorgt ervoor dat de robot langzamer draait.

Elk project begint standaard met de robot die met 50% snelheid draait.

Let op: Een hogere snelheid zorgt ervoor dat de robot sneller draait, maar mogelijk minder nauwkeurig. Een lagere snelheid zorgt ervoor dat de robot langzamer draait, maar mogelijk nauwkeuriger.

Usage:
drivetrain.set_turn_velocity(velocity, units)

Parameters	Beschrijving
`velocity`	De draaisnelheid van 0% tot 100% bij gebruik van `PERCENT`, van 0 tot 120 rpm bij gebruik van `RPM`, of van 0 tot 720 graden per seconde bij gebruik van `VelocityUnits.DPS`Dit kan een `integer` of een decimaal getal (`float` ) zijn.
`units`	Optioneel. De snelheidseenheid: `PERCENT` (standaard), `RPM` (rotaties per minuut) of `VelocityUnits.DPS` (graden per seconde).

# 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 bepaalt hoe de robot stopt met bewegen: door te remmen, uit te rollen of stil te staan.

Usage:
drivetrain.set_stopping(mode)

Parameters	Beschrijving
`mode`	Hoe de robot stopt: `BRAKE` — Stopt onmiddellijk. `COAST` — Vertraagt tot stilstand. `HOLD` — Stopt onmiddellijk en houdt de wielen in positie.

Parameters

Beschrijving

mode

Hoe de robot stopt:

BRAKE — Stopt onmiddellijk.
COAST — Vertraagt tot stilstand.
HOLD — Stopt onmiddellijk en houdt de wielen in positie.

Als deze methode niet wordt gebruikt, zal de robot BRAKE gebruiken bij het stoppen.

set_timeout #

set_timeout bepaalt hoeveel tijd de robot krijgt om een beweging te voltooien. Als de robot de beweging niet binnen die tijd kan voltooien, stopt hij met proberen en gaat hij verder met de volgende regel code. Dit voorkomt dat de robot vastloopt tijdens een beweging.

Usage:
drivetrain.set_timeout(value, units)

Parameters	Beschrijving
`value`	De hoeveelheid tijd die de robot kan proberen om een beweging te voltooien. Dit kan een positief geheel getal zijn `integer` ) of een decimaal getal (`float`).
`units`	Optioneel. De tijdseenheid: `MSEC` (milliseconden, standaard) of `SECONDS`.

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

set_heading #

Een koers is de richting waarin de robot kijkt, gemeten in graden. set_heading verandert de huidige koers van de robot naar een nieuwe koerswaarde.

Als de robot bijvoorbeeld naar rechts is gedraaid, zorgt het instellen van de richting op 0 graden ervoor dat die naar rechts gerichte positie de nieuwe 0 graden wordt. Vervolgens kan de robot zich op basis van die nieuwe richting naar andere posities draaien.

Usage:
drivetrain.set_heading(heading, units)

Parameters	Beschrijving
`heading`	De richtingswaarde, in graden of omwentelingen, die voor de robot moet worden ingesteld. Dit kan een geheel getal `integer` ) of een decimaal getal (`float` ) zijn.
`units`	Optioneel. De richtingseenheid: `DEGREES` (standaard) of `TURNS`Eén draai is gelijk aan 360 graden.

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

set_rotation #

Rotatie geeft aan hoeveel de robot is gedraaid, gemeten in graden of omwentelingen. Aan het begin van een project wordt de rotatiewaarde ingesteld op 0 graden. set_rotation wordt de huidige rotatie van de robot gewijzigd naar een nieuwe waarde.

Als de robot bijvoorbeeld twee volledige draaien naar rechts heeft gemaakt, is de rotatiewaarde 720 graden. Door de rotatie op 0 graden te zetten, wordt die rotatiewaarde gereset van 720 naar 0 graden. De robot kan vervolgens draaien op basis van die nieuwe waarde.

Usage:
drivetrain.set_rotation(rotation, units)

Parameters	Beschrijving
`rotation`	De rotatiewaarde, in graden of omwentelingen, die voor de robot moet worden ingesteld. Dit kan een geheel getal `integer` of een decimaal getal (`float` ) zijn.
`units`	Optioneel. De rotatie-eenheid: `DEGREES` (standaard) of `TURNS`Eén omwenteling is gelijk aan 360 graden.

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

set_turn_threshold #

set_turn_threshold stelt in hoe dicht de robot bij een doelhoek moet komen voordat een bocht is voltooid.

Een kleinere drempelwaarde kan leiden tot nauwkeurigere bochten, maar de robot heeft mogelijk langer nodig om de bocht te voltooien. Een grotere drempelwaarde kan leiden tot snellere bochten, maar deze zijn mogelijk minder nauwkeurig.

Usage:
drivetrain.set_turn_threshold(value)

Parameters	Beschrijving
`value`	De draaidrempel, in graden. Dit kan een geheel getal `integer` ) of een decimaal getal (`float`) zijn. De standaard draaidrempel is 1 graad.

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

set_turn_constant #

set_turn_constant verandert hoe sterk de robot zijn bochten corrigeert.

Een hogere waarde zorgt ervoor dat de robot scherpere bochten corrigeert. Een lagere waarde zorgt ervoor dat de robot zachtere bochten corrigeert. De standaardwaarde is 1,0.

Usage:
drivetrain.set_turn_constant(value)

Parameters	Beschrijving
`value`	De draaiconstante. Dit kan een decimaal getal zijn (`float`) van 0,1 tot 4,0. De standaardwaarde is 1,0.

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

Getters #

heading #

Een koers is de richting waarin de robot kijkt, gemeten in graden. heading geeft de huidige koers van de robot weer, van 0 tot 359 graden.

De beginrichting van de robot is 0 graden.

Usage:
drivetrain.heading(units)

Parameters	Beschrijving
`units`	Optioneel. De eenheid waarin de koers moet worden geretourneerd: `DEGREES` (standaard) of `TURNS`Eén draai is gelijk aan 360 graden.

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

rotation #

Rotatie geeft aan hoeveel de robot is gedraaid, gemeten in graden of omwentelingen. Aan het begin van een project wordt de rotatiewaarde ingesteld op 0 graden. rotation geeft de huidige rotatie van de robot weer.

Naar rechts draaien vergroot de rotatie, en naar links draaien verkleint de rotatie. Twee volledige draaien naar rechts resulteren bijvoorbeeld in een rotatie van 720 graden.

Usage:
drivetrain.rotation(units)

Parameters	Beschrijving
`units`	Optioneel. De eenheid waarin de rotatie moet worden weergegeven: `DEGREES` (standaard) of `TURNS`Eén omwenteling is gelijk aan 360 graden.

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

velocity #

velocity geeft aan hoe snel de robot rijdt.

Het kan de snelheid weergeven als een percentage van -100% tot 100%, in RPM van -127 rpm tot 127 rpm, of in VelocityUnits.DPSEen positieve waarde betekent dat de robot vooruit rijdt. Een negatieve waarde betekent dat de robot achteruit rijdt.

Usage:
drivetrain.velocity(units)

Parameters	Beschrijving
`units`	Optioneel. De eenheid waarin de snelheid moet worden weergegeven: `PERCENT` (standaard), `RPM` (rotaties per minuut) of `VelocityUnits.DPS` (graden per seconde).

current #

current geeft aan hoeveel elektrische stroom de aandrijflijn verbruikt, gemeten in ampère. Stroomsterkte is de hoeveelheid elektriciteit die door de aandrijflijn stroomt.

Een hogere stroomwaarde betekent dat de aandrijving meer elektrische stroom verbruikt. Dit kan gebeuren wanneer de robot tegen een object duwt of probeert te bewegen terwijl hij vastzit.

Hiermee kunt u controleren of de aandrijving tijdens een beweging moeite heeft. Als de stroomsterkte hoog blijft, kan de aandrijving warmer worden of minder efficiënt met energie omgaan.

Usage:
drivetrain.current(units)

Parameters	Beschrijving
`units`	Optioneel. De eenheid waarin de stroom moet worden geretourneerd: `CurrentUnits.AMP` (ampère, standaard).

is_moving #

is_moving geeft als Booleaanse waarde aan of de robot beweegt. Dit kan worden gebruikt om de timing van andere gedragingen te regelen op basis van de beweging van de robot.

True — De robot beweegt.
False — De robot beweegt niet.

Deze methode werkt samen met de volgende Drivetrain-methoden die de parameter wait hebben: drive_for, turn_for, turn_to_heading, en turn_to_rotation.

Usage:
drivetrain.is_moving()

Parameters	Beschrijving
	Deze methode heeft geen parameters.

is_done #

is_done geeft als Booleaanse waarde aan of de robot klaar is met bewegen. Dit kan worden gebruikt om de timing van andere acties te sturen op basis van de beweging van de robot.

True — De robot is klaar met bewegen.
False — De robot beweegt nog steeds.

Deze methode werkt samen met de volgende Drivetrain-methoden die de parameter wait hebben: drive_for, turn_for, turn_to_heading, en turn_to_rotation.

Usage:
drivetrain.is_done()

Parameters	Beschrijving
	Deze methode heeft geen parameters.

is_turning #

is_turning geeft als Booleaanse waarde aan of de robot aan het draaien is. Dit kan worden gebruikt om de timing van andere gedragingen te regelen op basis van de beweging van de robot.

True — De robot draait.
False — De robot draait niet.

Deze methode werkt samen met de volgende Drivetrain-methoden die de parameter wait hebben: turn_for, turn_to_heading, en turn_to_rotation.

Usage:
drivetrain.is_turning()

Parameters	Beschrijving
	Deze methode heeft geen parameters.

power #

power geeft aan hoeveel vermogen de aandrijving verbruikt, gemeten in watt. Vermogen laat zien hoe snel de aandrijving energie verbruikt.

Een hogere vermogenswaarde betekent dat de aandrijving sneller energie verbruikt. Dit kan gebeuren wanneer de robot tegen een object duwt of probeert te bewegen terwijl hij vastzit.

Dit kan worden gebruikt om bewegingen te vergelijken of te controleren of de aandrijving het moeilijk heeft. Als het vermogen constant hoog blijft, kan de aandrijving warmer worden of minder efficiënt met energie omgaan.

Usage:
drivetrain.power()

Parameters	Beschrijving
	Deze methode heeft geen parameters.

torque #

Het koppel geeft aan hoeveel kracht de aandrijving kan uitoefenen terwijl de wielen draaien.

torque geeft aan hoeveel koppel de aandrijflijn gebruikt, gemeten in Newtonmeter (Nm) of inch-pounds (InLb).

Een hogere koppelwaarde betekent dat de aandrijving harder duwt of trekt. Dit kan gebeuren wanneer de robot tegen een object duwt of probeert te bewegen terwijl hij vastzit.

Dit kan worden gebruikt om te controleren of de aandrijving moeite heeft of om te vergelijken hoeveel kracht verschillende bewegingen vereisen.

Usage:
drivetrain.torque(units)

Parameters	Beschrijving
`units`	Optioneel. De eenheid waarin het koppel moet worden geretourneerd: `TorqueUnits.NM` (newtonmeter, standaard) of `TorqueUnits.INLB` (inch-pond).

efficiency #

efficiency geeft aan hoe efficiënt de aandrijflijn het vermogen gebruikt, als een percentage van 0% tot 100%.

Het rendement geeft aan hoeveel van het vermogen van de aandrijving wordt gebruikt voor beweging. Een hogere efficiëntiewaarde betekent dat er meer vermogen van de aandrijving wordt gebruikt om te bewegen. Een lagere efficiëntiewaarde kan voorkomen wanneer de aandrijving hard werkt maar weinig beweging genereert, bijvoorbeeld wanneer de robot vastzit of tegen een object aan duwt.

Dit kan worden gebruikt om bewegingen te vergelijken of te controleren of de aandrijving energie verspilt in plaats van deze te gebruiken voor beweging.

Usage:
drivetrain.efficiency()

Parameters	Beschrijving
	Deze methode heeft geen parameters.

temperature #

temperature geeft de gemiddelde temperatuur van de aandrijflijn weer in de geselecteerde temperatuureenheid.

De temperatuur geeft aan hoe warm de motoren van de aandrijflijn zijn. Een hogere temperatuur betekent dat de motoren warmer worden tijdens het gebruik. De motoren moeten onder de 55 °C blijven om optimaal te blijven presteren.

Als de motoren te heet worden, verlagen ze hun maximale stroomsterkte ter bescherming. Bij 70 °C stoppen de motoren met draaien totdat ze zijn afgekoeld.

Hiermee kan worden gecontroleerd of de aandrijving te heet wordt tijdens herhaalde bewegingen, lange ritten of wanneer deze tegen een object aan duwt.

Usage:
drivetrain.temperature(units)

Parameters	Beschrijving
`units`	Optioneel. De eenheid waarin de temperatuur moet worden weergegeven: `TemperatureUnits.CELSIUS` (standaard) of `TemperatureUnits.FAHRENHEIT`.

Constructeurs #

Constructors worden gebruikt om in de code DriveTrain en SmartDrive -objecten te creëren. Dit is handig bij het configureren van een aandrijflijn zonder het venster Apparaten te gebruiken.

Er moeten minimaal twee Motor of MotorGroup objecten worden aangemaakt voordat een aandrijflijn kan worden gecreëerd.

DriveTrain #

DriveTrain creëert een aandrijflijn zonder een Inertiesensor of Gyroscoopsensor.

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

Parameter	Beschrijving
`lm`	De linker motor of motorgroep.
`rm`	De rechter motor of motorgroep.
`wheelTravel`	Optioneel. De omtrek van de aandrijfwielen. De standaardwaarde is 300 millimeter.
`trackWidth`	Optioneel. De afstand tussen het linker- en rechterwiel. De standaardwaarde is 320 millimeter.
`wheelBase`	Optioneel. De afstand tussen de voor- en achterwielen. De standaardwaarde is 320 millimeter.
`units`	Optioneel. De eenheid voor `wheelTravel`, `trackWidth`en `wheelBase`: `MM` (standaard), `INCHES`of `DistanceUnits.CM` (centimeter).
`externalGearRatio`	Optioneel. De overbrengingsverhouding die wordt gebruikt om de aandrijfafstand aan te passen als er versnellingen worden gebruikt. Dit kan een geheel getal `integer` ) of een decimaal getal (`float`) zijn. De standaardwaarde is 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 creëert een aandrijflijn die is geconfigureerd met een Inertiesensor of Gyroscoopsensor.

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

Parameter	Beschrijving
`lm`	De linker motor of motorgroep.
`rm`	De rechter motor of motorgroep.
`g`	De traagheidssensor of gyroscoopsensor die door de aandrijflijn wordt gebruikt.
`wheelTravel`	Optioneel. De omtrek van de aandrijfwielen. De standaardwaarde is 300 millimeter.
`trackWidth`	Optioneel. De afstand tussen het linker- en rechterwiel. De standaardwaarde is 320 millimeter.
`wheelBase`	Optioneel. De afstand tussen de voor- en achterwielen. De standaardwaarde is 320 millimeter.
`units`	Optioneel. De eenheid voor `wheelTravel`, `trackWidth`en `wheelBase`: `MM` (millimeter, standaard) of `INCHES`.
`externalGearRatio`	Optioneel. De overbrengingsverhouding die wordt gebruikt om de aandrijfafstand aan te passen als er versnellingen worden gebruikt. Dit kan een geheel getal `integer` ) of een decimaal getal (`float`) zijn. De standaardwaarde is 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)

Als je een slimme aandrijving met meerdere motoren maakt, moet je de motoren eerst afzonderlijk aanmaken voordat je ze in een motorgroep samenvoegt.

# 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)