Robotiem specifisks Python#

Ievads #

Varoņa robotam Mobijam ir motoru grupa, optiskais sensors, rotācijas sensors un spēles pozicionēšanas sistēmas (GPS) sensors.

Visas standarta VEXcode VR metodes ir pieejamas lietošanai V5 21-22 Tipping Point 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
- set_heading — Maina robota pašreizējo virzienu uz jaunu virzienu.
- set_rotation — Maina robota pašreizējo rotāciju uz jaunu rotāciju.
- set_timeout — Iestata, cik daudz laika robots mēģinās pabeigt kustību.
- set_drive_velocity — Norāda robotam, cik ātri braukt.
- set_turn_velocity — Norāda robotam, cik ātri griezties.
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 motoru grupu.

Darbības
- spin — Griez motoru grupu uz priekšu vai atpakaļ uz visiem laikiem.
- spin_for — Griež motoru grupu noteiktā attālumā.
- spin_to_position — Pagriež motoru grupu uz noteiktu pozīciju.
- stop — Aptur motoru grupas griešanos.
Mutatori
- set_position — Maina motora grupas pašreizējo pozīciju uz jaunu vērtību.
- set_velocity — Norāda motoru grupai, cik ātri griezties.
- set_timeout — Iestata, cik daudz laika motorā grupa mēģinās pavadīt kustības pabeigšanā.
Geters
- is_done — Atgriež, vai motoru grupa ir pabeigusi kustību, kā Būla vērtību.
- is_spinning — Atgriež, vai motoru grupa griežas, kā Būla vērtību.
- position — Atgriež motora grupas pašreizējo pozīciju.
- velocity — Atgriež motoru grupas griešanās ātrumu.

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

Drukāt
- brain.screen.print — Konsolē parāda tekstu, skaitļus vai mainīgo vērtības.
- brain.screen.next_row — Pārvieto konsoles kursoru uz nākamās rindas sākumu.
- brain.screen.clear_screen — Notīra visas rindas no konsoles.
Monitors
- monitor_variable — Pievieno cilnei Monitor vienu vai vairākus iepriekš definētus mainīgos.
- monitor_sensor — Pievieno vienu vai vairākas sensora vērtības cilnei Monitor.

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

Optiskais
- is_near_object – Atgriež, vai optiskais sensors uztver objektu diapazonā.
- color – Atgriež optiskā sensora noteikto krāsu.
- brightness – Atgriež no objekta atstarotās gaismas daudzumu.
- hue – Atgriež optiskā sensora noteikto nokrāsu.
- object_detected – Reģistrē funkciju, kas jāizsauc, kad optiskais sensors nosaka objektu.
- object_lost – Reģistrē funkciju, kas jāizsauc, kad optiskais sensors pazaudē objektu.
Rotācija
- set_position – Iestata rotācijas sensora pašreizējo pozīciju uz noteiktu vērtību.
- angle – Atgriež sensora pašreizējo leņķi no 0 līdz 359,99 grādiem.
- position – Atgriež kopējo rotācijas pozīciju grādos vai pagriezienos.
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 sensora rādījumiem no 0 līdz 359 grādiem.

Šajā lapā esošajos piemēros tiek izmantota noklusējuma Playground sākuma pozīcija.

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():
    # Drive forward then stop
    drivetrain.drive(FORWARD)
    wait(2, SECONDS)
    drivetrain.stop()

# 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():
    # Drive forward and backward
    drivetrain.drive_for(FORWARD, 200, MM)
    drivetrain.drive_for(REVERSE, 200, MM)

# 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():
    # 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 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. Rotācijas vienī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():
    # 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)

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.

Robota sākuma virziens ir 0 grādi.

Projekts gaidīs, līdz robots būs pabeidzis griešanos, pirms tiks palaista nākamā koda rinda.

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

Parametri	Apraksts
`angle`	Virziens, kurā robotam jābūt pagrieztam, grādos. Tas var būt vesels skaitlis `integer` vai decimālskaitlis (`float`) no -359 līdz 359.
`units`	Neobligāti. Rotācijas vienī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():
    # 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)

pagrieziena_līdz_rotācijai #

turn_to_rotation pagriež robotu noteiktā rotācijā.

Rotācija ir robota pagrieziena lielums, mērīts grādos. Projekta sākumā rotācijas vērtība tiek iestatīta uz 0 grādiem. Rotāciju var iestatīt arī, izmantojot metodi set_rotation.

Rotācijas vērtības ir absolūtas. Tas nozīmē, ka pagrieziena virziens ir atkarīgs no robota pašreizējās rotācijas. Pagriežoties pa labi, rotācija palielinās, bet pagriežoties pa kreisi, tā samazinās.

Piemēram, ja robots sāk darboties no 0 grādiem un jūs pagriežaties par 720 grādiem, tas divreiz pagriezīsies pa labi. Ja pēc tam pagriezīsities par 360 grādiem, tas vienreiz pagriezīsies pa kreisi, jo 360 grādi ir mazāki par 720.

Projekts gaidīs, līdz robots būs pabeidzis griešanos, pirms tiks palaista nākamā koda rinda.

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

Parametri	Apraksts
`angle`	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. Rotācijas vienī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():
    # 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)

apstāties #

stop aptur robota kustību.

Usage:
drivetrain.stop()

Parametri	Apraksts
	Šai metodei nav parametru.

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

# 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 iestatāmā virziena vērtība grādos. Tā var būt vesels skaitlis `integer` vai decimālskaitlis (`float`).
`units`	Neobligāti. Virziena mērvienība: `DEGREES` (pēc noklusējuma).

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 #

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. set_rotation maina robota pašreizējo rotāciju uz jaunu vērtību.

Piemēram, ja robots ir veicis divus pilnus pagriezienus pa labi, tā rotācijas vērtība būs 720 grādi. Iestatot rotāciju uz 0 grādiem, šī rotācija tiks atiestatīta no 720 uz 0 grādiem. Pēc tam robots var veikt rotācijas, pamatojoties uz šo jauno 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. Rotācijas vienība: `DEGREES` (pēc noklusējuma).

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)

iestatīts_laika_izslēgums #

set_timeout nosaka, cik ilgā laikā 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(value, units)

Parametri	Apraksts
`value`	Laiks, kurā robots 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():
    # 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)

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

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

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

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

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.

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.

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

Piemērs

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

Kustība #

Mobijs izmanto dakšas motoru grupu, lai paceltu un nolaistu dakšas, lai varētu transportēt un gūt punktus gredzenus un mobilos vārtus.

Virzienu aprakstos ir paskaidrots, kā katrs virziens pārvieto dakšas motoru grupu uz Moby.

Darbības #

grieziens #

spin griež motoru grupu uz priekšu vai atpakaļ uz visiem laikiem. Motoru grupa turpinās griezties, līdz tai tiks dota cita darbība, piemēram, griezties citā virzienā vai apstāties.

Usage:
fork_motor_group.spin(direction)

Parametri

Apraksts

direction

Motora grupas griešanās virziens:

FORWARD — Paceļ dakšas.
REVERSE — Nolaiž dakšas.

def main():
    # Spin the motor group forward then stop
    fork_motor_group.spin(FORWARD)
    wait(0.5, SECONDS)
    fork_motor_group.stop()

# VR threads — Do not delete
vr_thread(main)

grieziena_priekšmets #

spin_for griež motoru grupu noteiktā attālumā. Griešanās ātrums ir relatīvs attiecībā pret motoru grupas pašreizējo pozīciju. Projekts gaidīs, līdz motoru grupa būs beigusi griešanos, pirms tiks palaista nākamā koda rinda.

Usage:
fork_motor_group.spin_for(direction, distance, units, wait)

Parametri	Apraksts
`direction`	Motora grupas griešanās virziens: `FORWARD` — Paceļ dakšas. `REVERSE` — Nolaiž dakšas.
`distance`	Attālums, kādā griežas motoru grupa. `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 motora grupa ir beigusi griezties, pirms tiek palaista nākamā koda rinda. `wait=False` — Liek nekavējoties palaist nākamo koda rindu.

def main():
    # Spin the motor group forward then stop
    fork_motor_group.spin_for(FORWARD, 360, DEGREES)

# VR threads — Do not delete
vr_thread(main)

griezt_līdz_pozīcijai #

spin_to_position griež motoru grupu uz noteiktu pozīciju.

Motoru grupas pozīcija ir tas, cik tālu tā ir pagriezusies, mērot DEGREES vai TURNSViens pagrieziens ir vienāds ar 360 grādiem. Projekta sākumā motoru grupas pozīcija ir iestatīta uz 0 grādiem. Motoru grupas 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 motoru grupas pašreizējās pozīcijas.

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

Usage:
fork_motor_group.spin_to_position(angle, units, wait)

Parametri	Apraksts
`angle`	Pozīcijas vērtība, līdz kurai motoru grupa 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 motora grupa ir beigusi griezties, pirms tiek palaista nākamā koda rinda. `wait=False` — Liek nekavējoties palaist nākamo koda rindu.

Parametri

Apraksts

angle

Pozīcijas vērtība, līdz kurai motoru grupa 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 motora grupa ir beigusi griezties, pirms tiek palaista nākamā koda rinda.
wait=False — Liek nekavējoties palaist nākamo koda rindu.

def main():
    # Spin the motor group forward then stop
    fork_motor_group.spin_to_position(55, DEGREES)

# VR threads — Do not delete
vr_thread(main)

apstāties #

stop aptur motoru grupas griešanos.

Usage:
fork_motor_group.stop()

Parametri	Apraksts
	Šai metodei nav parametru.

def main():
    # Spin the motor group forward then stop
    fork_motor_group.spin(FORWARD)
    wait(0.5, SECONDS)
    fork_motor_group.stop()

# VR threads — Do not delete
vr_thread(main)

Mutatori #

iestatītā_pozīcija #

Motoru grupas pozīcija norāda, cik tālu tā ir pagriezusies, mērot DEGREES vai TURNSViens pagrieziens ir vienāds ar 360 grādiem. set_position maina motoru grupas pašreizējo pozīciju uz jaunu vērtību.

Piemēram, ja motoru grupa ir pagriezusies 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 motoru grupa var griezties pozīcijās, pamatojoties uz šo jauno vērtību.

Usage:
fork_motor_group.set_position(position, units)

Parametri	Apraksts
`position`	Motora grupai iestatāmā pozīcijas vērtība. `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():
    # Spin the motor group forward then stop
    fork_motor_group.set_position(90, DEGREES)
    fork_motor_group.spin_to_position(0, DEGREES)

# VR threads — Do not delete
vr_thread(main)

iestatīt_ātrumu #

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

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

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

Usage:
fork_motor_group.set_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`	Ātruma mērvienība: `PERCENT`.

def main():
    # Spin the motor group forward then stop
    fork_motor_group.set_velocity(75, PERCENT)
    fork_motor_group.spin_to_position(180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

iestatīts_laika_izslēgums #

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

Usage:
fork_motor_group.set_timeout(value, units)

Parametri	Apraksts
`value`	Laiks, kurā motorā grupa var mēģināt pabeigt kustību. Tas var būt pozitīvs vesels skaitlis `integer` vai decimālskaitlis (`float`).
`units`	Laika mērvienība: `SECONDS` vai `MSEC` (milisekundes).

def main():
    # Spin the motor group forward then stop
    fork_motor_group.set_timeout(2, SECONDS)
    fork_motor_group.spin_to_position(270, DEGREES)

# VR threads — Do not delete
vr_thread(main)

Getteri #

ir_pabeigts #

is_done atgriež, vai motoriskā grupa ir pabeigusi kustību, kā Būla vērtību. To var izmantot, lai kontrolētu citu darbību laiku, pamatojoties uz motoriskās grupas kustību.

True — Motoru grupa ir pabeigusi kustību.
False — Motoru grupa joprojām kustas.

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

Usage:
fork_motor_group.is_done()

Parametri	Apraksts
	Šai metodei nav parametru.

griežas #

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

True — Motoru grupa griežas.
False — Motoru grupa negriežas.

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

Usage:
fork_motor_group.is_spinning()

Parametri	Apraksts
	Šai metodei nav parametru.

pozīcija #

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

Projekta sākumā motoru grupas pozīcija ir iestatīta uz 0 grādiem. Ja motoru grupa griežas vienu pilnu apgriezienu uz priekšu, pozīcija būs 360 grādi jeb 1 apgrieziens. Ja motoru grupa griežas pretējā virzienā, pozīcija būs negatīva.

Usage:
fork_motor_group.position(units)

Parametri	Apraksts
`units`	Vienība, kas atgriež motora grupas pozīciju: `DEGREES` vai `TURNS`.

ātrums #

velocity atgriež motoru grupas griešanās ātrumu.

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

Usage:
fork_motor_group.velocity(units)

Parametri	Apraksts
`units`	Atgriežamā ātruma mērvienība: `PERCENT`.

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ē attēlo tekstu, skaitļus vai mainīgo vērtības, izmantojot pašreizējo kursora pozīciju. Tā darbojas līdzīgi kā print konsoles API lapā.

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)

VEXcode konsole, kurā redzama konsole un teksts "Sveiks, robot!".

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)

VEXcode konsole, kurā pirmajā rindā ir redzams konsole un teksts "1. rinda", bet otrajā rindā — "2. rinda".

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

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_rpm` `drivetrain.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` Dakšas motoru grupa `fork_motor_group.is_done` `fork_motor_group.is_spinning` `fork_motor_group.position_degrees` `fork_motor_group.position_turns` `fork_motor_group.velocity_rpm` `fork_motor_group.velocity_percent` Apakšējā attāluma sensors `bottom_distance.is_object_detected` `bottom_distance.object_distance_mm` `bottom_distance.object_distance_inches` Kreisais attāluma sensors `left_distance.is_object_detected` `left_distance.object_distance_mm` `left_distance.object_distance_inches` Centra attāluma sensors `center_distance.is_object_detected` `center_distance.object_distance_mm` `center_distance.object_distance_inches` Labais attāluma sensors `right_distance.is_object_detected` `right_distance.object_distance_mm` `right_distance.object_distance_inches` Līniju izsekotāji `bottom_line_tracker.reflectivity` `middle_line_tracker.reflectivity` `top_line_tracker.reflectivity` Rullīšu optiskais sensors `roller_optical.is_near_object` `roller_optical.color` `roller_optical.brightness` `roller_optical.hue` Optiskais sensors `optical.is_near_object` `optical.color` `optical.brightness` `optical.hue` GPS sensors `gps.position_mm` `gps.position_inches` `gps.heading` Rotācijas sensors `rotation.angle` `rotation.position`

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_rpm
- drivetrain.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
Dakšas motoru grupa
- fork_motor_group.is_done
- fork_motor_group.is_spinning
- fork_motor_group.position_degrees
- fork_motor_group.position_turns
- fork_motor_group.velocity_rpm
- fork_motor_group.velocity_percent
Apakšējā attāluma sensors
- bottom_distance.is_object_detected
- bottom_distance.object_distance_mm
- bottom_distance.object_distance_inches
Kreisais attāluma sensors
- left_distance.is_object_detected
- left_distance.object_distance_mm
- left_distance.object_distance_inches
Centra attāluma sensors
- center_distance.is_object_detected
- center_distance.object_distance_mm
- center_distance.object_distance_inches
Labais attāluma sensors
- right_distance.is_object_detected
- right_distance.object_distance_mm
- right_distance.object_distance_inches
Līniju izsekotāji
- bottom_line_tracker.reflectivity
- middle_line_tracker.reflectivity
- top_line_tracker.reflectivity
Rullīšu optiskais sensors
- roller_optical.is_near_object
- roller_optical.color
- roller_optical.brightness
- roller_optical.hue
Optiskais sensors
- optical.is_near_object
- optical.color
- optical.brightness
- optical.hue
GPS sensors
- gps.position_mm
- gps.position_inches
- gps.heading
Rotācijas sensors
- rotation.angle
- rotation.position

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 #

Optisks #

ir_objekta_tuvumā #

is_near_object atgriež Būla vērtību, kas norāda, vai optiskais sensors uztver objektu diapazonā.

True — optiskais sensors nosaka objektu.
False – Optiskais sensors neuztver objektu.

Usage:
optical.is_near_object()

Parametri	Apraksts
	Šai metodei nav parametru.

krāsa #

color atgriež Color klases instanci, pamatojoties uz noteikto nokrāsas vērtību. Tos var salīdzināt ar iepriekš definētiem Color objektiem, lai izveidotu nosacījuma paziņojumus.

Iespējamās krāsas ir:

NONE
RED — nokrāsas vērtība no 340° līdz 20°
GREEN — nokrāsas vērtība no 80° līdz 140°
BLUE — nokrāsas vērtība no 200° līdz 240°
YELLOW — Nokrāsas vērtība no 40° līdz 60°
ORANGE — Nokrāsas vērtība no 20° līdz 40°
PURPLE — nokrāsas vērtība no 240° līdz 280°
CYAN — nokrāsas vērtība no 140° līdz 200°

Piezīme: Optiskais sensors meklē nokrāsu diapazonus, kas atbilst norādītajai krāsai. Lai noteiktu konkrētu nokrāsu diapazonus, skatiet hue.

Usage:
optical.color()

Parametri	Apraksts
	Šai metodei nav parametru.

spilgtums #

brightness atgriež no objekta atstarotās gaismas daudzumu decimālskaitļa veidā (float), kas apzīmē procentus.

Augstāks procentuālais daudzums nozīmē, ka uz optisko sensoru tiek atstarots vairāk gaismas. Zemāks procentuālais daudzums nozīmē, ka uz optisko sensoru tiek atstarots mazāk gaismas.

Usage:
optical.brightness()

Parametri	Apraksts
	Šai metodei nav parametru.

nokrāsa #

hue atgriež noteiktās krāsas nokrāsas vērtību decimālskaitļa veidā (float) no 0 līdz 359.

Nokrāsa ir veids, kā aprakstīt krāsu, izmantojot skaitļus ap krāsu apli.

Apļveida krāsu aplis, kas attēlo pilnu toņu spektru, kas apzīmēts ar grādu vērtībām pa perimetru, palielinoties ar 30 grādu soli no 0° augšpusē līdz 360°.

Usage:
optical.hue()

Parametri	Apraksts
	Šai metodei nav parametru.

objekts_atklāts #

object_detected reģistrē funkciju, kas tiks izsaukta ikreiz, kad optiskais sensors atrod jaunu objektu.

Usage:
optical.object_detected(callback, arg)

Parametri	Apraksts
`callback`	Iepriekš definēta funkcija, kas tiek izpildīta, kad optiskais sensors nosaka jaunu objektu.
`arg`	Neobligāti. Tuple, kas satur argumentus, kas jānodod atzvanīšanas funkcijai. Plašāku informāciju skatiet sadaļā Funkciju izmantošana ar parametriem.

objekts_pazaudēts #

object_lost reģistrē funkciju, kas tiks izsaukta ikreiz, kad optiskais sensors pazaudē noteiktu objektu.

Usage:
optical.object_lost(callback, arg)

Parametri	Apraksts
`callback`	Iepriekš definēta funkcija, kas tiek izpildīta, kad optiskais sensors pazaudē noteiktu objektu.
`arg`	Neobligāti. Tuple, kas satur argumentus, kas jānodod atzvanīšanas funkcijai. Plašāku informāciju skatiet sadaļā Funkciju izmantošana ar parametriem.

Rotācija #

iestatītā_pozīcija #

set_position iestata rotācijas sensora pašreizējo pozīciju uz vērtību grādos.

Usage:
rotation.set_position(position, units)

Parametri	Apraksts
pozīcija	Pozīcija, kurā jāiestata rotācijas sensors.
vienības	Pēc izvēles. Pozīcijas mērvienība:`DEGREES` (pēc noklusējuma) vai `TURNS`

leņķis #

angle atgriež sensora pašreizējo leņķi kā peldošo skaitli.

Usage:
rotation.angle(units)

Parametri	Apraksts
vienības	Pēc izvēles. Leņķa mērvienība: `DEGREES` (pēc noklusējuma) – no 0 līdz 359,99 `TURNS`

Parametri

Apraksts

vienības

Pēc izvēles. Leņķa mērvienība:

DEGREES (pēc noklusējuma) – no 0 līdz 359,99
TURNS

pozīcija #

position atgriež kopējo rotācijas pozīciju.

Usage:
rotation.position(units)

Parametri	Apraksts
vienības	Pēc izvēles. Pozīcijas mērvienība: `DEGREES` (pēc noklusējuma) – no 0 līdz 359 kā vesels skaitlis `TURNS` – Kā peldošs skaitlis

Parametri

Apraksts

vienības

Pēc izvēles. Pozīcijas mērvienība:

DEGREES (pēc noklusējuma) – no 0 līdz 359 kā vesels skaitlis
TURNS – Kā peldošs skaitlis

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`

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`

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.