Robotspecifieke Python#

Invoering #

De Hero Bot, Dex, beschikt over twee motoropties, een AI-visiesensor, een optische sensor en een GPS-sensor (Game Positioning System).

Alle standaard VEXcode VR-methoden zijn beschikbaar voor gebruik in de V5 25-26 Push Back Playground.

Hieronder vindt u een lijst met alle beschikbare robotspecifieke methoden:

Aandrijving – Beweeg en stuur de robot.

Acties
- 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.
- turn_to_rotation — Draait de robot naar een specifieke rotatie.
- stop — Stopt de beweging van de robot.
Mutators
- 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_timeout — Stelt in hoeveel tijd de robot nodig heeft om een beweging te voltooien.
- set_drive_velocity — Vertelt de robot hoe snel hij moet rijden.
- set_turn_velocity — Vertelt de robot hoe snel hij moet draaien.
Verdieners
- heading — Geeft de huidige richting van de robot weer, van 0 tot 359,99 graden.
- rotation — Geeft de huidige rotatie van de robot terug.
- is_done — Geeft als Booleaanse waarde aan of de robot klaar is met bewegen.
- is_moving — Geeft als Booleaanse waarde aan of de robot beweegt.
- velocity — Geeft aan hoe snel de robot rijdt.

Beweging – Beweeg en volg de motoren van de robot.

Acties
- spin — Laat een motor oneindig lang vooruit of achteruit draaien.
- spin_for — Laat een motor een specifieke afstand draaien.
- spin_to_position — Draait een motor naar een specifieke positie.
- stop — Stopt een motor met draaien.
Mutators
- set_position — Wijzigt de huidige positie van de motor naar een nieuwe waarde.
- set_velocity — Vertelt een motor hoe snel hij moet draaien.
- set_timeout — Stelt in hoeveel tijd een motor nodig heeft om een beweging te voltooien.
Verdieners
- is_done — Geeft als Booleaanse waarde aan of de motor klaar is met bewegen.
- is_spinning — Geeft als Booleaanse waarde aan of de motor draait.
- position — Geeft de huidige positie van de motor terug.
- velocity — Geeft aan hoe snel de motor draait.

AI Vision - Leg objecten vast en analyseer ze met behulp van de AI Vision-sensor.

Verdieners
- take_snapshot – Retourneert een tuple van gedetecteerde objecten voor een specifieke signatuur.
Eigenschappen
- width – Breedte van het gedetecteerde object in pixels.
- height – Hoogte van het gedetecteerde object in pixels.
- centerX – X-positie van het middelpunt van het object in pixels.
- centerY – Y-positie van het middelpunt van het object in pixels.
- originX – X-positie van de linkerbovenhoek van het object in pixels.
- originY – Y-positie van de linkerbovenhoek van het object in pixels.
- id – Classificatie of tag-ID van het object.

Console – Waarden afdrukken naar de console en monitoren.

Afdrukken
- brain.screen.print — Geeft tekst, getallen of variabele waarden weer in de console.
- brain.screen.next_row — Verplaatst de consolecursor naar het begin van de volgende regel.
- brain.screen.clear_screen — Verwijdert alle rijen uit de console.
Monitor
- monitor_variable — Voegt een of meer vooraf gedefinieerde variabelen toe aan het tabblad Monitor.
- monitor_sensor — Voegt een of meer sensorwaarden toe aan het tabblad Monitor.

Waarneming - Gebruik de verschillende sensoren van de robot.

Optisch
- is_near_object – Geeft aan of de optische sensor een object binnen bereik detecteert.
- color – Geeft de kleur terug die door de optische sensor is gedetecteerd.
- brightness – Geeft de hoeveelheid licht terug die door het object wordt weerkaatst.
- hue – Geeft de tint terug die door de optische sensor is gedetecteerd.
- object_detected – Registreert een functie die wordt aangeroepen wanneer de optische sensor een object detecteert.
- object_lost – Registreert een functie die moet worden aangeroepen wanneer de optische sensor een object verliest.
GPS
- x_position – Geeft de huidige x-coördinaat van een GPS-sensor in het veld terug.
- y_position – Geeft de huidige y-coördinaat van een GPS-sensor in het veld terug.
- heading – Geeft de richting terug waarin de robot momenteel kijkt, gebaseerd op de metingen van de GPS-sensor van 0 tot 359 graden.

De voorbeelden op deze pagina gebruiken de standaard startpositie van de Playground.

Aandrijving #

De aandrijving bepaalt hoe de VR-robot rijdt en stuurt. De aandrijving kan vooruit of achteruit bewegen, naar links of rechts draaien, koersen volgen en zijn rotatie bijhouden.

Acties #

drijfveer #

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)

Parameters	Beschrijving
`direction`	De richting waarin de robot beweegt: `FORWARD` of `REVERSE`.

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

# VR threads — Do not delete
vr_thread(main)

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, 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) of `MM` (millimeter).
`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.

def main():
    # Drive forward and backward
    drivetrain.drive_for(FORWARD, 200, MM)
    drivetrain.drive_for(REVERSE, 200, MM)

# VR threads — Do not delete
vr_thread(main)

draai #

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)

Parameters	Beschrijving
`direction`	De richting waarin de robot draait: `LEFT` of `RIGHT`.

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

# VR threads — Do not delete
vr_thread(main)

turn_for draait de robot naar links of rechts over een specifiek aantal graden. 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, wait)

Parameters	Beschrijving
`direction`	De richting waarin de robot draait: `LEFT` of `RIGHT`.
`angle`	Het aantal graden dat de robot draait. Dit kan een geheel getal `integer` ) of een decimaal getal (`float` ) zijn.
`units`	Optioneel. De rotatie-eenheid: `DEGREES` (standaard).
`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.

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

# VR threads — Do not delete
vr_thread(main)

koptekst #

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, 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 rotatie-eenheid: `DEGREES` (standaard).
`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.

def main():
    # 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)

# VR threads — Do not delete
vr_thread(main)

draai_naar_rotatie #

turn_to_rotation draait de robot naar een specifieke rotatie.

Rotatie is de mate waarin de robot is gedraaid, gemeten in graden. 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, wait)

Parameters	Beschrijving
`angle`	De rotatiewaarde, in graden, waarnaar de robot zal draaien. Dit kan een geheel getal `integer` ) of een decimaal getal (`float` ) zijn.
`units`	Optioneel. De rotatie-eenheid: `DEGREES` (standaard).
`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.

def main():
    # 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)

# VR threads — Do not delete
vr_thread(main)

stop #

stop stopt de beweging van de robot.

Usage:
drivetrain.stop()

Parameters	Beschrijving
	Deze methode heeft geen parameters.

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

# VR threads — Do not delete
vr_thread(main)

Mutators #

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, 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).

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

# VR threads — Do not delete
vr_thread(main)

set_rotation #

Rotatie geeft aan hoeveel de robot is gedraaid, gemeten in graden. Aan het begin van een project wordt de rotatiewaarde ingesteld op 0 graden. Met de opdracht 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 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).

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

# VR threads — Do not delete
vr_thread(main)

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`	De tijdseenheid: `SECONDS` of `MSEC` (milliseconden).

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

# VR threads — Do not delete
vr_thread(main)

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%. Dit kan een geheel getal `integer` of een decimaal getal (`float` ) zijn.
`units`	Optioneel. De snelheidseenheid: `PERCENT` (standaard).

def main():
    # 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)

# VR threads — Do not delete
vr_thread(main)

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 snelheid waarmee je draait, van 0% tot 100%. Dit kan een geheel getal `integer` ) of een decimaal getal (`float` ) zijn.
`units`	Optioneel. De snelheidseenheid: `PERCENT` (standaard).

def main():
    # Turn at different velocities
    # Default velocity
    drivetrain.turn_for(RIGHT, 120, DEGREES)
    wait(1, SECONDS)
    # Turn slower
    drivetrain.set_turn_velocity(20, PERCENT)
    drivetrain.turn_for(RIGHT, 120, DEGREES)
    wait(1, SECONDS)
    # Turn faster
    drivetrain.set_turn_velocity(100, PERCENT)
    drivetrain.turn_for(RIGHT, 120, DEGREES)

# VR threads — Do not delete
vr_thread(main)

Getters #

kop #

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,99 graden.

De beginrichting van de robot is 0 graden.

Usage:
drivetrain.heading(units)

Parameters	Beschrijving
`units`	Optioneel. De richtingseenheid: `DEGREES` (standaard).

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

# VR threads — Do not delete
vr_thread(main)

rotatie #

Rotatie geeft aan hoeveel de robot is gedraaid, gemeten in graden. 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 rotatie-eenheid: `DEGREES` (standaard).

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

# VR threads — Do not delete
vr_thread(main)

is_klaar #

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

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.

Usage:
drivetrain.is_moving()

Parameters	Beschrijving
	Deze methode heeft geen parameters.

snelheid #

velocity geeft aan hoe snel de robot rijdt, als een percentage van -100% tot 100%.

Usage:
drivetrain.velocity(units)

Parameters	Beschrijving
`units`	Optioneel. De snelheidseenheid: `PERCENT` (standaard).

Voorbeeld

def main():
    # Display the velocity after driving
    drivetrain.drive_for(FORWARD, 150, MM)
    brain.screen.print("Velocity: ")
    brain.screen.print(drivetrain.velocity(PERCENT))

Beweging #

Dex gebruikt de aanzuigmotor om blokken in de robot te trekken. De transportbandmotor verplaatst de blokken van de aanzuigopening naar de bovenkant van de robot, zodat ze naar een doel kunnen worden geduwd.

Elke motor heeft zijn eigen richtingsgedrag. De richtingsbeschrijvingen leggen uit hoe elke richting de betreffende motor op de Dex beweegt.

Acties #

draaien #

spin draait een motor oneindig vooruit of achteruit. De motor blijft draaien totdat er een andere actie wordt uitgevoerd, zoals in een andere richting draaien of stoppen.

Gebruik:
Een van de twee beschikbare motorobjecten kan met deze methode worden gebruikt, zoals hieronder weergegeven:

motor	Commando
`intake_motor`	`intake_motor.spin(direction)` — Inlaatmotor
`conveyor_motor`	`conveyor_motor.spin(direction)` — Conveyor Motor

Parameters

Beschrijving

direction

De draairichting van de motor:

FORWARD — Laat de transportbandmotor omhoog draaien of de inlaatmotor in de inlaatrichting draaien.
REVERSE — Laat de transportbandmotor omlaag draaien of de inlaatmotor in de uitlaatrichting draaien.

def main():
    # Pick up a second Block
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 350, MM)

# VR threads — Do not delete
vr_thread(main)

spin_for #

spin_for laat een motor een specifieke afstand draaien. De draaiing is relatief ten opzichte van de huidige positie van de motor. Het project wacht tot de motor klaar is met draaien voordat de volgende regel code wordt uitgevoerd.

Gebruik:
Een van de twee beschikbare motorobjecten kan met deze methode worden gebruikt, zoals hieronder weergegeven:

motor	Commando
`intake_motor`	`intake_motor.spin_for(direction, distance, units, wait)` — Inlaatmotor
`conveyor_motor`	`conveyor_motor.spin_for(direction, distance, units, wait)` — Conveyor Motor

Parameters	Beschrijving
`direction`	De draairichting van de motor: `FORWARD` — Laat de transportbandmotor omhoog draaien of de inlaatmotor in de inlaatrichting draaien. `REVERSE` — Laat de transportbandmotor omlaag draaien of de inlaatmotor in de uitlaatrichting draaien.
`distance`	De afstand die de motor aflegt. `DEGREES` gebruik hele getallen. `TURNS` kan gebruik maken van hele getallen of decimalen.
`units`	Optioneel. De afstandseenheid: `DEGREES` (standaard) of `TURNS`.
`wait`	Optioneel. `wait=True` (standaard) — Zorgt ervoor dat het project wacht totdat de motor is gestopt met draaien voordat de volgende regel code wordt uitgevoerd. `wait=False` — Zorgt ervoor dat de volgende regel code direct wordt uitgevoerd.

def main():
    # Pick up a second Block
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 350, MM)

# VR threads — Do not delete
vr_thread(main)

spin_to_position #

spin_to_position laat een motor naar een specifieke positie draaien.

De positie van een motor is de afstand die deze heeft afgelegd, gemeten in DEGREES of TURNSEén omwenteling is gelijk aan 360 graden. Aan het begin van een project wordt de motorpositie ingesteld op 0 graden. De motorpositie kan ook worden ingesteld met behulp van de set_position methode.

Positiewaarden zijn absoluut. Dit betekent dat de draairichting afhangt van de huidige positie van de motor.

Als de motor bijvoorbeeld begint bij 0 graden en draait naar een positie van 720 graden, draait hij twee omwentelingen vooruit. Als hij vervolgens draait naar een positie van 360 graden, draait hij één omwenteling achteruit, omdat 360 minder is dan 720.

Gebruik:
Een van de twee beschikbare motorobjecten kan met deze methode worden gebruikt, zoals hieronder weergegeven:

motor	Commando
`intake_motor`	`intake_motor.spin_to_position(angle, units, wait=True)` — Inlaatmotor
`conveyor_motor`	`conveyor_motor.spin_to_position(angle, units, wait=True)` — Transportbandmotor

Parameters	Beschrijving
`angle`	De positiewaarde waarnaar de motor zal draaien. `DEGREES` gebruik gehele getallen. `TURNS` kan gebruik maken van gehele getallen of decimalen.
`units`	Optioneel. De positie-eenheid: `DEGREES` (standaard) of `TURNS`.
`wait`	Optioneel. `wait=True` (standaard) — Zorgt ervoor dat het project wacht totdat de motor is gestopt met draaien voordat de volgende regel code wordt uitgevoerd. `wait=False` — Zorgt ervoor dat de volgende regel code direct wordt uitgevoerd.

Parameters

Beschrijving

angle

De positiewaarde waarnaar de motor zal draaien. DEGREES gebruik gehele getallen. TURNS kan gebruik maken van gehele getallen of decimalen.

units

Optioneel. De positie-eenheid: DEGREES (standaard) of TURNS.

wait

Optioneel.

wait=True (standaard) — Zorgt ervoor dat het project wacht totdat de motor is gestopt met draaien voordat de volgende regel code wordt uitgevoerd.
wait=False — Zorgt ervoor dat de volgende regel code direct wordt uitgevoerd.

def main():
    # Pick up a second Block
    conveyor_motor.spin_to_position(150, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 350, MM)

# VR threads — Do not delete
vr_thread(main)

stop #

stop zorgt ervoor dat een motor stopt met draaien.

Gebruik:
Een van de twee beschikbare motorobjecten kan met deze methode worden gebruikt, zoals hieronder weergegeven:

motor	Commando
`intake_motor`	`intake_motor.stop()` — Inlaatmotor
`conveyor_motor`	`conveyor_motor.stop()` — Transportbandmotor

Parameters	Beschrijving
	Deze methode heeft geen parameters.

def main():
    # Pick up a second Block
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 350, MM)
    intake_motor.stop()

# VR threads — Do not delete
vr_thread(main)

Mutators #

set_position #

De positie van een motor geeft aan hoeveel omwentelingen hij heeft gemaakt, gemeten in DEGREES of TURNSEén omwenteling is gelijk aan 360 graden. set_position verandert de huidige positie van de motor naar een nieuwe waarde.

Als een motor bijvoorbeeld 180 graden heeft gedraaid, zal het instellen van de positie op 0 graden die positie resetten van 180 naar 0 graden. Vervolgens kan de motor naar posities draaien op basis van die nieuwe waarde.

Gebruik:
Een van de twee beschikbare motorobjecten kan met deze methode worden gebruikt, zoals hieronder weergegeven:

motor	Commando
`intake_motor`	`intake_motor.set_position(position, units)` — Inlaatmotor
`conveyor_motor`	`conveyor_motor.set_position(position, units)` — Transportbandmotor

Parameters	Beschrijving
`position`	De positiewaarde die voor de motor moet worden ingesteld. `DEGREES` gebruik gehele getallen. `TURNS` kan gebruik maken van gehele getallen of decimalen.
`units`	Optioneel. De positie-eenheid: `DEGREES` (standaard) of `TURNS`.

def main():
    # Pick up a second Block
    conveyor_motor.set_position(-150, DEGREES)
    conveyor_motor.spin_to_position(0, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 350, MM)

# VR threads — Do not delete
vr_thread(main)

set_velocity #

set_velocity geeft aan hoe snel een motor moet draaien. Een hoger percentage zorgt ervoor dat de motor sneller draait en een lager percentage zorgt ervoor dat de motor langzamer draait.

Elk project begint standaard met elke motor op 50% snelheid.

Let op: Een hogere snelheid zorgt ervoor dat de motor sneller draait, maar de precisie kan lager zijn. Een lagere snelheid zorgt ervoor dat de motor langzamer draait, maar de precisie kan hoger zijn.

Gebruik:
Een van de twee beschikbare motorobjecten kan met deze methode worden gebruikt, zoals hieronder weergegeven:

motor	Commando
`intake_motor`	`intake_motor.set_velocity(velocity, units)` — Inlaatmotor
`conveyor_motor`	`conveyor_motor.set_velocity(velocity, units)` — Transportbandmotor

Parameters	Beschrijving
`velocity`	De rotatiesnelheid van 0% tot 100%. Dit kan een geheel getal `integer` ) of een decimaal getal (`float` ) zijn.
`units`	De snelheidseenheid: `PERCENT`.

def main():
    # Pick up a second Block
    conveyor_motor.set_velocity(90, PERCENT)
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 400, MM)

# VR threads — Do not delete
vr_thread(main)

set_timeout #

set_timeout bepaalt hoeveel tijd een motor krijgt om een beweging te voltooien. Als de motor 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 motor vastloopt tijdens een beweging.

Gebruik:
Een van de twee beschikbare motorobjecten kan met deze methode worden gebruikt, zoals hieronder weergegeven:

motor	Commando
`intake_motor`	`intake_motor.set_timeout(value, units)` — Inlaatmotor
`conveyor_motor`	`conveyor_motor.set_timeout(value, units)` — Transportbandmotor

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

def main():
    # Pick up a second Block
    conveyor_motor.set_timeout(0.5, SECONDS)
    conveyor_motor.spin_to_position(1000, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 400, MM)

# VR threads — Do not delete
vr_thread(main)

Getters #

is_klaar #

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

True — De motor is klaar met bewegen.
False — De motor draait nog steeds.

Deze methode werkt samen met de volgende bewegingsmethoden die de parameter wait hebben: spin_for en spin_to_position.

Gebruik:
Een van de twee beschikbare motorobjecten kan met deze methode worden gebruikt, zoals hieronder weergegeven:

motor	Commando
`intake_motor`	`intake_motor.is_done()` — Inlaatmotor
`conveyor_motor`	`conveyor_motor.is_done()` — Conveyor Motor

Parameters	Beschrijving
	Deze methode heeft geen parameters.

def main():
    # Pick up a second Block
    conveyor_motor.spin_to_position(300, DEGREES, wait=False)
    wait(0.1, SECONDS)
    while not conveyor_motor.is_done():
        drivetrain.drive(FORWARD)
        intake_motor.spin(FORWARD)
        wait(5, MSEC)
    drivetrain.stop()
    intake_motor.stop()

# VR threads — Do not delete
vr_thread(main)

draait #

is_spinning geeft als Booleaanse waarde aan of de motor draait. Dit kan worden gebruikt om de timing van andere gedragingen te regelen op basis van de beweging van de motor.

True — De motor draait.
False — De motor draait niet.

Deze methode werkt samen met de volgende bewegingsmethoden die de parameter wait hebben: spin_for en spin_to_position.

Gebruik:
Een van de twee beschikbare motorobjecten kan met deze methode worden gebruikt, zoals hieronder weergegeven:

motor	Commando
`intake_motor`	`intake_motor.is_spinning()` — Inlaatmotor
`conveyor_motor`	`conveyor_motor.is_spinning()` — Transportbandmotor

Parameters	Beschrijving
	Deze methode heeft geen parameters.

def main():
    # Pick up a second Block
    conveyor_motor.spin_to_position(300, DEGREES, wait=False)
    wait(0.1, SECONDS)
    while conveyor_motor.is_spinning():
        drivetrain.drive_for(FORWARD, 200, MM)
        intake_motor.spin(FORWARD)

# VR threads — Do not delete
vr_thread(main)

positie #

De positie van een motor geeft aan hoeveel omwentelingen hij heeft gemaakt, gemeten in DEGREES of TURNSEén omwenteling is gelijk aan 360 graden. position geeft de huidige positie van de motor weer.

Aan het begin van een project wordt de motorpositie ingesteld op 0 graden. Als de motor één volledige omwenteling vooruit draait, is de positie 360 graden, oftewel 1 omwenteling. Als de motor de andere kant op draait, is de positie negatief.

Gebruik:
Een van de twee beschikbare motorobjecten kan met deze methode worden gebruikt, zoals hieronder weergegeven:

motor	Commando
`intake_motor`	`intake_motor.position(units)` — Inlaatmotor
`conveyor_motor`	`conveyor_motor.position(units)` — Transportbandmotor

Parameters	Beschrijving
`units`	De eenheid om de motorpositie terug te brengen naar: `DEGREES` of `TURNS`.

def main():
    # Pick up a second Block
    while conveyor_motor.position(DEGREES) < 150:
        conveyor_motor.spin(FORWARD)
        wait(2, MSEC)
    conveyor_motor.stop()
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 400, MM)

# VR threads — Do not delete
vr_thread(main)

snelheid #

velocity geeft aan hoe snel de motor draait.

Een positieve waarde betekent dat de motor vooruit draait. Een negatieve waarde betekent dat de motor achteruit draait.

Gebruik:
Een van de twee beschikbare motorobjecten kan met deze methode worden gebruikt, zoals hieronder weergegeven:

motor	Commando
`intake_motor`	`intake_motor.velocity(units)` — Inlaatmotor
`conveyor_motor`	`conveyor_motor.velocity(units)` — Transportbandmotor

Parameters	Beschrijving
`units`	De snelheidseenheid die moet worden geretourneerd: `PERCENT`.

def main():
    # Pick up a second block
    conveyor_motor.set_velocity(100, PERCENT)
    conveyor_motor.spin_to_position(300, DEGREES, wait=False)
    wait(0.2, SECONDS)
    brain.screen.print(conveyor_motor.velocity(PERCENT))
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 400, MM)

# VR threads — Do not delete
vr_thread(main)

AI-visie #

Getters #

momentopname maken #

take_snapshot filtert gegevens uit het frame van de AI Vision Sensor tot één enkele signatuur — een opgeslagen beschrijving van iets dat de sensor kan herkennen, zoals een spelelement op het veld — en retourneert een tuple.

De tuple slaat objecten op, gesorteerd van groot naar klein op basis van breedte, beginnend bij index 0. De eigenschappen van elk object kunnen worden benaderd via de index. Er wordt een lege tuple geretourneerd als er geen overeenkomende objecten worden gevonden.

Usage:
ai_vision.take_snapshot(signature)

Parameters	Beschrijving
`signature`	Filtert de dataset zodat alleen gegevens met de opgegeven signatuur worden weergegeven. Beschikbare signaturen zijn: `AiVision.ALL_AIOBJS` - Detecteert rode en blauwe blokken.

Parameters

Beschrijving

signature

Filtert de dataset zodat alleen gegevens met de opgegeven signatuur worden weergegeven. Beschikbare signaturen zijn:

AiVision.ALL_AIOBJS - Detecteert rode en blauwe blokken.

def main():
    # If an object is detected, pick it up
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            intake_motor.spin(FORWARD)
            drivetrain.drive(FORWARD)
            while not bumper.pressing():
                wait(2, MSEC)
            drivetrain.stop()
            break

# VR threads — Do not delete
vr_thread(main)

Eigenschappen #

Er zijn zeven eigenschappen die worden opgenomen bij elk object dat in een tuple is opgeslagen nadat take_snapshot is gebruikt.

Alle eigenschapswaarden behalve .id beschrijven de positie en grootte van het gedetecteerde object in het gezichtsveld van de AI Vision Sensor op het moment dat take_snapshot werd gebruikt. Deze waarden worden gemeten in pixels, gebaseerd op de resolutie van de sensor van 320 bij 240 pixels.

.breedte #

.width retourneert de breedte van het gedetecteerde object in pixels, wat een geheel getal is tussen 1 en 320.

def main():
    # If an object is detected, approach and pick it up
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].width > 65:
                drivetrain.stop()
                break
            else:
                intake_motor.spin(FORWARD)
                drivetrain.drive(FORWARD)

# VR threads — Do not delete
vr_thread(main)

.hoogte #

.height retourneert de hoogte van het gedetecteerde object in pixels, wat een geheel getal is tussen 1 en 240.

def main():
    # If an object is detected, approach and pick it up
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].height > 55:
                drivetrain.stop()
                break
            else:
                intake_motor.spin(FORWARD)
                drivetrain.drive(FORWARD)

# VR threads — Do not delete
vr_thread(main)

.centerX #

.centerX retourneert de x-coördinaat van het middelpunt van het gedetecteerde object in pixels, een geheel getal tussen 0 en 320.

def main():
    # Pick up a Block from the top left group
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    drivetrain.turn_for(LEFT, 80, DEGREES)
    drivetrain.drive_for(FORWARD, 200, MM)
    drivetrain.set_turn_velocity(20, PERCENT)
    drivetrain.turn(LEFT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if 140 < ai_objects[0].centerX < 180:
                intake_motor.spin(FORWARD)
                drivetrain.drive(FORWARD)
                while not bumper.pressing():
                    wait(2, MSEC)
                drivetrain.stop()

# VR threads — Do not delete
vr_thread(main)

.centerY #

.centerY retourneert de y-coördinaat van het middelpunt van het gedetecteerde object in pixels, een geheel getal tussen 0 en 240.

def main():
    # If an object is detected, approach and pick it up
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].centerY > 140:
                drivetrain.stop()
                break
            else:
                intake_motor.spin(FORWARD)
                drivetrain.drive(FORWARD)

# VR threads — Do not delete
vr_thread(main)

.originX #

.originX retourneert de x-coördinaat van de linkerbovenhoek van de begrenzingsbox van het gedetecteerde object in pixels, wat een geheel getal tussen 0 en 320 is.

def main():
    # Pick up a Block from the top left group
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    drivetrain.turn_for(LEFT, 80, DEGREES)
    drivetrain.drive_for(FORWARD, 300, MM)
    drivetrain.set_turn_velocity(20, PERCENT)
    drivetrain.turn(RIGHT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if 100 < ai_objects[0].originX < 140:
                intake_motor.spin(FORWARD)
                drivetrain.drive(FORWARD)
                while not bumper.pressing():
                    wait(2, MSEC)
                drivetrain.stop()

# VR threads — Do not delete
vr_thread(main)

.originY #

.originY retourneert de y-coördinaat van de linkerbovenhoek van het begrenzingskader van het gedetecteerde object in pixels, wat een geheel getal tussen 0 en 240 is.

def main():
    # If an object is detected, approach and pick it up
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].originY > 120:
                drivetrain.stop()
                break
            else:
                intake_motor.spin(FORWARD)
                drivetrain.drive(FORWARD)

# VR threads — Do not delete
vr_thread(main)

.id #

.id retourneert de ID van de gedetecteerde AI-classificatie als een geheel getal.

AI-classificatie	id	Handtekening
BlueBlock	1	`GameElements.BLUE_BLOCK`
RedBlock	2	`GameElements.RED_BLOCK`

def main():
    # Pick up a Red Block from the top left group
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    drivetrain.turn_for(LEFT, 80, DEGREES)
    drivetrain.drive_for(FORWARD, 300, MM)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            drivetrain.drive(FORWARD)
            if (ai_objects[0].id) == 2:
                intake_motor.spin(FORWARD)
                while not bumper.pressing():
                    wait(2, MSEC)
                drivetrain.stop()
                break

# VR threads — Do not delete
vr_thread(main)

Troosten #

De console toont tekst, getallen en variabele waarden terwijl een project wordt uitgevoerd. Consolemethoden kunnen ook de cursor naar een nieuwe regel verplaatsen, de console leegmaken en variabelen of sensorwaarden toevoegen aan het tabblad Monitor.

Afdrukken #

hersenen.scherm.print #

brain.screen.print geeft tekst, getallen of variabele waarden weer in de console met behulp van de huidige cursorpositie.

Gebruik brain.screen.next_row wanneer je wilt dat de volgende afgedrukte waarde op een nieuwe regel begint.

Usage:
brain.screen.print(value)

Parameters	Beschrijving
`value`	De tekst, het getal of de variabelewaarde die in de console moet worden weergegeven.

def main():
    # Display a message in the Console
    brain.screen.print("Hello, robot!")

# VR threads — Do not delete
vr_thread(main)

De VEXcode-console, met de console en de tekst "Hallo, robot!" weergegeven.

hersenen.scherm.volgende_rij #

brain.screen.next_row verplaatst de cursor naar kolom 1 op de volgende regel in de console. De volgende waarde die wordt afgedrukt, verschijnt op die regel.

Usage:
brain.screen.next_row()

Parameters	Beschrijving
	Deze methode heeft geen parameters.

def main():
    # Print on two rows
    brain.screen.print("Row 1")
    brain.screen.next_row()
    brain.screen.print("Row 2")

# VR threads — Do not delete
vr_thread(main)

De VEXcode-console, die de console en de tekst "Rij 1" op de eerste regel en "Rij 2" op de tweede regel weergeeft.

hersen.scherm.scherm wissen #

brain.screen.clear_screen wist alle rijen uit de console en verplaatst de cursor terug naar rij 1.

Usage:
brain.screen.clear_screen()

Parameters	Beschrijving
	Deze methode heeft geen parameters.

def main():
    # Display text, then clear it after two seconds
    brain.screen.print("This will disappear...")
    wait(2, SECONDS)
    brain.screen.clear_screen()

# VR threads — Do not delete
vr_thread(main)

Monitor #

monitor_variabele #

monitor_variable voegt een of meer vooraf gedefinieerde variabelen toe aan het tabblad Monitor in VEXcode. Hiermee kunt u de waarde van een variabele zien veranderen terwijl een project wordt uitgevoerd.

Variabelen moeten globaal zijn om ze succesvol te kunnen monitoren met monitor_variable . Geef elke variabelenaam op als een tekenreeks.

Usage:
monitor_variable(“variable”)
monitor_variable(“variable1”, “variable2”)

Parameters	Beschrijving
`variable`	De naam van een vooraf gedefinieerde globale variabele die moet worden bewaakt, gegeven als een tekenreeks. Om meerdere variabelen te bewaken, scheidt u de variabelenamen met een komma.

def main():
    # Monitor the amount of loops
    global loops
    monitor_variable("loops")

    # Drive in a square 3 times
    for loops in range(12):
        drivetrain.turn_for(RIGHT, 90, DEGREES)
        drivetrain.drive_for(FORWARD, 150, MM)

# VR threads — Do not delete
vr_thread(main)

monitor_sensor #

monitor_sensor voegt een of meer sensorwaarden toe aan het tabblad Monitor in VEXcode. Hiermee kunt u de wijzigingen in sensorwaarden volgen terwijl een project wordt uitgevoerd.

Geef elke sensorwaarde op als een tekenreeks.

Usage:
monitor_sensor(“sensor”)
monitor_sensor(“sensor1”, “sensor2”)

Parameters	Beschrijving
`sensor`	The sensor value to monitor, given as a string. To monitor more than one sensor value, separate each sensor value with a comma. Supported sensor identifiers include: Brain `brain.timer.time` Drivetrain `drivetrain.is_done` `drivetrain.is_moving` `drivetrain.heading` `drivetrain.rotation` `drivetrain.velocity` Pusher Motor `pusher_motor.is_done` `pusher_motor.is_spinning` `pusher_motor.position` `pusher_motor.velocity` Arm Motor `arm_motor.is_done` `arm_motor.is_spinning` `arm_motor.position` `arm_motor.velocity` Front Distance Sensor `front_distance.is_object_detected` `front_distance.object_distance_mm` `front_distance.object_distance_inches` Front Optical Sensor `front_optical.is_near_object` `front_optical.color` `front_optical.brightness` `front_optical.hue` GPS Sensor `gps.position_mm` `gps.position_inches` `gps.heading` Pusher Rotation Sensor `pusher_rotation.angle` `pusher_rotation.position` AI Vision Sensor `ai_vision.object_count` `ai_vision.height` `ai_vision.width` `ai_vision.centerX` `ai_vision.centerY` `ai_vision.originX` `ai_vision.originY` `ai_vision.id`

Parameters

Beschrijving

sensor

The sensor value to monitor, given as a string. To monitor more than one sensor value, separate each sensor value with a comma. Supported sensor identifiers include:

Brain
- brain.timer.time
Drivetrain
- drivetrain.is_done
- drivetrain.is_moving
- drivetrain.heading
- drivetrain.rotation
- drivetrain.velocity
Pusher Motor
- pusher_motor.is_done
- pusher_motor.is_spinning
- pusher_motor.position
- pusher_motor.velocity
Arm Motor
- arm_motor.is_done
- arm_motor.is_spinning
- arm_motor.position
- arm_motor.velocity
Front Distance Sensor
- front_distance.is_object_detected
- front_distance.object_distance_mm
- front_distance.object_distance_inches
Front Optical Sensor
- front_optical.is_near_object
- front_optical.color
- front_optical.brightness
- front_optical.hue
GPS Sensor
- gps.position_mm
- gps.position_inches
- gps.heading
Pusher Rotation Sensor
- pusher_rotation.angle
- pusher_rotation.position
AI Vision Sensor
- ai_vision.object_count
- ai_vision.height
- ai_vision.width
- ai_vision.centerX
- ai_vision.centerY
- ai_vision.originX
- ai_vision.originY
- ai_vision.id

def main():
    # Monitor the robot's heading
    monitor_sensor("drivetrain.heading")
    drivetrain.turn_for(RIGHT, 450, DEGREES)

# VR threads — Do not delete
vr_thread(main)

Waarneming #

Optisch #

is_nabij_object #

is_near_object retourneert een Booleaanse waarde die aangeeft of de optische sensor een object binnen bereik detecteert.

True – De optische sensor detecteert een object.
False – De optische sensor detecteert geen object.

Usage:
optical.is_near_object()

Parameters	Beschrijving
	Deze methode heeft geen parameters.

def main():
    # Move the preloaded Block to the top of the Conveyor
    conveyor_motor.spin(FORWARD)
    while not optical.is_near_object():
        wait(2, MSEC)
    conveyor_motor.stop()

# VR threads — Do not delete
vr_thread(main)

kleur #

color retourneert een instantie van een Color klasse, gebaseerd op de gedetecteerde tintwaarde. Deze kunnen worden vergeleken met vooraf gedefinieerde Color objecten om voorwaardelijke instructies te creëren.

Mogelijke kleuren zijn:

NONE
RED - Een tintwaarde tussen 340° en 20°
GREEN - Een tintwaarde tussen 80° en 140°
BLUE - Een tintwaarde tussen 200° en 240°
YELLOW - Een tintwaarde tussen 40° en 60°
ORANGE - Een tintwaarde tussen 20° en 40°
PURPLE - Een tintwaarde tussen 240° en 280°
CYAN - Een tintwaarde tussen 140° en 200°

Opmerking: De optische sensor zoekt naar kleurtinten die overeenkomen met de opgegeven kleur. Voor het detecteren van specifieke kleurtinten, zie hue.

Usage:
optical.color()

Parameters	Beschrijving
	Deze methode heeft geen parameters.

def main():
    # Pick up and move a Blue Block to the top of the Conveyor
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 360, MM)
    conveyor_motor.spin(FORWARD)
    while not optical.color() == BLUE:
        wait(2, MSEC)
    conveyor_motor.stop()

# VR threads — Do not delete
vr_thread(main)

helderheid #

brightness geeft de hoeveelheid licht terug die door het object wordt weerkaatst als een decimaal getal (float) dat een percentage vertegenwoordigt.

Een hoger percentage betekent dat er meer licht teruggekaatst wordt naar de optische sensor. Een lager percentage betekent dat er minder licht teruggekaatst wordt.

Usage:
optical.brightness()

Parameters	Beschrijving
	Deze methode heeft geen parameters.

def main():
    # Move the preloaded Block to the top of the Conveyor
    conveyor_motor.spin(FORWARD)
    while not 0 < optical.brightness():
        wait(2, MSEC)
    conveyor_motor.stop()

# VR threads — Do not delete
vr_thread(main)

tint #

hue retourneert de tintwaarde van de gedetecteerde kleur als een decimaal getal (float) van 0 tot 359.

Tint is een manier om kleur te beschrijven met behulp van getallen op een kleurencirkel.

Een cirkelvormig kleurenwiel dat een volledig spectrum aan tinten weergeeft, gelabeld met gradenwaarden rond de omtrek, oplopend in stappen van 30 graden van 0° bovenaan tot 360°.

Usage:
optical.hue()

Parameters	Beschrijving
	Deze methode heeft geen parameters.

def main():
    # Pick up and move a Blue Block to the top of the Conveyor
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 360, MM)
    conveyor_motor.spin(FORWARD)
    while not 220 < optical.hue() < 260:
        wait(2, MSEC)
    conveyor_motor.stop()

# VR threads — Do not delete
vr_thread(main)

object_detected #

object_detected registreert een functie die wordt aangeroepen wanneer de optische sensor een nieuw object detecteert.

Usage:
optical.object_detected(callback, arg)

Parameters	Beschrijving
`callback`	Een eerder gedefinieerde functie die wordt uitgevoerd wanneer de optische sensor een nieuw object detecteert.
`arg`	Optioneel. Een tuple met argumenten die aan de callbackfunctie moeten worden doorgegeven. Zie Functies gebruiken met parameters voor meer informatie.

def ready_block():
  # Stop the conveyor when Block is at the Sensor
  conveyor_motor.stop()

def main():
  # Move the preloaded Block near the top of the Conveyor
  conveyor_motor.spin(FORWARD)
  optical.object_detected(ready_block)

# VR threads — Do not delete
vr_thread(main)

object_lost #

object_lost registreert een functie die wordt aangeroepen wanneer de optische sensor een gedetecteerd object verliest.

Usage:
optical.object_lost(callback, arg)

Parameters	Beschrijving
`callback`	Een eerder gedefinieerde functie die wordt uitgevoerd wanneer de optische sensor een gedetecteerd object verliest.
`arg`	Optioneel. Een tuple met argumenten die aan de callbackfunctie moeten worden doorgegeven. Zie Functies gebruiken met parameters voor meer informatie.

def ready_block():
  # Stop the conveyor when Block is at the top
  conveyor_motor.stop()

def main():
  # Move the preloaded Block to the top of the Conveyor
  conveyor_motor.spin(FORWARD)
  optical.object_lost(ready_block)

# VR threads — Do not delete
vr_thread(main)

GPS #

x_positie #

x_position geeft de huidige x-coördinaat van een GPS-sensor (Game Positioning System™) op het veld terug.

Usage:
gps.x_position(units)

Parameters	Beschrijving
eenheden	De eenheid van de offsetwaarde: `INCHES` of `MM`

def main():
    # Pick up a second Block
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive(FORWARD)
    while not gps.x_position(MM) > -795:
        wait(2, MSEC)
    drivetrain.stop()

# VR threads — Do not delete
vr_thread(main)

y_positie #

y_position geeft de huidige y-coördinaat van een GPS-sensor (Game Positioning System™) op het veld terug.

Usage:
gps.y_position(units)

Parameters	Beschrijving
eenheden	De eenheid van de offsetwaarde: `INCHES` of `MM`

def main():
    # Pick up a second Block
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive(FORWARD)
    while not -450 > gps.y_position(MM):
        wait(2, MSEC)
    drivetrain.stop()

# VR threads — Do not delete
vr_thread(main)

kop #

heading geeft de huidige kijkrichting van de robot weer, gebaseerd op de metingen van de GPS-sensor (Game Positioning System™) van 0 tot 359 graden.

Usage:
gps.heading()

Parameters	Beschrijving
	Deze methode heeft geen parameters.

def main():
    # Score the preloaded Block into a Center Goal
    drivetrain.set_turn_velocity(30, PERCENT)
    drivetrain.turn(LEFT)
    while not 40 > gps.heading():
        wait(2, MSEC)
    drivetrain.drive_for(FORWARD, 1000, MM)
    drivetrain.turn(RIGHT)
    while not gps.heading() > 310:
        wait(2, MSEC)
    drivetrain.drive_for(REVERSE, 400, MM)
    conveyor_motor.spin(FORWARD)

# VR threads — Do not delete
vr_thread(main)