Robotspecifik Python

Introduktion

Hero Bot, Flex, inkluderar en klomotor, en armmotor, en AI-synsensor, en avståndssensor och en GPS-sensor (spelpositioneringssystem).

Alla standardmetoder för VEXcode VR är tillgängliga för användning i V5 26-27 Override 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.

AI Vision – Avbilda och analysera objekt med hjälp av AI Vision-sensorn.

• Hämtarna

  • take_snapshot – Returnerar en tupel av detekterade objekt för en specifik signatur.

• Fastigheter

  • .width – Width of the detected object in pixels.

  • .height – Height of the detected object in pixels.

  • .centerX – X position of the object’s center in pixels.

  • .centerY – Y position of the object’s center in pixels.

  • .originX – X position of the object’s top-left corner in pixels.

  • .originY – Y position of the object’s top-left corner in pixels.

  • .id – Classification ID of the detected object.

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.

• Avstånd

  • found_object – Returnerar om avståndssensorn detekterar ett objekt inom räckhåll.

  • object_distance – Returnerar avståndet mellan avståndssensorn och det närmaste detekterade objektet.

• GPS

  • x_position – Returnerar den aktuella x-koordinaten för GPS-sensorn på fältet.

  • y_position – Returnerar den aktuella y-koordinaten för GPS-sensorn på fältet.

  • heading – Returnerar den kurs som roboten för närvarande är riktad mot baserat på GPS-sensorn.

Exemplen på den här sidan använder startplats C från Playgrounds checklista före match.

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():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive(FORWARD)
    wait(0.5, SECONDS)
    drivetrain.stop()
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# 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():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# 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():
    # Score a Pin in a Neutral Goal
    drivetrain.turn(LEFT)
    wait(0.78, SECONDS)
    drivetrain.stop()
    arm_motor.spin_for(FORWARD, 800, DEGREES)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

vänd_för

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. Vinkelenheten: 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():
    # Score a Pin in a Neutral Goal
    drivetrain.turn_for(LEFT, 110, DEGREES)
    arm_motor.spin_for(FORWARD, 800, DEGREES)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    claw_motor.spin_for(REVERSE, 180, 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.

Startriktningen är 0 grader.

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

Parametrar	Beskrivning
heading	Robotens riktning ska vara mellan -359 och 359 grader.
units	Valfritt. Vinkelenheten: 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():
    # Score a Pin in a Neutral Goal
    drivetrain.turn_to_heading(-110, DEGREES)
    arm_motor.spin_for(FORWARD, 800, DEGREES)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    claw_motor.spin_for(REVERSE, 180, 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 är rotationsvärdet inställt på 0 grader. Att vrida åt höger ökar rotationen och att vrida åt vänster minskar rotationen.

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

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

Parametrar	Beskrivning
rotation	Rotationsvärdet, i grader, som roboten kommer att rotera till. Detta kan vara ett heltal integer eller ett decimaltal (float).
units	Valfritt. Vinkelenheten: 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():
    # Score a Pin in a Neutral Goal
    drivetrain.turn_to_rotation(-110, DEGREES)
    arm_motor.spin_for(FORWARD, 800, DEGREES)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    claw_motor.spin_for(REVERSE, 180, 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():
    # Score a Pin in a Neutral Goal
    drivetrain.turn(LEFT)
    wait(0.78, SECONDS)
    drivetrain.stop()
    arm_motor.spin_for(FORWARD, 800, DEGREES)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# 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.
units	Valfritt. Vinkelenheten: DEGREES (standard).

def main():
    # Make facing the Neutral Goal the new heading
    drivetrain.set_heading(110, 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. set_rotation ändrar robotens aktuella rotation till ett nytt värde.

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. Vinkelenheten: DEGREES (standard).

def main():
    # Make facing the Neutral Goal the new rotation
    drivetrain.set_rotation(110, DEGREES)
    drivetrain.turn_to_rotation(0, DEGREES)

# VR threads — Do not delete
vr_thread(main)

set_timeout

set_timeout anger hur många sekunder 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(time, units)

Parametrar	Beskrivning
time	Antalet sekunder roboten kan försöka slutföra en rörelse. Detta kan vara ett positivt integer eller ett decimaltal (float).
units	Valfritt. Tidsenheten: SECONDS (standard) eller MSEC.

def main():
    # Turn to face the Neutral Goal
    drivetrain.set_timeout(0.8, SECONDS)
    drivetrain.turn_for(LEFT, 180, DEGREES)

# 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():
    # Score a Pin in a Neutral Goal
    drivetrain.turn_for(LEFT, 110, DEGREES)
    arm_motor.spin_for(FORWARD, 800, DEGREES)
    drivetrain.set_drive_velocity(100, PERCENT)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# 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 to face the Neutral Goal faster
    drivetrain.set_turn_velocity(100, PERCENT)
    drivetrain.turn_for(LEFT, 110, 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():
    # Turn to the Goal, then show heading
    drivetrain.turn_for(LEFT, 110, 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():
    # Spin to find a Pin, then show rotation
    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.

def main():
    # Score a Pin in a Neutral Goal
    drivetrain.turn_for(LEFT, 110, DEGREES)
    arm_motor.spin_for(FORWARD, 800, DEGREES)
    drivetrain.drive_for(FORWARD, 25, INCHES, wait=False)
    wait(0.5, SECONDS)
    while not drivetrain.is_done():
        wait(5, MSEC)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

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.

def main():
    # Raise the Arm once stopped near the Goal
    drivetrain.turn_for(LEFT, 110, DEGREES)
    drivetrain.drive_for(FORWARD, 25, INCHES, wait=False)
    wait (0.5, SEC)
    while drivetrain.is_moving():
        wait(5, MSEC)
    arm_motor.spin_for(FORWARD, 800, DEGREES)

# VR threads — Do not delete
vr_thread(main)

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

def main():
    # Show speed while driving to the Goal
    drivetrain.drive_for(FORWARD, 150, MM)
    brain.screen.print("Velocity: ")
    brain.screen.print(drivetrain.velocity(PERCENT))

# VR threads — Do not delete
vr_thread(main)

Rörelse

Flex använder armmotorn för att lyfta och sänka armen och klomotorn för att öppna och stänga klon.

Varje motor har sin egen riktningsbeteende. Riktningsbeskrivningarna förklarar hur varje riktning rör motorn på Flex.

Åtgärder

snurra

spin snurrar en motor i en av två riktningar 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 två tillgängliga motorobjekt kan användas med den här metoden, som visas nedan:

motor	Kommando
arm_motor	arm_motor.spin(direction) — Armmotor
claw_motor	claw_motor.spin(direction) — Klomotor

Parametrar	Beskrivning
direction	Motorns rotationsriktning: FORWARD — Flyttar armmotorn uppåt eller stänger klomotorn. REVERSE — Flyttar armmotorn neråt eller öppnar klomotorn.

def main():
    # Raise the Arm before driving toward a Pin
    arm_motor.spin(FORWARD)
    wait(1, SECONDS)
    arm_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 två tillgängliga motorobjekt kan användas med den här metoden, som visas nedan:

motor	Kommando
arm_motor	arm_motor.spin_for(direction, distance, units, wait) — Armmotor
claw_motor	claw_motor.spin_for(direction, distance, units, wait) — Klomotor

Parametrar	Beskrivning
direction	Motorns rotationsriktning: FORWARD — Flyttar armmotorn uppåt eller stänger klomotorn. REVERSE — Flyttar armmotorn neråt eller öppnar klomotorn.
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():
    # Raise the Arm to carry the Pin to the Goal
    arm_motor.spin_for(FORWARD, 800, 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 armmotorns position inställd på 0 grader. Klomotorn är undantaget – den börjar vid 467 grader (helt stängd). 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 två tillgängliga motorobjekt kan användas med den här metoden, som visas nedan:

motor	Kommando
arm_motor	arm_motor.spin_to_position(angle, units, wait=True) — Armmotor
claw_motor	claw_motor.spin_to_position(angle, units, wait=True) — Klomotor

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():
    # Raise the Arm, then release the Pin
    arm_motor.spin_to_position(800, DEGREES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

stopp

stop stoppar en motor från att snurra.

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

motor	Kommando
arm_motor	arm_motor.stop() — Armmotor
claw_motor	claw_motor.stop() — Klomotor

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

def main():
    # Raise the Arm partway to hold the Pin
    arm_motor.spin(FORWARD)
    wait(1, SECONDS)
    arm_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 två tillgängliga motorobjekt kan användas med den här metoden, som visas nedan:

motor	Kommando
arm_motor	arm_motor.set_position(position, units) — Armmotor
claw_motor	claw_motor.set_position(position, units) — Klomotor

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():
    # Reset encoder, raise Arm, place Pin
    arm_motor.set_position(0, DEGREES)
    arm_motor.spin_to_position(800, DEGREES)
    claw_motor.spin_for(REVERSE, 180, 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 två tillgängliga motorobjekt kan användas med den här metoden, som visas nedan:

motor	Kommando
arm_motor	arm_motor.set_velocity(velocity, units) — Armmotor
claw_motor	claw_motor.set_velocity(velocity, units) — Klomotor

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

def main():
    # Raise the Arm fast to release the Pin
    arm_motor.set_velocity(100, PERCENT)
    arm_motor.spin_for(FORWARD, 800, DEGREES)
    claw_motor.spin_for(REVERSE, 180, 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 två tillgängliga motorobjekt kan användas med den här metoden, som visas nedan:

motor	Kommando
arm_motor	arm_motor.set_timeout(value, units) — Armera motor
claw_motor	claw_motor.set_timeout(value, units) — Klomotor

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():
    # Score a Pin in a Neutral Goal
    drivetrain.turn_for(LEFT, 110, DEGREES)
    arm_motor.set_timeout(1, SECONDS)
    arm_motor.spin_for(FORWARD, 1800, DEGREES)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    claw_motor.spin_for(REVERSE, 180, 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 två tillgängliga motorobjekt kan användas med den här metoden, som visas nedan:

motor	Kommando
arm_motor	arm_motor.is_done() — Armmotor
claw_motor	claw_motor.is_done() — Klomotor

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

def main():
    # Raise the Arm while driving to the Goal
    arm_motor.spin_to_position(800, DEGREES, wait=False)
    wait(0.1, SECONDS)
    while not arm_motor.is_done():
        drivetrain.drive(FORWARD)
        wait(5, MSEC)
    drivetrain.stop()

# VR threads — Do not delete
vr_thread(main)

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 två tillgängliga motorobjekt kan användas med den här metoden, som visas nedan:

motor	Kommando
arm_motor	arm_motor.is_spinning() — Armmotor
claw_motor	claw_motor.is_spinning() — Klomotor

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

def main():
    # Raise the Arm while driving to the Goal, then release the Pin
    arm_motor.spin_to_position(800, DEGREES, wait=False)
    wait(0.1, SECONDS)
    while arm_motor.is_spinning():
        drivetrain.drive_for(FORWARD, 25, MM)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

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 armmotorns position inställd på 0 grader. Klomotorn är undantaget – den börjar vid 467 grader (helt stängd). Om motorn snurrar ett helt varv framåt ökar positionen. Om motorn snurrar åt andra hållet minskar positionen.

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

motor	Kommando
arm_motor	arm_motor.position(units) — Armmotor
claw_motor	claw_motor.position(units) — Klomotor

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

def main():
    # Raise the Arm, then release the Pin
    while arm_motor.position(DEGREES) < 800:
        arm_motor.spin(FORWARD)
        wait(2, MSEC)
    arm_motor.stop()
    claw_motor.spin_for(REVERSE, 180, 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 två tillgängliga motorobjekt kan användas med den här metoden, som visas nedan:

motor	Kommando
arm_motor	arm_motor.velocity(units) — Armmotor
claw_motor	claw_motor.velocity(units) — Klomotor

Parametrar	Beskrivning
units	Hastighetsenheten som ska returneras: PERCENT.

def main():
    # Show Arm Motor velocity while raising
    arm_motor.set_velocity(100, PERCENT)
    arm_motor.spin_to_position(800, DEGREES, wait=False)
    wait(0.2, SECONDS)
    brain.screen.print(arm_motor.velocity(PERCENT))

# VR threads — Do not delete
vr_thread(main)

AI-vision

Getters

ta_ögonblicksbild

take_snapshot filtrerar data från AI Vision Sensor-ramen till en enda signatur – en sparad beskrivning av något som sensorn kan känna igen, till exempel ett spelelement på planen – och returnerar en tupel.

Tupeln lagrar objekt sorterade från störst till minst efter bredd, med början vid index 0. Varje objekts egenskaper kan nås med hjälp av dess index. En tom tupel returneras om inga matchande objekt upptäcks.

Usage:
ai_vision.take_snapshot(signature)

Parametrar

Beskrivning

signature

Filtrerar datamängden för att endast inkludera data från den givna signaturen. Tillgängliga signaturer är: AiVision.ALL_AIOBJS - Detekterar alla spelelement. GameElements.RED_BLUE_PIN - Detekterar RedBluePin-spelelement. GameElements.BLUE_YELLOW_PIN - Detekterar BlueYellowPin-spelelement. GameElements.RED_YELLOW_PIN - Detekterar RedYellowPin-spelelement. GameElements.YELLOW_PIN - Detekterar YellowPin-spelelement. GameElements.CUP - Detekterar Cup-spelelement.

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    drivetrain.turn_for(LEFT, 70, DEGREES)

    # Turn to face the Pin
    drivetrain.set_turn_velocity(30, PERCENT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].centerX < 140:
                drivetrain.turn(LEFT)
            elif ai_objects[0].centerX > 180:
                drivetrain.turn(RIGHT)
            else:
                drivetrain.stop()
                break

# VR threads — Do not delete
vr_thread(main)

Fastigheter

Det finns sju egenskaper som ingår i varje objekt som lagras i en tupel efter att take_snapshot har använts.

Alla egenskapsvärden utom .id beskriver det detekterade objektets position och storlek i AI-visionssensorns vy vid det ögonblick då take_snapshot användes. Dessa värden mäts i pixlar, baserat på sensorns upplösning på 320 x 240 pixlar.

.bredd

.width returnerar bredden på det detekterade objektet i pixlar, vilket är ett heltal mellan 1 och 320.

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    drivetrain.turn_for(LEFT, 70, DEGREES)

    # Approach the next Cup and Pin
    drivetrain.set_drive_velocity(30, PERCENT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].width > 140:
                drivetrain.stop()
                break
            else:
                drivetrain.drive(FORWARD)

# VR threads — Do not delete
vr_thread(main)

.höjd

.height returnerar höjden på det detekterade objektet i pixlar, vilket är ett heltal mellan 1 och 240.

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    drivetrain.turn_for(LEFT, 70, DEGREES)

    # Approach the next Cup and Pin
    drivetrain.set_drive_velocity(30, PERCENT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].height > 200:
                drivetrain.stop()
                break
            else:
                drivetrain.drive(FORWARD)

# VR threads — Do not delete
vr_thread(main)

.centerX

.centerX returnerar x-koordinaten för det detekterade objektets centrum i pixlar, vilket är ett heltal mellan 0 och 320.

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    drivetrain.turn_for(LEFT, 70, DEGREES)

    # Turn and approach the next Cup and Pin
    drivetrain.set_turn_velocity(30, PERCENT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].centerX < 140:
                drivetrain.turn_for(LEFT, 5, DEGREES)
            else: 
                drivetrain.drive_for(FORWARD, 25, INCHES)
                break

# VR threads — Do not delete
vr_thread(main)

.centerY

.centerY returnerar y-koordinaten för det detekterade objektets centrum i pixlar, vilket är ett heltal mellan 0 och 240.

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    drivetrain.turn_for(LEFT, 70, DEGREES)

    # Approach the next Cup and Pin
    drivetrain.set_drive_velocity(30, PERCENT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].centerY > 230:
                drivetrain.stop()
                break
            else:
                drivetrain.drive(FORWARD)

# VR threads — Do not delete
vr_thread(main)

.originX

.originX returnerar x-koordinaten för det övre vänstra hörnet av det detekterade objektets avgränsningsram i pixlar, vilket är ett heltal mellan 0 och 320.

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    drivetrain.turn_for(LEFT, 70, DEGREES)

    # Turn and approach the next Cup and Pin
    drivetrain.set_turn_velocity(30, PERCENT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].originX < 100:
                drivetrain.turn_for(LEFT, 5, DEGREES)
            else:
                drivetrain.drive_for(FORWARD, 25, INCHES)
                break

# VR threads — Do not delete
vr_thread(main)

.ursprungY

.originY returnerar y-koordinaten för det övre vänstra hörnet av det detekterade objektets avgränsningsram i pixlar, vilket är ett heltal mellan 0 och 240.

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    drivetrain.turn_for(LEFT, 70, DEGREES)

    # Approach the next Cup and Pin
    drivetrain.set_drive_velocity(30, PERCENT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].originY > 140:
                drivetrain.stop()
                break
            else:
                drivetrain.drive(FORWARD)

# VR threads — Do not delete
vr_thread(main)

.id

.id returnerar ID:t för den detekterade AI-klassificeringen som ett heltal.

AI-klassificering	id	Signatur
RödBlåPin	0	GameElements.RED_BLUE_PIN
BlåGulPin	1	GameElements.BLUE_YELLOW_PIN
RödGulPin	2	GameElements.RED_YELLOW_PIN
GulPin	3	GameElements.YELLOW_PIN
Kopp	4	GameElements.CUP

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    drivetrain.turn_for(LEFT, 70, DEGREES)

    # Display the ID of the next closest object
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            brain.screen.print(ai_objects[0].id)
            break

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

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)

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 number of loops
    global loops
    monitor_variable("loops")

    # Turn in a full circle 3 times
    for loops in range(12):
        drivetrain.turn_for(RIGHT, 90, DEGREES)

# 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

Sensorvärdet som ska övervakas, angivet som en sträng. För att övervaka mer än ett sensorvärde, separera varje sensorvärde med ett kommatecken. Stödda sensoridentifierare inkluderar: Brain brain.timer.time Drivetrain drivetrain.is_done drivetrain.is_moving drivetrain.heading drivetrain.rotation drivetrain.velocity arm_motor.is_done arm_motor.is_spinning arm_motor.position arm_motor.velocity Claw Motor claw_motor.is_done claw_motor.is_spinning claw_motor.position claw_motor.velocity Avståndssensor distance.is_object_detected distance.object_distance_mm distance.object_distance_inches GPS-sensor gps.position_mm gps.position_inches gps.heading AI-visionssensor 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)

Avkänning

Avstånd

hittat_objekt

found_object returnerar om avståndssensorn för närvarande detekterar ett objekt inom 2000 mm.

• True — Avståndssensorn detekterar ett objekt.

• False — Avståndssensorn detekterar inget objekt.

Usage:
distance.found_object()

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

def main():
    # Turn until something is detected, then release the Pin
    drivetrain.turn(RIGHT)
    while True:
        wait(5, MSEC)
        if distance.found_object():
            drivetrain.stop()
            break
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

objektavstånd

object_distance returnerar avståndet mellan avståndssensorn och det närmaste detekterade objektet.

Usage:
distance.object_distance(units)

Parametrar	Beskrivning
units	Avståndsenheten: MM eller INCHES.

def main():
    # Drive until 200 mm from the Goal, then release the Pin
    while distance.object_distance(MM) > 200:
        wait(5, MSEC)
        drivetrain.drive(FORWARD)
    drivetrain.stop()
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

GPS

x_position

x_position returnerar den aktuella x-koordinaten för en GPS-sensor (Game Positioning System™) på planen.

Usage:
gps.x_position(units)

Parametrar	Beskrivning
enheter	Enheten för offsetvärdet: INCHES eller MM

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive(FORWARD)
    while not gps.x_position(MM) > -1370:
        wait(2, MSEC)
    drivetrain.stop()
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

y-position

y_position returnerar den aktuella y-koordinaten för en GPS-sensor (Game Positioning System™) på planen.

Usage:
gps.y_position(units)

Parametrar	Beskrivning
enheter	Enheten för offsetvärdet: INCHES eller MM

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive(FORWARD)
    while not gps.y_position(MM) < -450:
        wait(2, MSEC)
    drivetrain.stop()
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

rubrik

heading returnerar den kurs som roboten för närvarande är vänd mot baserat på GPS-sensorns (Game Positioning System™) avläsningar från 0 till 359 grader.

Usage:
gps.heading()

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    monitor_sensor("gps.heading")
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    # Turn left to face the Neutral Goal
    drivetrain.set_turn_velocity(30, PERCENT)
    drivetrain.turn(LEFT)
    while not gps.heading() < 18:
        wait(2, MSEC)
    drivetrain.stop()


# VR threads — Do not delete
vr_thread(main)