Robotspecifik Python#

Introduktion #

Hjälteboten Fling har tre motoralternativ och en färgsensor.

Alla vanliga VEXcode VR-metoder är tillgängliga för användning i IQ 21-22 Pitching In Playground.

Nedan följer en lista över alla tillgängliga robotspecifika metoder:

Drivinstruktioner – Flytta och vrida roboten.

Åtgärder
- drive — Rör roboten framåt eller bakåt i all oändlighet.
- drive_for — Rör roboten framåt eller bakåt ett visst avstånd.
- turn — Svänger roboten åt vänster eller höger för alltid.
- turn_for — Svänger roboten åt vänster eller höger ett visst antal grader.
- turn_to_heading — Vrider roboten mot en specifik kurs från -359 till 359 grader.
- turn_to_rotation — Vrider roboten till en specifik rotation.
- stop — Stoppar robotens rörelse.
Mutatorer
- set_heading — Ändrar robotens nuvarande kurs till en ny kurs.
- set_rotation — Ändrar robotens aktuella rotation till en ny rotation.
- set_timeout — Anger hur lång tid roboten ska försöka slutföra en rörelse.
- set_drive_velocity — Anger för roboten hur snabbt den ska köra.
- set_turn_velocity — Anger för roboten hur snabbt den ska svänga.
Hämtarna
- heading — Returnerar robotens aktuella kurs från 0 till 359,99 grader.
- rotation — Returnerar robotens aktuella rotation.
- is_done — Returnerar om roboten är klar med sin rörelse, som ett booleskt värde.
- is_moving — Returnerar om roboten rör sig, som ett booleskt värde.
- velocity — Returnerar hur snabbt roboten kör.

Rörelse - Flytta och spåra robotens motorer.

Åtgärder
- spin — Snurrar en motor framåt eller bakåt i all oändlighet.
- spin_for — Snurrar en motor ett visst avstånd.
- spin_to_position — Roterar en motor till en specifik position.
- stop — Stoppar en motor från att snurra.
Mutatorer
- set_position — Ändrar motorns aktuella position till ett nytt värde.
- set_velocity — Anger hur snabbt motorn ska snurra.
- set_timeout — Anger hur lång tid en motor ska försöka slutföra en rörelse.
Hämtarna
- is_done — Returnerar om motorn är klar med att röra sig, som ett booleskt värde.
- is_spinning — Returnerar om motorn snurrar, som ett booleskt värde.
- position — Returnerar motorns aktuella position.
- velocity — Returnerar hur snabbt motorn snurrar.

Konsol – Skriv ut till konsolen och övervaka värden.

Skriva ut
- brain.screen.print — Visar text, siffror eller variabelvärden i konsolen.
- brain.screen.next_row — Flyttar konsolmarkören till början av nästa rad.
- brain.screen.clear_screen — Rensar alla rader från konsolen.
Övervaka
- monitor_variable — Lägger till en eller flera fördefinierade variabler på fliken Monitor.
- monitor_sensor — Lägger till ett eller flera sensorvärden på fliken Monitor.

Avkänning - Använd robotens olika sensorer.

Färg
- color – Returnerar färgen som detekterats av färgsensorn.
- brightness – Returnerar mängden ljus som reflekteras från objektet.
- hue - Returnerar nyansen som detekterats av färgsensorn.
- is_near_object – Returnerar om färgsensorn detekterar ett objekt inom räckhåll.

Exemplen på den här sidan använder standardstartpositionen för Playground.

Drivlina #

Drivlinan styr hur VR-roboten kör och svänger. Drivlinan kan röra sig framåt eller bakåt, svänga vänster eller höger, följa kursriktningar och spåra sin rotation.

Åtgärder #

köra #

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

Usage:
drivetrain.drive(direction)

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

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

# VR threads — Do not delete
vr_thread(main)

kör_för #

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

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

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

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)

sväng #

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

Usage:
drivetrain.turn(direction)

Parametrar	Beskrivning
`direction`	Riktningen roboten svänger: `LEFT` eller `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 vrider roboten åt vänster eller höger ett visst antal grader. Vridningen är relativ till robotens aktuella position. Projektet väntar tills roboten är klar med att vrida sig innan nästa kodrad körs.

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

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

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)

sväng_till_rubrik #

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

Robotens startriktning är 0 grader.

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

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

Parametrar	Beskrivning
`angle`	Riktningen roboten ska vara vänd mot, i grader. Detta kan vara ett heltal `integer` eller ett decimaltal (`float`) från -359 till 359.
`units`	Valfritt. Rotationsenheten: `DEGREES` (standard).
`wait`	Valfritt. `wait=True` (standard) gör att projektet väntar tills roboten är klar med att vända innan nästa kodrad körs. `wait=False` gör att nästa kodrad körs direkt.

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)

sväng_till_rotation #

turn_to_rotation vrider roboten till en specifik rotation.

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

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

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

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

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

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

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)

stopp #

stop stoppar robotens rörelse.

Usage:
drivetrain.stop()

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

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

# VR threads — Do not delete
vr_thread(main)

Mutatorer #

set_header #

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

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

Usage:
drivetrain.set_heading(heading, units)

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

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 #

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

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

Usage:
drivetrain.set_rotation(rotation, units)

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

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 anger hur lång tid roboten ska försöka slutföra en rörelse. Om roboten inte kan slutföra inom den tiden kommer den att sluta försöka och gå vidare till nästa kodrad. Detta förhindrar att roboten fastnar i en rörelse.

Usage:
drivetrain.set_timeout(value, units)

Parametrar	Beskrivning
`value`	Den tid roboten kan försöka slutföra en rörelse. Detta kan vara ett positivt `integer` eller ett decimaltal (`float`).
`units`	Tidsenheten: `SECONDS` eller `MSEC` (millisekunder).

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 anger hur snabbt roboten ska köra. En högre procentandel gör att roboten kör snabbare och en lägre procentandel gör att roboten kör långsammare.

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

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

Usage:
drivetrain.set_drive_velocity(velocity, units)

Parametrar	Beskrivning
`velocity`	Hastigheten att köra med från 0 % till 100 %. Detta kan vara ett heltal `integer` eller ett decimaltal (`float`).
`units`	Valfritt. Hastighetsenheten: `PERCENT` (standard).

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 anger hur snabbt roboten ska snurra. En högre procentandel gör att roboten snurrar snabbare och en lägre procentandel gör att roboten snurrar långsammare.

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

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

Usage:
drivetrain.set_turn_velocity(velocity, units)

Parametrar	Beskrivning
`velocity`	Hastigheten att rotera med från 0 % till 100 %. Detta kan vara ett heltal `integer` eller ett decimaltal (`float`).
`units`	Valfritt. Hastighetsenheten: `PERCENT` (standard).

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 #

rubrik #

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

Robotens startriktning är 0 grader.

Usage:
drivetrain.heading(units)

Parametrar	Beskrivning
`units`	Valfritt. Kursenheten: `DEGREES` (standard).

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)

rotation #

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

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

Usage:
drivetrain.rotation(units)

Parametrar	Beskrivning
`units`	Valfritt. Rotationsenheten: `DEGREES` (standard).

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)

är_klar #

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

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

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

Usage:
drivetrain.is_done()

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

rör sig #

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

True — Roboten rör sig.
False — Roboten rör sig inte.

Usage:
drivetrain.is_moving()

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

hastighet #

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

Usage:
drivetrain.velocity(units)

Parametrar	Beskrivning
`units`	Valfritt. Hastighetsenheten: `PERCENT` (standard).

Exempel

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

Rörelse #

Fling använder insugningsmotorn för att dra in eller kasta ut bollar. Katapulten och katapultarmens spänningsmotorer avfyrar bollar, där spänningen ändrar hur långt bollarna färdas.

Varje motor har sitt eget riktningsbeteende. Riktningsbeskrivningarna förklarar hur varje riktning rör motorn vid Fling.

Åtgärder #

snurra #

spin snurrar en motor framåt eller bakåt för alltid. Motorn fortsätter att snurra tills den får en annan åtgärd, som att snurra i en annan riktning eller stanna.

Användning:
Ett av tre tillgängliga motorobjekt kan användas med den här metoden, som visas nedan:

motor	Kommando
`intake_motor`	`intake_motor.spin(direction)` — Insugningsmotor
`catapult_motor`	`catapult_motor.spin(direction)` — Katapultmotor
`catapult_tension_motor`	`catapult_tension_motor.spin(direction)` — Katapultens spänningsmotor

Parametrar	Beskrivning
`direction`	Motorns rotationsriktning beror på vald motor: `FORWARD` — Snurrar insugningsmotorn i insugningsriktningen eller flyttar den valda katapultmotorn framåt. `REVERSE` — Snurrar insugningsmotorn i utsugningsriktningen eller flyttar den valda katapultmotorn bakåt.

Parametrar

Beskrivning

direction

Motorns rotationsriktning beror på vald motor:

FORWARD — Snurrar insugningsmotorn i insugningsriktningen eller flyttar den valda katapultmotorn framåt.
REVERSE — Snurrar insugningsmotorn i utsugningsriktningen eller flyttar den valda katapultmotorn bakåt.

def main():
    # Spin the Intake Motor to collect a Ball
    intake_motor.spin(FORWARD)
    wait(1, SECONDS)
    intake_motor.stop()

# VR threads — Do not delete
vr_thread(main)

spin_for #

spin_for snurrar en motor ett visst avstånd. Rotationen är relativ till motorns aktuella position. Projektet väntar tills motorn har snurrat klart innan nästa kodrad körs.

Användning:
Ett av tre tillgängliga motorobjekt kan användas med den här metoden, som visas nedan:

motor	Kommando
`intake_motor`	`intake_motor.spin_for(direction, distance, units, wait=True)` — Insugningsmotor
`catapult_motor`	`catapult_motor.spin_for(direction, distance, units, wait=True)` — Katapultmotor
`catapult_tension_motor`	`catapult_tension_motor.spin_for(direction, distance, units, wait=True)` — Katapultens spänningsmotor

Parametrar	Beskrivning
`direction`	Motorns rotationsriktning beror på vald motor: `FORWARD` eller `REVERSE`.
`distance`	Avståndet motorn snurrar. `DEGREES` använd heltal. `TURNS` kan använda heltal eller decimaler.
`units`	Valfritt. Avståndsenheten: `DEGREES` (standard) eller `TURNS`.
`wait`	Valfritt. `wait=True` (standard) — Gör att projektet väntar tills motorn har snurrat klart innan nästa kodrad körs. `wait=False` — Gör att nästa kodrad körs direkt.

def main():
    # Collect a Ball with the Intake Motor
    intake_motor.spin_for(FORWARD, 360, DEGREES)

# VR threads — Do not delete
vr_thread(main)

snurra_till_position #

spin_to_position snurrar en motor till en specifik position.

En motors position är hur långt den har snurrat, mätt i DEGREES eller TURNSEtt varv är lika med 360 grader. I början av ett projekt är motorpositionen inställd på 0 grader. Motorpositionen kan också ställas in med metoden set_position.

Positionsvärdena är absoluta. Det betyder att rotationsriktningen beror på motorns aktuella position.

Om motorn till exempel startar vid 0 grader och snurrar till en position på 720 grader, snurrar den framåt två varv. Om den sedan snurrar till en position på 360 grader, snurrar den bakåt ett varv, eftersom 360 är mindre än 720.

Användning:
Ett av tre tillgängliga motorobjekt kan användas med den här metoden, som visas nedan:

motor	Kommando
`intake_motor`	`intake_motor.spin_to_position(angle, units, wait=True)` — Insugningsmotor
`catapult_motor`	`catapult_motor.spin_to_position(angle, units, wait=True)` — Katapultmotor
`catapult_tension_motor`	`catapult_tension_motor.spin_to_position(angle, units, wait=True)` — Katapultens spänningsmotor

Parametrar	Beskrivning
`angle`	Positionsvärdet som motorn kommer att rotera till. `DEGREES` använd heltal. `TURNS` kan använda heltal eller decimaler.
`units`	Valfritt. Positionsenheten: `DEGREES` (standard) eller `TURNS`.
`wait`	Valfritt. `wait=True` (standard) — Gör att projektet väntar tills motorn har snurrat klart innan nästa kodrad körs. `wait=False` — Gör att nästa kodrad körs direkt.

Parametrar

Beskrivning

angle

Positionsvärdet som motorn kommer att rotera till. DEGREES använd heltal. TURNS kan använda heltal eller decimaler.

units

Valfritt. Positionsenheten: DEGREES (standard) eller TURNS.

wait

Valfritt.

wait=True (standard) — Gör att projektet väntar tills motorn har snurrat klart innan nästa kodrad körs.
wait=False — Gör att nästa kodrad körs direkt.

def main():
    # Move the Catapult Motor to a launch position
    catapult_motor.spin_to_position(2600, DEGREES)

# VR threads — Do not delete
vr_thread(main)

stoppa motorn #

stop stoppar en motor från att snurra.

Användning:
Ett av tre tillgängliga motorobjekt kan användas med den här metoden, som visas nedan:

motor	Kommando
`intake_motor`	`intake_motor.stop()` — Insugningsmotor
`catapult_motor`	`catapult_motor.stop()` — Katapultmotor
`catapult_tension_motor`	`catapult_tension_motor.stop()` — Katapultens spänningsmotor

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

def main():
    # Spin the Intake Motor, then stop it
    intake_motor.spin(FORWARD)
    wait(1, SECONDS)
    intake_motor.stop()

# VR threads — Do not delete
vr_thread(main)

Mutatorer #

set_position #

En motors position är hur långt den har snurrat, mätt i DEGREES eller TURNSEtt varv är lika med 360 grader. set_position ändrar motorns nuvarande position till ett nytt värde.

Om till exempel en motor har snurrat 180 grader, kommer en position som ställs in på 0 grader att återställas från 180 grader till 0 grader. Motorn kan sedan snurra till positioner baserat på det nya värdet.

Användning:
Ett av tre tillgängliga motorobjekt kan användas med den här metoden, som visas nedan:

motor	Kommando
`intake_motor`	`intake_motor.set_position(position, units)` — Insugningsmotor
`catapult_motor`	`catapult_motor.set_position(position, units)` — Katapultmotor
`catapult_tension_motor`	`catapult_tension_motor.set_position(position, units)` — Katapultens spänningsmotor

Parametrar	Beskrivning
`position`	Positionsvärdet som ska ställas in för motorn. `DEGREES` använd heltal. `TURNS` kan använda heltal eller decimaler.
`units`	Valfritt. Positionsenheten: `DEGREES` (standard) eller `TURNS`.

def main():
    # Set the Catapult Motor position, then return it to 0 degrees
    catapult_motor.set_position(2600, DEGREES)
    catapult_motor.spin_to_position(0, DEGREES)

# VR threads — Do not delete
vr_thread(main)

set_velocity #

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

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

Obs! En högre hastighet gör att motorn snurrar snabbare, men den kan vara mindre exakt. En lägre hastighet gör att motorn snurrar långsammare, men den kan vara mer exakt.

Användning:
Ett av tre tillgängliga motorobjekt kan användas med den här metoden, som visas nedan:

motor	Kommando
`intake_motor`	`intake_motor.set_velocity(velocity, units)` — Insugningsmotor
`catapult_motor`	`catapult_motor.set_velocity(velocity, units)` — Katapultmotor
`catapult_tension_motor`	`catapult_tension_motor.set_velocity(velocity, units)` — Katapultens spänningsmotor

Parametrar	Beskrivning
`velocity`	Hastigheten att rotera med från -100 % till 100 %. Detta kan vara ett heltal `integer` eller ett decimaltal (`float`).
`units`	Hastighetsenheten: `PERCENT`.

def main():
    # Set the Catapult Motor velocity before moving it
    catapult_motor.set_velocity(75, PERCENT)
    catapult_motor.spin_to_position(2600, DEGREES)

# VR threads — Do not delete
vr_thread(main)

set_timeout #

set_timeout anger hur lång tid en motor ska försöka slutföra en rörelse. Om motorn inte kan slutföra inom den tiden kommer den att sluta försöka och gå vidare till nästa kodrad. Detta förhindrar att motorn fastnar i en rörelse.

Användning:
Ett av tre tillgängliga motorobjekt kan användas med den här metoden, som visas nedan:

motor	Kommando
`intake_motor`	`intake_motor.set_timeout(value, units)` — Insugningsmotor
`catapult_motor`	`catapult_motor.set_timeout(value, units)` — Katapultmotor
`catapult_tension_motor`	`catapult_tension_motor.set_timeout(value, units)` — Katapultens spänningsmotor

Parametrar	Beskrivning
`value`	Den tid motorn kan försöka slutföra en rörelse. Detta kan vara ett positivt `integer` eller ett decimaltal (`float`).
`units`	Tidsenheten: `SECONDS` eller `MSEC` (millisekunder).

def main():
    # Limit how long the Catapult Motor waits to reach its target
    catapult_motor.set_timeout(2, SECONDS)
    catapult_motor.spin_to_position(5000, DEGREES)

# VR threads — Do not delete
vr_thread(main)

Getters #

är_klar #

is_done returnerar om motorn är klar med att röra sig, som ett booleskt värde. Detta kan användas för att styra tidpunkten för andra beteenden baserat på motorns rörelse.

True — Motorn är klar med att röra sig.
False — Motorn rör sig fortfarande.

Den här metoden fungerar tillsammans med följande rörelsemetoder som har parametern wait : spin_for och spin_to_position.

Användning:
Ett av tre tillgängliga motorobjekt kan användas med den här metoden, som visas nedan:

motor	Kommando
`intake_motor`	`intake_motor.is_done()` — Insugningsmotor
`catapult_motor`	`catapult_motor.is_done()` — Katapultmotor
`catapult_tension_motor`	`catapult_tension_motor.is_done()` — Katapultens spänningsmotor

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

snurrar #

is_spinning returnerar huruvida motorn snurrar, som ett booleskt värde. Detta kan användas för att styra tidpunkten för andra beteenden baserat på motorns rörelse.

True — Motorn snurrar.
False — Motorn snurrar inte.

Den här metoden fungerar tillsammans med följande rörelsemetoder som har parametern wait : spin_for och spin_to_position.

Användning:
Ett av tre tillgängliga motorobjekt kan användas med den här metoden, som visas nedan:

motor	Kommando
`intake_motor`	`intake_motor.is_spinning()` — Insugningsmotor
`catapult_motor`	`catapult_motor.is_spinning()` — Katapultmotor
`catapult_tension_motor`	`catapult_tension_motor.is_spinning()` — Katapultspänningsmotor

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

placera #

En motors position är hur långt den har snurrat, mätt i DEGREES eller TURNSEtt varv är lika med 360 grader. position returnerar motorns aktuella position.

I början av ett projekt är motorpositionen inställd på 0 grader. Om motorn snurrar ett helt varv framåt blir positionen 360 grader eller 1 varv. Om motorn snurrar åt andra hållet blir positionen negativ.

Användning:
Ett av tre tillgängliga motorobjekt kan användas med den här metoden, som visas nedan:

motor	Kommando
`intake_motor`	`intake_motor.position(units)` — Insugningsmotor
`catapult_motor`	`catapult_motor.position(units)` — Katapultmotor
`catapult_tension_motor`	`catapult_tension_motor.position(units)` — Katapultens spänningsmotor

Parametrar	Beskrivning
`units`	Enheten för att återställa motorpositionen i: `DEGREES` eller `TURNS`.

def main():
    # Print the current Catapult Motor position
    brain.screen.print(catapult_motor.position(DEGREES))

# VR threads — Do not delete
vr_thread(main)

hastighet #

velocity returnerar hur snabbt motorn snurrar.

Ett positivt värde betyder att motorn roterar framåt. Ett negativt värde betyder att motorn roterar bakåt.

Användning:
Ett av tre tillgängliga motorobjekt kan användas med den här metoden, som visas nedan:

motor	Kommando
`intake_motor`	`intake_motor.velocity(units)` — Insugningsmotor
`catapult_motor`	`catapult_motor.velocity(units)` — Katapultmotor
`catapult_tension_motor`	`catapult_tension_motor.velocity(units)` — Katapultens spänningsmotor

Parametrar	Beskrivning
`units`	Hastighetsenheten som ska returneras: `PERCENT`.

def main():
    # Print the current Intake Motor velocity
    brain.screen.print(intake_motor.velocity(PERCENT))

# VR threads — Do not delete
vr_thread(main)

Trösta #

Konsolen visar text, siffror och variabelvärden medan ett projekt körs. Konsolmetoder kan också flytta markören till en ny rad, rensa konsolen och lägga till variabler eller sensorvärden på fliken Monitor.

Skriva ut #

hjärnskärmavtryck #

brain.screen.print visar text, siffror eller variabelvärden i konsolen med hjälp av markörens aktuella position.

Använd brain.screen.next_row när du vill att nästa utskrivna värde ska börja på en ny rad.

Usage:
brain.screen.print(value)

Parametrar	Beskrivning
`value`	Texten, talet eller variabelvärdet som ska visas i konsolen.

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

# VR threads — Do not delete
vr_thread(main)

VEXcode-konsolen, som visar konsolen och texten "Hej, robot!" visas.

hjärnskärm.nästa_rad #

brain.screen.next_row flyttar markören till kolumn 1 på nästa rad i konsolen. Nästa värde som skrivs ut visas på den raden.

Usage:
brain.screen.next_row()

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

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)

VEXcode-konsolen, som visar konsolen och texten "Rad 1" visas på den första raden och "Rad 2" på den andra raden.

hjärnskärm.klar_skärm #

brain.screen.clear_screen rensar alla rader från konsolen och flyttar markören tillbaka till rad 1.

Usage:
brain.screen.clear_screen()

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

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)

Övervaka #

monitor_variabel #

monitor_variable lägger till en eller flera fördefinierade variabler till fliken Monitor i VEXcode. Detta låter dig se en variabels värde ändras medan ett projekt körs.

Variabler måste vara globala för att monitor_variable ska kunna övervakas. Ange varje variabelnamn som en sträng.

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

Parametrar	Beskrivning
`variable`	Namnet på en fördefinierad global variabel som ska övervakas, angivet som en sträng. För att övervaka mer än en variabel, separera varje variabelnamn med ett kommatecken.

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 lägger till ett eller flera sensorvärden till fliken Monitor i VEXcode. Detta låter dig se sensorvärden ändras medan ett projekt körs.

Ange varje sensorvärde som en sträng.

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

Parametrar	Beskrivning
`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_rpm` `drivetrain.velocity_percent` Arm Motor `arm_motor.is_done` `arm_motor.is_spinning` `arm_motor.position_degrees` `arm_motor.position_turns` `arm_motor.velocity_rpm` `arm_motor.velocity_percent` Arm Motor Group `arm_motor_group.is_done` `arm_motor_group.is_spinning` `arm_motor_group.position_degrees` `arm_motor_group.position_turns` `arm_motor_group.velocity_rpm` `arm_motor_group.velocity_percent` Intake Motor `intake_motor.is_done` `intake_motor.is_spinning` `intake_motor.position_degrees` `intake_motor.position_turns` `intake_motor.velocity_rpm` `intake_motor.velocity_percent` Intake Motor Group `intake_motor_group.is_done` `intake_motor_group.is_spinning` `intake_motor_group.position_degrees` `intake_motor_group.position_turns` `intake_motor_group.velocity_rpm` `intake_motor_group.velocity_percent` Catapult Motor `catapult_motor.is_done` `catapult_motor.is_spinning` `catapult_motor.position_degrees` `catapult_motor.position_turns` `catapult_motor.velocity_rpm` `catapult_motor.velocity_percent` Catapult Tension Motor `catapult_tension_motor.is_done` `catapult_tension_motor.is_spinning` `catapult_tension_motor.position_degrees` `catapult_tension_motor.position_turns` `catapult_tension_motor.velocity_rpm` `catapult_tension_motor.velocity_percent` Bumpers `intake_bumper.pressing` `bumper.pressing` 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` Color Sensor `color.is_near_object` `color.color` `color.brightness` `color.hue`

Parametrar

Beskrivning

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_rpm
- drivetrain.velocity_percent
Arm Motor
- arm_motor.is_done
- arm_motor.is_spinning
- arm_motor.position_degrees
- arm_motor.position_turns
- arm_motor.velocity_rpm
- arm_motor.velocity_percent
Arm Motor Group
- arm_motor_group.is_done
- arm_motor_group.is_spinning
- arm_motor_group.position_degrees
- arm_motor_group.position_turns
- arm_motor_group.velocity_rpm
- arm_motor_group.velocity_percent
Intake Motor
- intake_motor.is_done
- intake_motor.is_spinning
- intake_motor.position_degrees
- intake_motor.position_turns
- intake_motor.velocity_rpm
- intake_motor.velocity_percent
Intake Motor Group
- intake_motor_group.is_done
- intake_motor_group.is_spinning
- intake_motor_group.position_degrees
- intake_motor_group.position_turns
- intake_motor_group.velocity_rpm
- intake_motor_group.velocity_percent
Catapult Motor
- catapult_motor.is_done
- catapult_motor.is_spinning
- catapult_motor.position_degrees
- catapult_motor.position_turns
- catapult_motor.velocity_rpm
- catapult_motor.velocity_percent
Catapult Tension Motor
- catapult_tension_motor.is_done
- catapult_tension_motor.is_spinning
- catapult_tension_motor.position_degrees
- catapult_tension_motor.position_turns
- catapult_tension_motor.velocity_rpm
- catapult_tension_motor.velocity_percent
Bumpers
- intake_bumper.pressing
- bumper.pressing
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
Color Sensor
- color.is_near_object
- color.color
- color.brightness
- color.hue

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)

Avkänning #

Färg #

färg #

color returnerar en instans av en Color klass, baserat på det detekterade nyansvärdet. Dessa kan jämföras med fördefinierade Color -objekt för att skapa villkorliga satser.

Möjliga färger är:

NONE
RED - Ett nyansvärde mellan 340° - 20°
GREEN - Ett nyansvärde mellan 80° - 140°
BLUE - Ett nyansvärde mellan 200° - 240°
YELLOW - Ett nyansvärde mellan 40° och 60°
ORANGE - Ett nyansvärde mellan 20° - 40°
PURPLE - Ett nyansvärde mellan 240° och 280°
CYAN - Ett nyansvärde mellan 140° och 200°

Obs! Färgsensorn letar efter nyansintervall som matchar den angivna färgen. För att upptäcka specifika nyansintervall, se hue.

Usage:
color.color()

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

def main():
    # Print the color detected by the Color Sensor
    brain.screen.print(color.color())

# VR threads — Do not delete
vr_thread(main)

ljusstyrka #

brightness returnerar mängden ljus som reflekteras från objektet som ett decimaltal (float) som representerar en procentandel.

En högre procentandel innebär att mer ljus reflekteras tillbaka till färgsensorn. En lägre procentandel innebär att mindre ljus reflekteras tillbaka.

Usage:
color.brightness()

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

def main():
    # Print the Color Sensor brightness
    brain.screen.print(color.brightness())

# VR threads — Do not delete
vr_thread(main)

nyans #

hue returnerar nyansvärdet för den detekterade färgen som ett decimaltal (float) från 0 till 359.

Nyans är ett sätt att beskriva färg med hjälp av siffror runt en färgcirkel.

En cirkulär färgcirkel som visar ett komplett spektrum av nyanser märkta med gradvärden runt omkretsen, ökande i 30-graders steg från 0 grader högst upp till 360 grader.

Usage:
color.hue()

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

def main():
    # Print the hue detected by the Color Sensor
    brain.screen.print(color.hue())

# VR threads — Do not delete
vr_thread(main)

är_nära_objektet #

is_near_object returnerar ett booleskt värde som anger om färgsensorn detekterar ett objekt inom räckhåll.

True – Färgsensorn detekterar ett objekt.
False – Färgsensorn detekterar inte ett objekt.

Usage:
color.is_near_object()

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

def main():
    # Print whether the Color Sensor detects an object nearby
    brain.screen.print(color.is_near_object())

# VR threads — Do not delete
vr_thread(main)