Robotiem specifisks Python#

Ievads #

Varoņa robotam Akselam ir divas motora iespējas: mākslīgā intelekta redzes sensors, optiskais sensors, rotācijas sensors un spēles pozicionēšanas sistēmas (GPS) sensors.

Visas standarta VEXcode VR metodes ir pieejamas lietošanai V5 24-25 High Stakes 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 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 – Noteiktā objekta augstums pikseļos.
- centerX – objekta centra X pozīcija pikseļos.
- 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 – Objekta klasifikācijas vai birkas ID.

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 pabeidzis pagriešanos, 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 beidzis kustību, 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 #

Aksels izmanto rokas motoru, lai paceltu un nolaistu roku, lai gredzenus varētu novietot mietiņu tuvumā. Stūmēja motors pārvieto stūmēju uz leju pa roku, lai izstumtu gredzenus no rokas un uzliktu tos uz mietiņa.

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

Darbības #

grieziens #

spin griež motoru uz priekšu vai atpakaļ bezgalīgi. Motors turpinās griezties, līdz tam tiks dota cita darbība, piemēram, griešanās citā virzienā vai apstāšanā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.spin(direction)` — Rokas motors
`pusher_motor`	`pusher_motor.spin(direction)` — Stūmēja motors

Parametri

Apraksts

direction

Motora griešanās virziens:

FORWARD — Pagriež sviru uz augšu vai pārvieto stūmēju uz leju pa sviru.
REVERSE — Pagriež sviru uz leju vai pārvieto stūmēju uz augšu pa sviru.

def main():
    # Lift the Arm up before moving
    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
`pusher_motor`	`pusher_motor.spin_for(direction, distance, units, wait)` — Stūmēja motors

Parametri	Apraksts
`direction`	Motora griešanās virziens: `FORWARD` — Pagriež sviru uz augšu vai pārvieto stūmēju uz leju pa sviru. `REVERSE` — Pagriež sviru uz leju vai pārvieto stūmēju uz augšu pa sviru.
`distance`	Attālums, kādā griežas motors. `DEGREES` izmanto veselus skaitļus. `TURNS` var izmantot veselus skaitļus vai decimālskaitļus.
`units`	Pēc izvēles. 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():
    # Lift the Arm up before moving
    arm_motor.spin_for(FORWARD, 400, 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 ir tas, cik tālu tas ir pagriezies, mērot DEGREES vai TURNSViens pagrieziens ir vienāds ar 360 grādiem. Projekta sākumā motora pozīcija ir iestatīta uz 0 grādiem. 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
`pusher_motor`	`pusher_motor.spin_to_position(angle, units, wait=True)` — Stūmēja 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.

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():
    # Lift the Arm up before moving
    arm_motor.spin_to_position(400, 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
`pusher_motor`	`pusher_motor.stop()` — Stūmēja motors

Parametri	Apraksts
	Šai metodei nav parametru.

def main():
    # Lift the Arm up before moving
    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
`pusher_motor`	`pusher_motor.set_position(position, units)` — Stūmēja 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():
    # Make the raised Arm as the new 0 degrees position
    arm_motor.spin_to_position(400, DEGREES)
    arm_motor.set_position(0, 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
`pusher_motor`	`pusher_motor.set_velocity(velocity, units)` — Stūmēja 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():
    # Lift the Arm up before moving
    arm_motor.set_velocity(100, PERCENT)
    arm_motor.spin_to_position(400, 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
`pusher_motor`	`pusher_motor.set_timeout(value, units)` — Stūmēja motors

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():
    # Lift the Arm up before moving
    arm_motor.set_timeout(1, SECONDS)
    arm_motor.spin_for(FORWARD, 1080, 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
`pusher_motor`	`pusher_motor.is_done()` — Stūmēja motors

Parametri	Apraksts
	Šai metodei nav parametru.

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
`pusher_motor`	`pusher_motor.is_spinning()` — Stūmēja motors

Parametri	Apraksts
	Šai metodei nav parametru.

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ā motora pozīcija ir iestatīta uz 0 grādiem. Ja motors griežas vienu pilnu apgriezienu uz priekšu, pozīcija būs 360 grādi jeb 1 apgrieziens. Ja motors griežas pretējā virzienā, pozīcija būs negatīva.

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
`pusher_motor`	`pusher_motor.position(units)` — Stūmēja motors

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

ā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
`pusher_motor`	`pusher_motor.velocity(units)` — Stūmēja motors

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

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 mobilos mērķus, sarkanos gredzenus un zilos gredzenus.

Parametri

Apraksts

signature

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

AiVision.ALL_AIOBJS — nosaka mobilos mērķus, sarkanos gredzenus un zilos gredzenus.

def main():
    # Lift the Arm to not block the AI Vision Sensor's field of view
    arm_motor.spin_for(FORWARD, 350, DEGREES)
    while True:
        brain.screen.clear_screen()

        # Display the data of the largest detected Game Element
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)

        if len(ai_objects) is not 0:
            brain.screen.print("Center X: ", ai_objects[0].centerX)
            brain.screen.next_row()

            brain.screen.print("Center Y: ", ai_objects[0].centerY)
            brain.screen.next_row()

        else:
            brain.screen.print("No object detected.")

        wait(0.2, SECONDS)

# 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():
    # Lift the Arm to not block the AI Vision Sensor's view
    arm_motor.spin_for(FORWARD, 350, DEGREES)

    # Display the width of the largest Game Element
    ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)

    if len(ai_objects) is not 0:
        brain.screen.print(ai_objects[0].width)

# 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():
    # Lift the Arm to not block the AI Vision Sensor's view
    arm_motor.spin_for(FORWARD, 350, DEGREES)

    # Display the height of the largest Game Element
    ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)

    if len(ai_objects) is not 0:
        brain.screen.print(ai_objects[0].height)

# 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():
    # Lift the Arm to not block the AI Vision Sensor's view
    arm_motor.spin_for(FORWARD, 350, DEGREES)

    # Display the centerX of the largest Game Element
    ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)

    if len(ai_objects) is not 0:
        brain.screen.print(ai_objects[0].centerX)

# 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():
    # Lift the Arm to not block the AI Vision Sensor's view
    arm_motor.spin_for(FORWARD, 350, DEGREES)

    # Display the centerY of the largest Game Element
    ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)

    if len(ai_objects) is not 0:
        brain.screen.print(ai_objects[0].centerY)

# 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():
    # Lift the Arm to not block the AI Vision Sensor's view
    arm_motor.spin_for(FORWARD, 350, DEGREES)

    # Display the originX of the largest Game Element
    ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)

    if len(ai_objects) is not 0:
        brain.screen.print(ai_objects[0].originX)

# 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():
    # Lift the Arm to not block the AI Vision Sensor's view
    arm_motor.spin_for(FORWARD, 350, DEGREES)

    # Display the originY of the largest Game Element
    ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)

    if len(ai_objects) is not 0:
        brain.screen.print(ai_objects[0].originY)

# 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
MobileGoal	0	`GameElements.MOBILE_GOAL`
RedRing	1	`GameElements.RED_RING`
BlueRing	2	`GameElements.BLUE_RING`

def main():
    # Lift the Arm to not block the AI Vision Sensor's view
    arm_motor.spin_for(FORWARD, 350, DEGREES)

    # Display if a Mobile Goal is detected
    ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)

    if len(ai_objects) is not 0:

        if ai_objects[0].id == GameElements.MOBILE_GOAL:
            brain.screen.print("This is a Mobile Goal.")
        else:
            brain.screen.print("This is not a Mobile Goal.")

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

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` Pusher Motor `pusher_motor.is_done` `pusher_motor.is_spinning` `pusher_motor.position` `pusher_motor.velocity` Rokas Motor `arm_motor.is_done` `arm_motor.is_spinning` `arm_motor.position` `arm_motor.velocity` Priekšējais attāluma sensors `front_distance.is_object_detected` `front_distance.object_distance_mm` `front_distance.object_distance_inches` Priekšējais optiskais sensors `front_optical.is_near_object` `front_optical.color` `front_optical.brightness` `front_optical.hue` GPS sensors `gps.position_mm` `gps.position_inches` `gps.heading` Stūmēja rotācijas sensors `pusher_rotation.angle` `pusher_rotation.position` 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`

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
Pusher Motor
- pusher_motor.is_done
- pusher_motor.is_spinning
- pusher_motor.position
- pusher_motor.velocity
Rokas Motor
- arm_motor.is_done
- arm_motor.is_spinning
- arm_motor.position
- arm_motor.velocity
Priekšējais attāluma sensors
- front_distance.is_object_detected
- front_distance.object_distance_mm
- front_distance.object_distance_inches
Priekšējais optiskais sensors
- front_optical.is_near_object
- front_optical.color
- front_optical.brightness
- front_optical.hue
GPS sensors
- gps.position_mm
- gps.position_inches
- gps.heading
Stūmēja rotācijas sensors
- pusher_rotation.angle
- pusher_rotation.position
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 #

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:
front_optical.is_near_object()

Parametri	Apraksts
	Šai metodei nav parametru.

def main():
    # Display if the Optical Sensor is detecting an object
    brain.screen.print(front_optical.is_near_object())

# VR threads — Do not delete
vr_thread(main)

krāsa #

color atgriež Color klases instanci, pamatojoties uz noteikto nokrāsas vērtību. Tās 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:
front_optical.color()

Parametri	Apraksts
	Šai metodei nav parametru.

def main():
    # Display the color of the ring on the Arm
    brain.screen.print(front_optical.color())

# VR threads — Do not delete
vr_thread(main)

spilgtums #

brightness atgriež no objekta atstarotās gaismas daudzumu decimāldaļā (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:
front_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:
front_optical.hue()

Parametri	Apraksts
	Šai metodei nav parametru.

def main():
    # Display the hue of the ring on the Arm.
    brain.screen.print("Hue: ", optical.hue())

# VR threads — Do not delete
vr_thread(main)

objekts_atklāts #

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

Usage:
front_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:
front_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:
pusher_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:
pusher_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

pozīcija #

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

Usage:
pusher_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šais 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.