Robotspecifieke Python#
Invoering#
De Hero Bot, Huey, heeft twee motoropties: de IQ AI Vision Sensor, de optische sensor en de Touch LED.
Alle standaard VEXcode VR-methoden zijn beschikbaar voor gebruik in de IQ 25-26 Mix & Match 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 de IQ 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.
Aanraak-LED
set_color- Stelt de aanraak-LED in op een geselecteerde kleur.
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.
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 |
|---|---|
|
De richting waarin de robot beweegt: |
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 |
|---|---|
|
De richting waarin de robot beweegt: |
|
De afstand die de robot aflegt. Dit kan een geheel getal |
|
Optioneel. De afstandseenheid: |
|
Optioneel. |
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 |
|---|---|
|
De richting waarin de robot draait: |
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)
beurt_voor#
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 |
|---|---|
|
De richting waarin de robot draait: |
|
Het aantal graden dat de robot draait. Dit kan een geheel getal |
|
Optioneel. De rotatie-eenheid: |
|
Optioneel. |
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 |
|---|---|
|
De richting waarin de robot moet kijken, in graden. Dit kan een geheel getal |
|
Optioneel. De rotatie-eenheid: |
|
Optioneel. |
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 |
|---|---|
|
De rotatiewaarde, in graden, waarnaar de robot zal draaien. Dit kan een geheel getal |
|
Optioneel. De rotatie-eenheid: |
|
Optioneel. |
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 |
|---|---|
|
De richtingswaarde, in graden, die voor de robot moet worden ingesteld. Dit kan een geheel getal |
|
Optioneel. De richtingseenheid: |
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 |
|---|---|
|
De rotatiewaarde in graden die voor de robot moet worden ingesteld. Dit kan een geheel getal |
|
Optioneel. De rotatie-eenheid: |
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 |
|---|---|
|
De hoeveelheid tijd die de robot kan proberen om een beweging te voltooien. Dit kan een positief geheel getal zijn |
|
De tijdseenheid: |
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 |
|---|---|
|
De snelheid waarmee gereden moet worden, van 0% tot 100%. Dit kan een geheel getal |
|
Optioneel. De snelheidseenheid: |
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 |
|---|---|
|
De snelheid waarmee je draait, van 0% tot 100%. Dit kan een geheel getal |
|
Optioneel. De snelheidseenheid: |
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 |
|---|---|
|
Optioneel. De richtingseenheid: |
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 |
|---|---|
|
Optioneel. De rotatie-eenheid: |
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 |
|---|---|
|
Optioneel. De snelheidseenheid: |
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#
Huey gebruikt de grijpermotor om de grijper te openen en te sluiten, zodat pinnen en balken kunnen worden opgepakt of neergelegd. De hefmotor tilt de pinnen of balken omhoog en omlaag, zodat ze aan elkaar kunnen worden bevestigd.
Elke motor heeft zijn eigen richtingsgedrag. De richtingsbeschrijvingen leggen uit hoe elke richting de betreffende motor op de Huey aandrijft.
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 |
|---|---|
|
|
|
|
Parameters |
Beschrijving |
|---|---|
|
De draairichting van de motor:
|
def main():
# Raise the lift, drive forward, then open the claw.
lift_motor.spin_for(REVERSE, 600, DEGREES)
drivetrain.drive_for(FORWARD, 140, MM)
claw_motor.spin(FORWARD)
# 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 |
|---|---|
|
|
|
|
Parameters |
Beschrijving |
|---|---|
|
De draairichting van de motor:
|
|
De afstand die de motor aflegt. |
|
Optioneel. De afstandseenheid: |
|
Optioneel.
|
def main():
# Raise the lift, drive forward, then open the claw.
lift_motor.spin_for(REVERSE, 600, DEGREES)
drivetrain.drive_for(FORWARD, 140, MM)
claw_motor.spin(FORWARD)
# 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 |
|---|---|
|
|
|
|
Parameters |
Beschrijving |
|---|---|
|
De positie waarnaar de motor zal draaien. |
|
Optioneel. De positie-eenheid: |
|
Optioneel.
|
def main():
# Raise the lift to a known position, drive, then open the claw
lift_motor.spin_to_position(-720, DEGREES)
drivetrain.drive_for(FORWARD, 140, MM)
claw_motor.spin(FORWARD)
# VR threads — Do not delete
vr_thread(main)
stop motor#
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 |
|---|---|
|
|
|
|
Parameters |
Beschrijving |
|---|---|
Deze methode heeft geen parameters. |
def main():
# Raise the lift for 2 seconds, then stop
lift_motor.spin(REVERSE)
wait(2, SECONDS)
lift_motor.stop()
drivetrain.drive_for(FORWARD, 140, MM)
claw_motor.spin(FORWARD)
# 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 |
|---|---|
|
|
|
|
Parameters |
Beschrijving |
|---|---|
|
De positiewaarde die voor de motor moet worden ingesteld. |
|
Optioneel. De positie-eenheid: |
def main():
# Reset the lift position, then move to a new target.
lift_motor.set_position(100, DEGREES)
lift_motor.spin_to_position(-500, DEGREES)
drivetrain.drive_for(FORWARD, 140, MM)
claw_motor.spin(FORWARD)
# 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 |
|---|---|
|
|
|
|
Parameters |
Beschrijving |
|---|---|
|
De rotatiesnelheid van 0% tot 100%. Dit kan een geheel getal |
|
De snelheidseenheid: |
def main():
# Set lift speed, then raise it.
lift_motor.set_velocity(100, PERCENT)
lift_motor.spin_for(REVERSE, 600, DEGREES)
drivetrain.drive_for(FORWARD, 140, MM)
claw_motor.spin(FORWARD)
# 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 |
|---|---|
|
|
|
|
Parameters |
Beschrijving |
|---|---|
|
De hoeveelheid tijd die de motor kan proberen om een beweging te voltooien. Dit kan een positief geheel getal zijn |
|
De tijdseenheid: |
def main():
# Limit how long the lift waits to reach its target.
lift_motor.set_timeout(2, SECONDS)
lift_motor.spin_for(REVERSE, 1800, DEGREES)
drivetrain.drive_for(FORWARD, 140, MM)
claw_motor.spin(FORWARD)
# 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 |
|---|---|
|
|
|
|
Parameters |
Beschrijving |
|---|---|
Deze methode heeft geen parameters. |
def main():
# Flash the Touch LED while the lift is moving.
lift_motor.spin_for(REVERSE, 600, DEGREES, wait=False)
wait(0.1, SECONDS)
while not lift_motor.is_done():
touchled.set_color(RED)
wait(0.5, SECONDS)
touchled.set_color(NONE)
wait(0.5, SECONDS)
# 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 |
|---|---|
|
|
|
|
Parameters |
Beschrijving |
|---|---|
Deze methode heeft geen parameters. |
def main():
# Flash the Touch LED while the lift is spinning.
lift_motor.spin_for(REVERSE, 600, DEGREES, wait=False)
wait(0.1, SECONDS)
while lift_motor.is_spinning():
touchled.set_color(RED)
wait(0.5, SECONDS)
touchled.set_color(NONE)
wait(0.5, SECONDS)
# 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 |
|---|---|
|
|
|
|
Parameters |
Beschrijving |
|---|---|
|
De eenheid om de motorpositie terug te brengen naar: |
def main():
# Raise the lift until it reaches roughly 600 degrees.
lift_motor.spin(REVERSE)
while not lift_motor.position(DEGREES) <= -600:
wait(2, MSEC)
lift_motor.stop()
drivetrain.drive_for(FORWARD, 140, MM)
claw_motor.spin(FORWARD)
# 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 |
|---|---|
|
|
|
|
Parameters |
Beschrijving |
|---|---|
|
De snelheidseenheid die moet worden geretourneerd: |
def main():
# Print the lift velocity while it is moving.
lift_motor.set_velocity(100, PERCENT)
lift_motor.spin_for(REVERSE, 600, DEGREES, wait=False)
wait(0.5, SECONDS)
brain.screen.print(lift_motor.velocity(PERCENT))
# VR threads — Do not delete
vr_thread(main)
AI-visie#
Getters#
momentopname maken#
take_snapshot filtert gegevens uit het frame van de IQ 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 |
|---|---|
|
Filtert de dataset zodat alleen gegevens met de opgegeven signatuur worden opgenomen. Beschikbare signaturen zijn:
|
def main():
# Place the Red Pin on the top-left Blue Pin.
lift_motor.spin_for(REVERSE, 600, DEGREES)
drivetrain.turn_for(LEFT, 38, DEGREES)
ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
while not ai_objects[0].width > 48:
ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
drivetrain.drive(FORWARD)
drivetrain.drive_for(FORWARD, 160, MM)
claw_motor.spin(FORWARD)
# 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 IQ 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():
ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
if len(ai_objects) > 0:
brain.screen.print(ai_objects[0].width)
# 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():
ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
if len(ai_objects) > 0:
brain.screen.print(ai_objects[0].height)
# 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():
ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
if len(ai_objects) > 0:
brain.screen.print(ai_objects[0].centerX)
# 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():
ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
if len(ai_objects) > 0:
brain.screen.print(ai_objects[0].centerY)
# 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():
ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
if len(ai_objects) > 0:
brain.screen.print(ai_objects[0].originX)
# 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():
ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
if len(ai_objects) > 0:
brain.screen.print(ai_objects[0].originY)
# 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 |
|---|---|---|
Straal |
0 |
|
Blauwe speld |
1 |
|
Rode speld |
2 |
|
Oranje speld |
3 |
|
def main():
# Find the nearest Blue Pin in the current snapshot.
lift_motor.spin_for(REVERSE, 600, DEGREES)
object_count = 1
ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
if len(ai_objects) > 0:
for repeat_count in range(len(ai_objects)):
if ai_objects[repeat_count].id == GameElements.BLUE_PIN:
brain.screen.print(str("Closest Blue Pin is ") + str(object_count))
break
object_count = object_count + 1
# 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. Het werkt hetzelfde als print op de Console API-pagina.
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 |
|---|---|
|
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)
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)
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 |
|---|---|
|
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 |
|---|---|
|
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:
|
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#
Aanraak-LED#
set_color#
set_color stelt de kleur van de Touch LED in.
Usage:
touchled.set_color(color)
Parameters |
Beschrijving |
|---|---|
|
The color to set the Touch LED to:
|
def main():
# Light the Touch LED while placing a Pin.
touchled.set_color(RED)
lift_motor.spin_for(REVERSE, 600, DEGREES)
drivetrain.drive_for(FORWARD, 140, MM)
claw_motor.spin(FORWARD)
touchled.set_color(NONE)
# VR threads — Do not delete
vr_thread(main)
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():
# Wait until the claw no longer detects an object, then lower the lift.
lift_motor.spin_for(REVERSE, 600, DEGREES)
drivetrain.drive_for(FORWARD, 140, MM)
claw_motor.spin(FORWARD)
while optical.is_near_object():
wait(2, MSEC)
lift_motor.spin_to_position(0, DEGREES)
# 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:
NONERED- 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():
# Wait until the Optical Sensor detects red, then lower the lift.
lift_motor.spin_for(REVERSE, 600, DEGREES)
drivetrain.drive_for(FORWARD, 140, MM)
claw_motor.spin(FORWARD)
while not optical.color() == RED:
wait(5, MSEC)
lift_motor.spin_to_position(0, DEGREES)
# 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():
# Lower the lift once the claw sees a darker object.
lift_motor.spin_for(REVERSE, 600, DEGREES)
drivetrain.drive_for(FORWARD, 140, MM)
claw_motor.spin(FORWARD)
while not 30 > optical.brightness():
wait(5, MSEC)
lift_motor.spin_to_position(0, DEGREES)
# 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.
Usage:
optical.hue()
Parameters |
Beschrijving |
|---|---|
Deze methode heeft geen parameters. |
def main():
# Lower the lift once the Optical Sensor reports a hue value.
lift_motor.spin_for(REVERSE, 600, DEGREES)
drivetrain.drive_for(FORWARD, 140, MM)
claw_motor.spin(FORWARD)
while not optical.hue() > 0:
wait(5, MSEC)
lift_motor.spin_to_position(0, DEGREES)
# 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 |
|---|---|
|
Een eerder gedefinieerde functie die wordt uitgevoerd wanneer de optische sensor een nieuw object detecteert. |
|
Optioneel. Een tuple met argumenten die aan de callbackfunctie moeten worden doorgegeven. Zie Functies gebruiken met parameters voor meer informatie. |
def pin_in_claw():
touchled.set_color(RED)
def main():
# Change the Touch LED color when the claw detects an object.
optical.object_detected(pin_in_claw)
touchled.set_color(GREEN)
lift_motor.spin_for(REVERSE, 600, DEGREES)
drivetrain.drive_for(FORWARD, 140, MM)
claw_motor.spin(FORWARD)
# 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 |
|---|---|
|
Een eerder gedefinieerde functie die wordt uitgevoerd wanneer de optische sensor een gedetecteerd object verliest. |
|
Optioneel. Een tuple met argumenten die aan de callbackfunctie moeten worden doorgegeven. Zie Functies gebruiken met parameters voor meer informatie. |
def lower_lift():
# Lower the lift when the claw no longer holds an object.
lift_motor.spin_to_position(0, DEGREES)
def main():
optical.object_lost(lower_lift)
lift_motor.spin_for(REVERSE, 600, DEGREES)
drivetrain.drive_for(FORWARD, 140, MM)
claw_motor.spin(FORWARD)
# VR threads — Do not delete
vr_thread(main)