Robotiem specifisks Python#

Ievads#

Varoņa robotam Flex ir iekļauts spīļu motors, rokas motors, mākslīgā intelekta redzes sensors, attāluma sensors un spēles pozicionēšanas sistēmas (GPS) sensors.

Visas standarta VEXcode VR metodes ir pieejamas lietošanai V5 26-27 Override rotaļu laukumā.

Zemāk ir saraksts ar visām pieejamajām robotam specifiskajām metodēm:

Piedziņa — pārvietojiet un pagrieziet robotu.

  • Darbības

    • drive — Pārvieto robotu uz priekšu vai atpakaļ uz visiem laikiem.

    • drive_for — Pārvieto robotu uz priekšu vai atpakaļ noteiktu attālumu.

    • turn — Pagriež robotu pa kreisi vai pa labi uz visiem laikiem.

    • turn_for — Pagriež robotu pa kreisi vai pa labi par noteiktu grādu skaitu.

    • turn_to_heading — Pagriež robotu noteiktā virzienā no -359 līdz 359 grādiem.

    • turn_to_rotation — Pagriež robotu noteiktā rotācijā.

    • stop — Aptur robota kustību.

  • Mutatori

  • Geters

    • heading — Atgriež robota pašreizējo virzienu no 0 līdz 359,99 grādiem.

    • rotation — Atgriež robota pašreizējo rotāciju.

    • is_done — Atgriež, vai robots ir pabeidzis kustību, kā Būla vērtību.

    • is_moving — Atgriež, vai robots kustas, kā Būla vērtību.

    • velocity — Atgriež robota braukšanas ātrumu.

Kustība — pārvietojiet un izsekojiet robota motorus.

  • Darbības

    • spin — Griež motoru uz priekšu vai atpakaļ bezgalīgi.

    • spin_for — Griež motoru noteiktu attālumu.

    • spin_to_position — Pagriež motoru uz noteiktu pozīciju.

    • stop — Aptur motora griešanos.

  • Mutatori

    • set_position — Maina motora pašreizējo pozīciju uz jaunu vērtību.

    • set_velocity — Norāda motoram, cik ātri griezties.

    • set_timeout — Iestata, cik daudz laika motors mēģinās pabeigt kustību.

  • Geters

    • is_done — Atgriež, vai motors ir beidzis kustību, kā Būla vērtību.

    • is_spinning — Atgriež, vai motors griežas, kā Būla vērtību.

    • position — Atgriež motora pašreizējo pozīciju.

    • velocity — Atgriež motora griešanās ātrumu.

AI redze — uztveriet un analizējiet objektus, izmantojot AI redzes sensoru.

  • Geters

    • take_snapshot – Atgriež noteikta paraksta noteikto objektu sarakstu.

  • Īpašumi

    • .width – Noteiktā objekta platums pikseļos.

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

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

    • .centerY – objekta centra Y pozīcija pikseļos.

    • .originX – objekta augšējā kreisā stūra X pozīcija pikseļos.

    • .originY – objekta augšējā kreisā stūra Y pozīcija pikseļos.

    • .id – Classification ID of the detected object.

Konsole — izdrukājiet vērtības konsolē un uzraugiet tās.

Sensēšana — izmantojiet robota dažādos sensorus.

  • Attālums

    • found_object – Atgriež, vai attāluma sensors uztver objektu diapazonā.

    • object_distance – Atgriež attālumu starp attāluma sensoru un tuvāko noteikto objektu.

  • GPS

    • x_position – Atgriež GPS sensora pašreizējo x koordinātu laukā.

    • y_position – Atgriež GPS sensora pašreizējo y koordinātu laukā.

    • heading – Atgriež robota pašreizējo virzienu, pamatojoties uz GPS sensoru.

Šajā lapā redzamajos piemēros tiek izmantota sākuma atrašanās vieta C no Rotaļu laukuma pirmsspēles kontrolsaraksta.

Piedziņa#

Piedziņa kontrolē VR robota braukšanu un pagriezienus. Piedziņa var pārvietoties uz priekšu vai atpakaļ, pagriezties pa kreisi vai pa labi, mainīt virzienu un izsekot rotācijai.

Darbības#

braukt#

drive pārvieto robotu uz priekšu vai atpakaļ bezgalīgi. Robots turpinās kustēties, līdz tam tiks dota cita darbība, piemēram, pagriešana vai apstāšanās.

Usage:
drivetrain.drive(direction)

Parametri

Apraksts

direction

Robota kustības virziens: FORWARD vai 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)

braukt_pēc#

drive_for pārvieto robotu uz priekšu vai atpakaļ noteiktu attālumu. Projekts gaidīs, līdz robots būs pabeidzis kustību, pirms tiks palaista nākamā koda rinda.

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

Parametri

Apraksts

direction

Robota kustības virziens: FORWARD vai REVERSE.

distance

Robota nobrauktais attālums. Tas var būt vesels skaitlis integer vai decimālskaitlis (float).

units

Neobligāti. Attāluma mērvienība: INCHES (pēc noklusējuma) vai MM (milimetri).

wait

Neobligāti. wait=True (noklusējums) liek projektam gaidīt, līdz robots ir beidzis kustību, pirms tiek palaista nākamā koda rinda. wait=False liek nekavējoties palaist nākamo koda rindu.

 
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)

pagrieziens#

turn pagriež robotu pa kreisi vai pa labi uz visiem laikiem. Robots turpinās griezties, līdz tam tiks dota cita darbība, piemēram, braukšana vai apstāšanās.

Usage:
drivetrain.turn(direction)

Parametri

Apraksts

direction

Robota griešanās virziens: LEFT vai 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)

pagrieziens_par#

turn_for pagriež robotu pa kreisi vai pa labi par noteiktu grādu skaitu. Pagrieziens ir relatīvs attiecībā pret robota pašreizējo pozīciju. Projekts gaidīs, līdz robots būs pabeidzis pagriešanos, pirms tiks palaista nākamā koda rinda.

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

Parametri

Apraksts

direction

Robota griešanās virziens: LEFT vai RIGHT.

angle

Robota pagrieziena grādu skaits. Tas var būt vesels skaitlis integer vai decimālskaitlis (float).

units

Neobligāti. Leņķa mērvienība: DEGREES (pēc noklusējuma).

wait

Neobligāti. wait=True (noklusējums) liek projektam gaidīt, līdz robots ir pabeidzis pagriešanos, pirms tiek palaista nākamā koda rinda. wait=False liek nekavējoties palaist nākamo koda rindu.

 
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)

pagrieziena_uz_virzienu#

Virziens ir virziens, kurā robots ir pagriezies, mērot grādos. turn_to_heading pagriež robotu noteiktā virzienā no -359 līdz 359 grādiem. Robots pagriezīsies īsākajā virzienā, lai sasniegtu mērķa virzienu.

Sākuma kurss ir 0 grādi.

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

Parametri

Apraksts

heading

Robota virziens no -359 līdz 359 grādiem.

units

Neobligāti. Leņķa mērvienība: DEGREES (pēc noklusējuma).

wait

Neobligāti. wait=True (noklusējums) liek projektam gaidīt, līdz robots ir pabeidzis pagriešanos, pirms tiek palaista nākamā koda rinda. wait=False liek nekavējoties palaist nākamo koda rindu.

 
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)

pagrieziena_līdz_rotācijai#

turn_to_rotation pagriež robotu noteiktā rotācijā.

Rotācija ir robota pagrieziena lielums, mērot grādos. Projekta sākumā rotācijas vērtība ir iestatīta uz 0 grādiem. Pagriežot pa labi, rotācija palielinās, bet pagriežot pa kreisi, tā samazinās.

Piemēram, ja robots sāk braukt no 0 grādiem un pagriežas par 720 grādiem, tas divas reizes pagriezīsies pa labi. Ja tas pēc tam pagriezīsies par 360 grādiem, tas vienu reizi pagriezīsies pa kreisi, jo 360 grādi ir mazāki par 720 grādiem.

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

Parametri

Apraksts

rotation

Rotācijas vērtība grādos, kādā robots pagriezīsies. Tā var būt vesels skaitlis integer vai decimālskaitlis (float).

units

Neobligāti. Leņķa mērvienība: DEGREES (pēc noklusējuma).

wait

Neobligāti. wait=True (noklusējums) liek projektam gaidīt, līdz robots ir pabeidzis pagriešanos, pirms tiek palaista nākamā koda rinda. wait=False liek nekavējoties palaist nākamo koda rindu.

 
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)

apstāties#

stop aptur robota kustību.

Usage:
drivetrain.stop()

Parametri

Apraksts

Šai metodei nav parametru.

 
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)

Mutatori#

set_header#

Virziens ir virziens, kurā robots ir pagriezies, mērot grādos. set_heading maina robota pašreizējo virzienu uz jaunu virziena vērtību.

Piemēram, ja robots ir pagriezies pa labi, iestatot virzienu uz 0 grādiem, šī pozīcija, kas vērsta pa labi, kļūst par jauno 0 grādu pozīciju. Pēc tam robots var pagriezties uz citām pozīcijām, pamatojoties uz šo jauno virzienu.

Usage:
drivetrain.set_heading(heading, units)

Parametri

Apraksts

heading

Robota virziena vērtība grādos, kas jāiestata.

units

Neobligāti. Leņķa mērvienība: DEGREES (pēc noklusējuma).

 
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#

Rotācija ir robota pagrieziena lielums, mērīts grādos. set_rotation maina robota pašreizējo rotāciju uz jaunu vērtību.

Usage:
drivetrain.set_rotation(rotation, units)

Parametri

Apraksts

rotation

Robota iestatāmā rotācijas vērtība grādos. Tā var būt vesels skaitlis integer vai decimālskaitlis (float).

units

Neobligāti. Leņķa mērvienība: DEGREES (pēc noklusējuma).

 
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)

iestatīts_laika_izslēgums#

set_timeout nosaka, cik sekundes robots mēģinās pabeigt kustību. Ja robots nevar pabeigt šajā laikā, tas pārtrauks mēģinājumu un pāries uz nākamo koda rindiņu. Tas neļauj robotam iestrēgt kustībā.

Usage:
drivetrain.set_timeout(time, units)

Parametri

Apraksts

time

Sekunžu skaits, kurā robots var mēģināt pabeigt kustību. Tas var būt pozitīvs skaitlis integer vai decimālskaitlis (float).

units

Neobligāti. Laika mērvienība: SECONDS (pēc noklusējuma) vai 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)

iestatīt_piedziņas_ātrumu#

set_drive_velocity norāda robotam, cik ātri jābrauc. Augstāka procentuālā vērtība liek robotam braukt ātrāk, bet zemāka procentuālā vērtība liek robotam braukt lēnāk.

Katrs projekts sākas ar robota kustību ar noklusējuma ātrumu 50%.

Piezīme: Lielāks ātrums padara robotu ātrāku, bet tas var būt mazāk precīzs. Mazāks ātrums padara robotu lēnāku, bet tas var būt precīzāks.

Usage:
drivetrain.set_drive_velocity(velocity, units)

Parametri

Apraksts

velocity

Braukšanas ātrums no 0% līdz 100%. Tas var būt vesels skaitlis integer vai decimālskaitlis (float).

units

Pēc izvēles. Ātruma mērvienība: PERCENT (pēc noklusējuma).

 
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)

iestatīts_pagrieziena_ātrums#

set_turn_velocity norāda robotam, cik ātri griezties. Augstāka procentuālā vērtība liek robotam griezties ātrāk, bet zemāka procentuālā vērtība liek robotam griezties lēnāk.

Katrs projekts sākas ar robota griešanos ar noklusējuma ātrumu 50%.

Piezīme: Lielāks ātrums liek robotam griezties ātrāk, bet tas var būt mazāk precīzs. Mazāks ātrums liek robotam griezties lēnāk, bet tas var būt precīzāks.

Usage:
drivetrain.set_turn_velocity(velocity, units)

Parametri

Apraksts

velocity

Griešanās ātrums no 0% līdz 100%. Tas var būt vesels skaitlis integer vai decimālskaitlis (float).

units

Pēc izvēles. Ātruma mērvienība: PERCENT (pēc noklusējuma).

 
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)

Getteri#

virsraksts#

Virziens ir virziens, kurā robots ir pagriezies, mērot grādos. heading atgriež robota pašreizējo virzienu no 0 līdz 359,99 grādiem.

Robota sākuma virziens ir 0 grādi.

Usage:
drivetrain.heading(units)

Parametri

Apraksts

units

Neobligāti. Virziena mērvienība: DEGREES (pēc noklusējuma).

 
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)

rotācija#

Rotācija ir robota pagrieziena lielums, mērot grādos. Projekta sākumā rotācijas vērtība ir iestatīta uz 0 grādiem. rotation atgriež robota pašreizējo rotāciju.

Pagriežoties pa labi, rotācija palielinās, bet pagriežoties pa kreisi, tā samazinās. Piemēram, veicot divus pilnus pagriezienus pa labi, rotācija būs 720 grādi.

Usage:
drivetrain.rotation(units)

Parametri

Apraksts

units

Neobligāti. Rotācijas vienība: DEGREES (pēc noklusējuma).

 
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)

ir_pabeigts#

is_done atgriež, vai robots ir pabeidzis kustību, kā Būla vērtību. To var izmantot, lai kontrolētu citu darbību laiku, pamatojoties uz robota kustību.

  • True — Robots ir pabeidzis kustību.

  • False — Robots joprojām kustas.

Šī metode darbojas kopā ar šādām Drivetrain metodēm, kurām ir parametrs wait : drive_for, turn_for, turn_to_heading un turn_to_rotation.

Usage:
drivetrain.is_done()

Parametri

Apraksts

Šai metodei nav parametru.

 
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)

pārvietojas#

is_moving atgriež, vai robots kustas, kā Būla vērtību. To var izmantot, lai kontrolētu citu darbību laiku, pamatojoties uz robota kustību.

  • True — Robots kustas.

  • False — Robots nekustas.

Usage:
drivetrain.is_moving()

Parametri

Apraksts

Šai metodei nav parametru.

 
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)

ātrums#

velocity atgriež robota braukšanas ātrumu procentos no -100% līdz 100%.

Usage:
drivetrain.velocity(units)

Parametri

Apraksts

units

Pēc izvēles. Ātruma mērvienība: PERCENT (pēc noklusējuma).

 
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)

Kustība#

Flex izmanto rokas motoru, lai paceltu un nolaistu roku, un spīļu motoru, lai atvērtu un aizvērtu spīli.

Katram motoram ir sava virziena uzvedība. Virzienu aprakstos ir paskaidrots, kā katrs virziens pārvieto motoru uz Flex.

Darbības#

grieziens#

spin griež motoru vienā no diviem virzieniem mūžīgi. Motors turpinās griezties, līdz tam tiks dota cita darbība, piemēram, griezties citā virzienā vai apstāties.

Lietojums:
Ar šo metodi var izmantot vienu no diviem pieejamajiem motora objektiem, kā parādīts tālāk:

motors

Komanda

arm_motor

arm_motor.spin(direction) — Rokas motors

claw_motor

claw_motor.spin(direction) — Spīļveida motors

Parametri

Apraksts

direction

Motora griešanās virziens:

  • FORWARD — Pārvieto rokas motoru uz augšu vai aizver spīļu motoru.
  • REVERSE — Pārvieto rokas motoru uz leju vai atver spīļu motoru.

 
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)

grieziena_priekšmets#

spin_for griež motoru noteiktu attālumu. Griešanās ātrums ir relatīvs attiecībā pret motora pašreizējo pozīciju. Projekts gaidīs, līdz motors būs beidzis griezties, pirms tiks palaista nākamā koda rinda.

Lietojums:
Ar šo metodi var izmantot vienu no diviem pieejamajiem motora objektiem, kā parādīts tālāk:

motors

Komanda

arm_motor

arm_motor.spin_for(direction, distance, units, wait) — Rokas motors

claw_motor

claw_motor.spin_for(direction, distance, units, wait) — Claw Motor

Parametri

Apraksts

direction

Motora griešanās virziens:

  • FORWARD — Pārvieto rokas motoru uz augšu vai aizver spīļu motoru.
  • REVERSE — Pārvieto rokas motoru uz leju vai atver spīļu motoru.

distance

Attālums, kādā griežas motors. DEGREES izmanto veselus skaitļus. TURNS var izmantot veselus skaitļus vai decimālskaitļus.

units

Neobligāti. Attāluma mērvienība: DEGREES (pēc noklusējuma) vai TURNS.

wait

Neobligāti.

  • wait=True (noklusējums) — Liek projektam gaidīt, līdz motors ir beidzis griezties, pirms tiek palaista nākamā koda rinda.
  • wait=False — Liek nekavējoties palaist nākamo koda rindu.

 
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)

griezt_līdz_pozīcijai#

spin_to_position griež motoru uz noteiktu pozīciju.

Motora pozīcija norāda, cik tālu tas ir pagriezies, mērot DEGREES vai TURNSViens pagrieziens ir vienāds ar 360 grādiem. Projekta sākumā rokas motora pozīcija ir iestatīta uz 0 grādiem. Nažveida motors ir izņēmums — tas sāk darboties ar 467 grādiem (pilnībā aizvērts). Motora pozīciju var iestatīt arī, izmantojot metodi set_position.

Pozīcijas vērtības ir absolūtas. Tas nozīmē, ka griešanās virziens ir atkarīgs no motora pašreizējās pozīcijas.

Piemēram, ja motors iedarbojas pie 0 grādiem un griežas līdz 720 grādu pozīcijai, tas griezīsies divus apgriezienus uz priekšu. Ja tas pēc tam griežas līdz 360 grādu pozīcijai, tas griezīsies atpakaļ par vienu apgriezienu, jo 360 grādi ir mazāki par 720.

Lietojums:
Ar šo metodi var izmantot vienu no diviem pieejamajiem motora objektiem, kā parādīts tālāk:

motors

Komanda

arm_motor

arm_motor.spin_to_position(angle, units, wait=True) — Rokas motors

claw_motor

claw_motor.spin_to_position(angle, units, wait=True) — Spīļveida motors

Parametri

Apraksts

angle

Pozīcijas vērtība, līdz kurai motors griezīsies. DEGREES izmanto veselus skaitļus. TURNS var izmantot veselus skaitļus vai decimālskaitļus.

units

Pēc izvēles. Pozīcijas mērvienība: DEGREES (pēc noklusējuma) vai TURNS.

wait

Neobligāti.

  • wait=True (noklusējums) — Liek projektam gaidīt, līdz motors ir beidzis griezties, pirms tiek palaista nākamā koda rinda.
  • wait=False — Liek nekavējoties palaist nākamo koda rindu.

 
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)

apstāties#

stop aptur motora griešanos.

Lietojums:
Ar šo metodi var izmantot vienu no diviem pieejamajiem motora objektiem, kā parādīts tālāk:

motors

Komanda

arm_motor

arm_motor.stop() — Rokas motors

claw_motor

claw_motor.stop() — Spīļveida motors

Parametri

Apraksts

Šai metodei nav parametru.

 
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)

Mutatori#

iestatītā_pozīcija#

Motora pozīcija norāda, cik tālu tas ir pagriezies, mērot DEGREES vai TURNSViens apgrieziens ir vienāds ar 360 grādiem. set_position maina motora pašreizējo pozīciju uz jaunu vērtību.

Piemēram, ja motors ir pagriezies līdz 180 grādiem, pozīcijas iestatīšana uz 0 grādiem atiestatīs šo pozīciju no 180 uz 0 grādiem. Pēc tam motors var griezties pozīcijās, pamatojoties uz šo jauno vērtību.

Lietojums:
Ar šo metodi var izmantot vienu no diviem pieejamajiem motora objektiem, kā parādīts tālāk:

motors

Komanda

arm_motor

arm_motor.set_position(position, units) — Rokas motors

claw_motor

claw_motor.set_position(position, units) — Spīļveida motors

Parametri

Apraksts

position

Motora pozīcijas vērtība, kas jāiestata. DEGREES izmanto veselus skaitļus. TURNS var izmantot veselus skaitļus vai decimālskaitļus.

units

Pēc izvēles. Pozīcijas mērvienība: DEGREES (pēc noklusējuma) vai 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)

iestatīt_ātrumu#

set_velocity norāda motoram, cik ātri griezties. Augstāka procentuālā vērtība liek motoram griezties ātrāk, bet zemāka procentuālā vērtība liek motoram griezties lēnāk.

Katrs projekts sākas ar to, ka katrs motors pēc noklusējuma griežas ar 50% ātrumu.

Piezīme: Lielāks ātrums liek motoram griezties ātrāk, bet tas var būt mazāk precīzs. Mazāks ātrums liek motoram griezties lēnāk, bet tas var būt precīzāks.

Lietojums:
Ar šo metodi var izmantot vienu no diviem pieejamajiem motora objektiem, kā parādīts tālāk:

motors

Komanda

arm_motor

arm_motor.set_velocity(velocity, units) — Rokas motors

claw_motor

claw_motor.set_velocity(velocity, units) — Spīļveida motors

Parametri

Apraksts

velocity

Griešanās ātrums no 0% līdz 100%. Tas var būt vesels skaitlis integer vai decimālskaitlis (float).

units

Ātruma mērvienība: 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)

iestatīts_laika_izslēgums#

set_timeout nosaka, cik ilgi motors mēģinās pabeigt kustību. Ja motors nevar pabeigt šajā laikā, tas pārtrauks mēģinājumu un pāries uz nākamo koda rindiņu. Tas neļauj motoram iestrēgt kustībā.

Lietojums:
Ar šo metodi var izmantot vienu no diviem pieejamajiem motora objektiem, kā parādīts tālāk:

motors

Komanda

arm_motor

arm_motor.set_timeout(value, units) — Ieslēgt motoru

claw_motor

claw_motor.set_timeout(value, units) — Claw Motor

Parametri

Apraksts

value

Laiks, kurā motors var mēģināt pabeigt kustību. Tas var būt pozitīvs skaitlis integer vai decimālskaitlis (float).

units

Laika mērvienība: SECONDS vai MSEC (milisekundes).

 
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)

Getteri#

ir_pabeigts#

is_done atgriež, vai motors ir beidzis kustību, kā Būla vērtību. To var izmantot, lai kontrolētu citu darbību laiku, pamatojoties uz motora kustību.

  • True — Motors ir beidzis kustību.

  • False — Motors joprojām kustas.

Šī metode darbojas kopā ar šādām kustības metodēm, kurām ir parametrs wait : spin_for un spin_to_position.

Lietojums:
Ar šo metodi var izmantot vienu no diviem pieejamajiem motora objektiem, kā parādīts tālāk:

motors

Komanda

arm_motor

arm_motor.is_done() — Rokas motors

claw_motor

claw_motor.is_done() — Spīļveida motors

Parametri

Apraksts

Šai metodei nav parametru.

 
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)

griežas#

is_spinning atgriež, vai motors griežas, kā Būla vērtību. To var izmantot, lai kontrolētu citu darbību laiku, pamatojoties uz motora kustību.

  • True — Motors griežas.

  • False — Motors negriežas.

Šī metode darbojas kopā ar šādām kustības metodēm, kurām ir parametrs wait : spin_for un spin_to_position.

Lietojums:
Ar šo metodi var izmantot vienu no diviem pieejamajiem motora objektiem, kā parādīts tālāk:

motors

Komanda

arm_motor

arm_motor.is_spinning() — Rokas motors

claw_motor

claw_motor.is_spinning() — Spīļveida motors

Parametri

Apraksts

Šai metodei nav parametru.

 
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)

pozīcija#

Motora pozīcija norāda, cik tālu tas ir pagriezies, mērot DEGREES vai TURNSViens pagrieziens ir vienāds ar 360 grādiem. position atgriež motora pašreizējo pozīciju.

Projekta sākumā rokas motora pozīcija ir iestatīta uz 0 grādiem. Izņēmums ir spīļu motors — tas sāk darboties 467 grādos (pilnībā aizvērts). Ja motors griežas vienu pilnu apgriezienu uz priekšu, pozīcija palielinās. Ja motors griežas pretējā virzienā, pozīcija samazinās.

Lietojums:
Ar šo metodi var izmantot vienu no diviem pieejamajiem motora objektiem, kā parādīts tālāk:

motors

Komanda

arm_motor

arm_motor.position(units) — Rokas motors

claw_motor

claw_motor.position(units) — Spīļveida motors

Parametri

Apraksts

units

Bloks, kas atgriež motora pozīciju: DEGREES vai 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)

ātrums#

velocity atgriež motora griešanās ātrumu.

Pozitīva vērtība nozīmē, ka motors griežas uz priekšu. Negatīva vērtība nozīmē, ka motors griežas atpakaļgaitā.

Lietojums:
Ar šo metodi var izmantot vienu no diviem pieejamajiem motora objektiem, kā parādīts tālāk:

motors

Komanda

arm_motor

arm_motor.velocity(units) — Rokas motors

claw_motor

claw_motor.velocity(units) — Claw Motor

Parametri

Apraksts

units

Atgriežamā ātruma mērvienība: 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)

Mākslīgā intelekta vīzija#

Getteri#

uzņemt_momentuzņēmumu#

take_snapshot filtrē datus no AI redzes sensora kadra līdz vienam parakstam — saglabātam aprakstam par kaut ko, ko sensors var atpazīt, piemēram, spēles elementu laukumā — un atgriež kortežu.

Kortežs saglabā objektus, kas sakārtoti no lielākā līdz mazākajam pēc platuma, sākot ar indeksu 0. Katra objekta īpašībām var piekļūt, izmantojot tā indeksu. Ja netiek atrasti atbilstoši objekti, tiek atgriezts tukšs kortežs.

Usage:
ai_vision.take_snapshot(signature)

Parametri

Apraksts

signature

Filtrē datu kopu, lai iekļautu tikai dotā paraksta datus. Pieejamie paraksti ir:

  • AiVision.ALL_AIOBJS  — nosaka visus spēles elementus.
  • GameElements.RED_BLUE_PIN  — nosaka RedBluePin spēles elementus.
  • GameElements.BLUE_YELLOW_PIN  — nosaka BlueYellowPin spēles elementus.
  • GameElements.RED_YELLOW_PIN  — nosaka RedYellowPin spēles elementus.
  • GameElements.YELLOW_PIN  — nosaka YellowPin spēles elementus.
  • GameElements.CUP  — nosaka Cup spēles elementus.

 
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)

Īpašumi#

Pēc take_snapshot izmantošanas katrā objektā, kas tiek glabāts kortežā, ir iekļautas septiņas īpašības.

Visas rekvizītu vērtības, izņemot .id apraksta noteiktā objekta pozīciju un izmēru AI redzes sensora skatā brīdī, kad tika izmantots take_snapshot Šīs vērtības tiek mērītas pikseļos, pamatojoties uz sensora 320 x 240 pikseļu izšķirtspēju.

.platums#

.width atgriež noteiktā objekta platumu pikseļos, kas ir vesels skaitlis no 1 līdz 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)

.augstums#

.height atgriež noteiktā objekta augstumu pikseļos, kas ir vesels skaitlis no 1 līdz 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 atgriež noteiktā objekta centra x koordinātu pikseļos, kas ir vesels skaitlis no 0 līdz 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 atgriež noteiktā objekta centra y koordinātu pikseļos, kas ir vesels skaitlis no 0 līdz 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 atgriež noteiktā objekta ierobežojošā lodziņa augšējā kreisā stūra x koordinātu pikseļos, kas ir vesels skaitlis no 0 līdz 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)

.originY#

.originY atgriež noteiktā objekta ierobežojošā lodziņa augšējā kreisā stūra y koordinātu pikseļos, kas ir vesels skaitlis no 0 līdz 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 atgriež noteiktās AI klasifikācijas ID kā veselu skaitli.

AI klasifikācija

id

Paraksts

RedBluePin

0

GameElements.RED_BLUE_PIN

ZilaDzeltenaPiespraude

1

GameElements.BLUE_YELLOW_PIN

SarkansDzeltensPiespraude

2

GameElements.RED_YELLOW_PIN

Dzeltenā piespraude

3

GameElements.YELLOW_PIN

Kauss

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)

Konsole#

Kamēr projekts darbojas, konsolē tiek parādīts teksts, skaitļi un mainīgo vērtības. Konsoles metodes var arī pārvietot kursoru uz jaunu rindu, notīrīt konsoli un pievienot mainīgos vai sensoru vērtības cilnei Monitor.

Drukāt#

smadzeņu.ekrāna.izdruka#

brain.screen.print konsolē parāda tekstu, skaitļus vai mainīgo vērtības, izmantojot pašreizējo kursora pozīciju.

Izmantojiet brain.screen.next_row, ja vēlaties, lai nākamā drukātā vērtība sāktos jaunā rindā.

Usage:
brain.screen.print(value)

Parametri

Apraksts

value

Teksts, skaitlis vai mainīgā vērtība, kas jāparāda konsolē.

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

# VR threads — Do not delete
vr_thread(main)

smadzeņu.ekrāns.nākamā_rinda#

brain.screen.next_row pārvieto kursoru uz 1. kolonnu nākamajā konsoles rindā. Nākamā izdrukātā vērtība parādīsies šajā rindā.

Usage:
brain.screen.next_row()

Parametri

Apraksts

Šai metodei nav parametru.

 
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)

smadzeņu.screen.clear_screen#

brain.screen.clear_screen notīra visas rindas no konsoles un pārvieto kursoru atpakaļ uz 1. rindu.

Usage:
brain.screen.clear_screen()

Parametri

Apraksts

Šai metodei nav parametru.

 
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)

Monitors#

monitora_mainīgais#

monitor_variable pievieno vienu vai vairākus iepriekš definētus mainīgos VEXcode cilnei Monitor. Tas ļauj vērot mainīgā vērtības izmaiņas projekta darbības laikā.

Mainīgajiem jābūt globāliem monitor_variable varētu veiksmīgi uzraudzīt. Norādiet katra mainīgā nosaukumu kā virkni.

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

Parametri

Apraksts

variable

Iepriekš definēta globālā mainīgā nosaukums, kas jāuzrauga, norādot kā virkni. Lai uzraudzītu vairākus mainīgos, atdaliet katru mainīgā nosaukumu ar komatu.

 
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)

monitora_sensors#

monitor_sensor pievieno vienu vai vairākas sensoru vērtības cilnei “Monitor” programmā VEXcode. Tas ļauj vērot sensoru vērtību izmaiņas projekta darbības laikā.

Norādiet katra sensora vērtību kā virkni.

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

Parametri

Apraksts

sensor

Sensora vērtība, kas jāuzrauga, norādīta kā virkne. Lai uzraudzītu vairākas sensora vērtības, atdaliet katru sensora vērtību ar komatu. Atbalstītie sensoru identifikatori ietver:

  • Brain
    • brain.timer.time
  • Drivetrain
    • drivetrain.is_done
    • drivetrain.is_moving
    • drivetrain.heading
    • drivetrain.rotation
    • drivetrain.velocity
  • Arm Motor
    • 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
  • Attāluma sensors
    • distance.is_object_detected
    • distance.object_distance_mm
    • distance.object_distance_inches
  • GPS sensors
    • gps.position_mm
    • gps.position_inches
    • gps.heading
  • Mākslīgā intelekta redzes sensors
    • 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)

Sensori#

Attālums#

atrastais_objekts#

found_object atgriež, vai attāluma sensors pašlaik nosaka objektu 2000 mm attālumā.

  • True — Attāluma sensors nosaka objektu.

  • False — Attāluma sensors neuztver objektu.

Usage:
distance.found_object()

Parametri

Apraksts

Šai metodei nav parametru.

 
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)

objekta_attālums#

object_distance atgriež attālumu starp attāluma sensoru un tuvāko noteikto objektu.

Usage:
distance.object_distance(units)

Parametri

Apraksts

units

Attāluma mērvienība: MM vai 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_pozīcija#

x_position atgriež GPS (Game Positioning System™) sensora pašreizējo x koordinātu laukumā.

Usage:
gps.x_position(units)

Parametri

Apraksts

vienības

Nobīdes vērtības mērvienība: INCHES vai 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_pozīcija#

y_position atgriež GPS (Game Positioning System™) sensora pašreizējo y koordinātu laukā.

Usage:
gps.y_position(units)

Parametri

Apraksts

vienības

Nobīdes vērtības mērvienība: INCHES vai 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)

virsraksts#

heading atgriež robota pašreizējo virzienu, pamatojoties uz GPS (Game Positioning System™) sensora rādījumiem no 0 līdz 359 grādiem.

Usage:
gps.heading()

Parametri

Apraksts

Šai metodei nav parametru.

 
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)
On this page