Robotiem specifisks Python#

Ievads #

Varoņa robotam Swish ir viena motora opcija, viena motoru grupas opcija un optiskais sensors.

Visas standarta VEXcode VR metodes ir pieejamas lietošanai IQ 24-25 Rapid Relay 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 un motoru grupu.

Darbības
- spin — Griež motoru vai motoru grupu uz priekšu vai atpakaļ uz visiem laikiem.
- spin_for — Griež motoru vai motoru grupu noteiktā attālumā.
- spin_to_position — Pagriež motoru vai motoru grupu uz noteiktu pozīciju.
- stop — Aptur motora vai motoru grupas griešanos.
Mutatori
- set_position — Maina motora vai motoru grupas pašreizējo pozīciju uz jaunu vērtību.
- set_velocity — Norāda motoram vai motoru grupai, cik ātri griezties.
- set_timeout — Iestata, cik daudz laika motors vai motoru grupa mēģinās pabeigt kustību.
Geters
- is_done — Atgriež, vai motora vai motoru grupas kustība ir pabeigta, kā Būla vērtību.
- is_spinning — Atgriež, vai griežas motors vai motoru grupa, kā Būla vērtību.
- position — Atgriež motora vai motoru grupas pašreizējo pozīciju.
- velocity — Atgriež motora vai 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.

Š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`	Attāluma mērvienība: `INCHES` 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`	Rotācijas vienība: `DEGREES`.
`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`	Rotācijas vienība: `DEGREES`.
`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`	Rotācijas vienība: `DEGREES`.
`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`	Virziena mērvienība: `DEGREES`.

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`	Rotācijas vienība: `DEGREES`.

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

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

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`	Virziena mērvienība: `DEGREES`.

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`	Rotācijas vienība: `DEGREES`.

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

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 #

Swish izmanto ieplūdes motoru, lai savāktu bumbiņas un pārvietotu tās uz katapultu. Katapultas motoru grupa nolaiž un atbrīvo katapultas roku, lai palaistu bumbiņas.

Katram motoram un motoru grupai ir sava virziena uzvedība. Virzienu aprakstos ir paskaidrots, kā katrs virziens pārvieto šo motoru vai motoru grupu programmā Swish.

Darbības #

grieziens #

spin griež motoru vai motoru grupu uz priekšu vai atpakaļ uz visiem laikiem. Motors vai motoru grupa 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 vai motora grupas objektiem, kā parādīts tālāk:

motors	Komanda
`intake_motor`	`intake_motor.spin(direction)` — Ieplūdes motors
`catapult_group`	`catapult_group.spin(direction)` — Katapultu grupa

Parametri

Apraksts

direction

Motora vai motoru grupas griešanās virziens:

FORWARD — Griež ieplūdes motoru ieplūdes virzienā vai nolaiž katapultu grupu.
REVERSE — Griež ieplūdes motoru izplūdes virzienā vai atbrīvo katapultu grupu.

def main():
    # Spin the Intake Motor to bring a Ball onto the Catapult
    intake_motor.spin(FORWARD)
    wait(2, SECONDS)
    intake_motor.stop()

# VR threads — Do not delete
vr_thread(main)

grieziena_priekšmets #

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

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

motors	Komanda
`intake_motor`	`intake_motor.spin_for(direction, distance, units, wait=True)` — Ieplūdes motors
`catapult_group`	`catapult_group.spin_for(direction, distance, units, wait=True)` — Katapultu grupa

Parametri	Apraksts
`direction`	Motora vai motoru grupas griešanās virziens: `FORWARD` — Griež ieplūdes motoru ieplūdes virzienā vai nolaiž katapultu grupu. `REVERSE` — Griež ieplūdes motoru izplūdes virzienā vai atbrīvo katapultu grupu.
`distance`	Attālums, kādā griežas motors vai 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 motors vai motoru grupa ir beigusi griezties, pirms tiek palaista nākamā koda rinda. `wait=False` — Liek nekavējoties palaist nākamo koda rindu.

def main():
    # Release the preloaded Ball
    catapult_group.spin_for(REVERSE, 5, DEGREES)
    # Lower the Catapult to prepare to load another Ball
    catapult_group.spin_for(FORWARD, 1350, DEGREES)

# VR threads — Do not delete
vr_thread(main)

griezt_līdz_pozīcijai #

spin_to_position griež motoru vai motoru grupu uz noteiktu pozīciju.

Motora vai motoru grupas 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 vai motoru grupas pozīcija ir iestatīta uz 0 grādiem. Motora vai 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 motora vai motoru grupas pašreizējās pozīcijas.

Piemēram, ja motors vai motoru grupa sāk griezties 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 grādiem.

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

motors	Komanda
`intake_motor`	`intake_motor.spin_to_position(angle, units, wait=True)` — Ieplūdes motors
`catapult_group`	`catapult_group.spin_to_position(angle, units, wait=True)` — Katapultu grupa

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

def main():
    # Release the preloaded Ball
    catapult_group.spin_to_position(-90, DEGREES)
    # Lower the Catapult to prepare to load another Ball
    catapult_group.spin_to_position(1260, DEGREES)

# VR threads — Do not delete
vr_thread(main)

apturēt motoru #

stop aptur motora vai motoru grupas griešanos.

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

motors	Komanda
`intake_motor`	`intake_motor.stop()` — Ieplūdes motors
`catapult_group`	`catapult_group.stop()` — Katapultu grupa

Parametri	Apraksts
	Šai metodei nav parametru.

def main():
    # Spin the Intake Motor to bring a Ball onto the Catapult
    intake_motor.spin(FORWARD)
    wait(2, SECONDS)
    intake_motor.stop()

# VR threads — Do not delete
vr_thread(main)

Mutatori #

iestatītā_pozīcija #

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

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

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

motors	Komanda
`intake_motor`	`intake_motor.set_position(position, units)` — Ieplūdes motors
`catapult_group`	`catapult_group.set_position(position, units)` — Katapultu grupa

Parametri	Apraksts
`position`	Pozīcijas vērtība, kas jāiestata motoram vai motoru grupai. `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():
    # Lower the Catapult to prepare to load another Ball
    catapult_group.spin_to_position(1260, DEGREES)
    # Set the new Catapult position to be 0 degrees
    catapult_group.set_position(0, DEGREES)

# VR threads — Do not delete
vr_thread(main)

iestatīt_ātrumu #

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

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

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

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

motors	Komanda
`intake_motor`	`intake_motor.set_velocity(velocity, units)` — Ieplūdes motors
`catapult_group`	`catapult_group.set_velocity(velocity, units)` — Katapultu grupa

Parametri	Apraksts
`velocity`	Griešanās ātrums no -100% līdz 100%. Tas var būt vesels skaitlis `integer` vai decimālskaitlis (`float`).
`units`	Ātruma mērvienība: `PERCENT`.

def main():
    # Start spinning the Intake Motor to prepare for picking up a Ball
    intake_motor.set_velocity(100, PERCENT)
    intake_motor.spin(FORWARD)

# VR threads — Do not delete
vr_thread(main)

iestatīts_laika_izslēgums #

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

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

motors	Komanda
`intake_motor`	`intake_motor.set_timeout(value, units)` — Ieplūdes motors
`catapult_group`	`catapult_group.set_timeout(value, units)` — Katapultu grupa

Parametri	Apraksts
`value`	Laiks, kurā motors vai motoru 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():
    # Limit how long the Catapult waits to reach its target
    catapult_group.set_timeout(2, SECONDS)
    catapult_group.spin_for(FORWARD, 2160, DEGREES)

# VR threads — Do not delete
vr_thread(main)

Getteri #

ir_pabeigts #

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

True — Motors vai motoru grupa ir pabeigusi kustību.
False — Motors vai 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.

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

motors	Komanda
`intake_motor`	`intake_motor.is_done()` — Ieplūdes motors
`catapult_group`	`catapult_group.is_done()` — Katapultu grupa

Parametri	Apraksts
	Šai metodei nav parametru.

griežas #

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

True — Motors vai motoru grupa griežas.
False — Motors vai 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.

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

motors	Komanda
`intake_motor`	`intake_motor.is_spinning()` — Ieplūdes motors
`catapult_group`	`catapult_group.is_spinning()` — Katapultu grupa

Parametri	Apraksts
	Šai metodei nav parametru.

pozīcija #

Motora vai motoru grupas 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 vai motoru grupas pašreizējo pozīciju.

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

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

motors	Komanda
`intake_motor`	`intake_motor.position(units)` — Ieplūdes motors
`catapult_group`	`catapult_group.position(units)` — Katapultu grupa

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

def main():
    # Lower the Catapult to prepare to load another Ball
    while not catapult_group.position(DEGREES) == 1260:
        catapult_group.spin(FORWARD)

# VR threads — Do not delete
vr_thread(main)

ātrums #

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

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

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

motors	Komanda
`intake_motor`	`intake_motor.velocity(units)` — Ieplūdes motors
`catapult_group`	`catapult_group.velocity(units)` — Katapultu grupa

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

def main():
    # Print the current Catapult velocity
    brain.screen.print(catapult_group.velocity(PERCENT))

# 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ē 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` Arm Motor `arm_motor.is_done` `arm_motor.is_spinning` `arm_motor.position_degrees` `arm_motor.position_turns` `arm_motor.velocity_rpm` `arm_motor.velocity_percent` Rokas motoru grupa `arm_motor_group.is_done` `arm_motor_group.is_spinning` `arm_motor_group.position_degrees` `arm_motor_group.position_turns` `arm_motor_group.velocity_rpm` `arm_motor_group.velocity_percent` Ieplūdes motors `intake_motor.is_done` `intake_motor.is_spinning` `intake_motor.position_degrees` `intake_motor.position_turns` `intake_motor.velocity_rpm` `intake_motor.velocity_percent` Ieplūdes motoru grupa `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` Katapultas motors `catapult_motor.is_done` `catapult_motor.is_spinning` `catapult_motor.position_degrees` `catapult_motor.position_turns` `catapult_motor.velocity_rpm` `catapult_motor.velocity_percent` Katapultas spriegošanas motors `catapult_tension_motor.is_done` `catapult_tension_motor.is_spinning` `catapult_tension_motor.position_degrees` `catapult_tension_motor.position_turns` `catapult_tension_motor.velocity_rpm` `catapult_tension_motor.velocity_percent` Bamperi `intake_bumper.pressing` `bumper.pressing` 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` Krāsu sensors `color.is_near_object` `color.color` `color.brightness` `color.hue`

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
Arm Motor
- arm_motor.is_done
- arm_motor.is_spinning
- arm_motor.position_degrees
- arm_motor.position_turns
- arm_motor.velocity_rpm
- arm_motor.velocity_percent
Rokas motoru grupa
- arm_motor_group.is_done
- arm_motor_group.is_spinning
- arm_motor_group.position_degrees
- arm_motor_group.position_turns
- arm_motor_group.velocity_rpm
- arm_motor_group.velocity_percent
Ieplūdes motors
- intake_motor.is_done
- intake_motor.is_spinning
- intake_motor.position_degrees
- intake_motor.position_turns
- intake_motor.velocity_rpm
- intake_motor.velocity_percent
Ieplūdes motoru grupa
- 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
Katapultas motors
- catapult_motor.is_done
- catapult_motor.is_spinning
- catapult_motor.position_degrees
- catapult_motor.position_turns
- catapult_motor.velocity_rpm
- catapult_motor.velocity_percent
Katapultas spriegošanas motors
- catapult_tension_motor.is_done
- catapult_tension_motor.is_spinning
- catapult_tension_motor.position_degrees
- catapult_tension_motor.position_turns
- catapult_tension_motor.velocity_rpm
- catapult_tension_motor.velocity_percent
Bamperi
- intake_bumper.pressing
- bumper.pressing
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
Krāsu sensors
- color.is_near_object
- color.color
- color.brightness
- color.hue

def main():
    # Monitor the robot's heading
    monitor_sensor("drivetrain.heading")
    drivetrain.turn_for(RIGHT, 450, DEGREES)

# VR threads — Do not delete
vr_thread(main)

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

Parametri	Apraksts
	Šai metodei nav parametru.

def main():
    # Launch a loaded Ball once the Intake Optical Sensor detects a Ball
    if intake_optical.is_near_object():
        catapult_group.spin_for(REVERSE, 5, DEGREES)

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

Parametri	Apraksts
	Šai metodei nav parametru.

def main():
    # Launch a loaded Ball once yellow is detected in the Intake
    if intake_optical.color() == YELLOW:
        catapult_group.spin_for(REVERSE, 5, DEGREES)

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

Parametri	Apraksts
	Šai metodei nav parametru.

def main():
    # Launch a loaded Ball once the Intake Optical Sensor sees a Ball
    if intake_optical.brightness() > 0:
        catapult_group.spin_for(REVERSE, 5, DEGREES)

# VR threads — Do not delete
vr_thread(main)

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 ik pēc 30 grādiem no 0 grādiem augšpusē līdz 360 grādiem.

Usage:
intake_optical.hue()

Parametri	Apraksts
	Šai metodei nav parametru.

def main():
    # Launch a loaded Ball once the Intake Optical Sensor reports a hue value
    if intake_optical.hue() > 100:
        catapult_group.spin_for(REVERSE, 5, DEGREES)

# 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:
intake_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.

def launch_ball():
    catapult_group.spin_for(REVERSE, 5, DEGREES)

def main():
    # Launch the Ball when the Intake Optical Sensor detects an object
    intake_optical.object_detected(launch_ball)

# VR threads — Do not delete
vr_thread(main)

objekts_pazaudēts #

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

Usage:
intake_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.

def lower_catapult():
    catapult_group.spin_to_position(1260, DEGREES)

def main():
    # Lower the Catapult when the Intake Optical Sensor no longer detects an object
    intake_optical.object_lost(lower_catapult)

# VR threads — Do not delete
vr_thread(main)