Robotiem specifisks Python#

Ievads #

Varoņa robotam Fling ir trīs motora iespējas un krāsu sensors.

Visas standarta VEXcode VR metodes ir pieejamas lietošanai IQ 21-22 Pitching In 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.

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.

Krāsa
- color — Atgriež krāsu, ko noteicis krāsu sensors.
- brightness — Atgriež no objekta atstarotās gaismas daudzumu.
- hue — Atgriež krāsu sensora noteikto nokrāsu.
- is_near_object — Atgriež, vai krāsu sensors uztver objektu diapazonā.

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

Fling izmanto ieplūdes motoru, lai ievilktu vai izmestu bumbiņas. Katapultas un katapultas rokas spriegošanas motori palaiž bumbiņas, un spriegums maina bumbiņu lidojuma attālumu.

Katram motoram ir sava virziena uzvedība. Virzienu apraksti paskaidro, kā katrs virziens pārvieto motoru Fling režīmā.

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 trim pieejamajiem motora objektiem, kā parādīts tālāk:

motors	Komanda
`intake_motor`	`intake_motor.spin(direction)` — Ieplūdes motors
`catapult_motor`	`catapult_motor.spin(direction)` — Katapultas motors
`catapult_tension_motor`	`catapult_tension_motor.spin(direction)` — Katapultas spriegošanas motors

Parametri	Apraksts
`direction`	Motora griešanās virziens ir atkarīgs no izvēlētā motora: `FORWARD` — Griež ieplūdes motoru ieplūdes virzienā vai pārvieto izvēlēto katapultas motoru uz priekšu. `REVERSE` — Griež ieplūdes motoru izplūdes virzienā vai pārvieto izvēlēto katapultas motoru atpakaļgaitā.

Parametri

Apraksts

direction

Motora griešanās virziens ir atkarīgs no izvēlētā motora:

FORWARD — Griež ieplūdes motoru ieplūdes virzienā vai pārvieto izvēlēto katapultas motoru uz priekšu.
REVERSE — Griež ieplūdes motoru izplūdes virzienā vai pārvieto izvēlēto katapultas motoru atpakaļgaitā.

def main():
    # Spin the Intake Motor to collect a Ball
    intake_motor.spin(FORWARD)
    wait(1, SECONDS)
    intake_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 trim pieejamajiem motora 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_motor`	`catapult_motor.spin_for(direction, distance, units, wait=True)` — Katapultas motors
`catapult_tension_motor`	`catapult_tension_motor.spin_for(direction, distance, units, wait=True)` — Katapultas spriegošanas motors

Parametri	Apraksts
`direction`	Motora griešanās virziens ir atkarīgs no izvēlētā motora: `FORWARD` vai `REVERSE`.
`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():
    # Collect a Ball with the Intake Motor
    intake_motor.spin_for(FORWARD, 360, 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 trim pieejamajiem motora 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_motor`	`catapult_motor.spin_to_position(angle, units, wait=True)` — Katapultas motors
`catapult_tension_motor`	`catapult_tension_motor.spin_to_position(angle, units, wait=True)` — Katapultas spriegošanas 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():
    # Move the Catapult Motor to a launch position
    catapult_motor.spin_to_position(2600, DEGREES)

# VR threads — Do not delete
vr_thread(main)

apturēt motoru #

stop aptur motora griešanos.

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

motors	Komanda
`intake_motor`	`intake_motor.stop()` — Ieplūdes motors
`catapult_motor`	`catapult_motor.stop()` — Katapultas motors
`catapult_tension_motor`	`catapult_tension_motor.stop()` — Katapultas spriegošanas motors

Parametri	Apraksts
	Šai metodei nav parametru.

def main():
    # Spin the Intake Motor, then stop it
    intake_motor.spin(FORWARD)
    wait(1, SECONDS)
    intake_motor.stop()

# VR threads — Do not delete
vr_thread(main)

Mutatori #

iestatītā_pozīcija #

Motora pozīcija ir tas, cik tālu tas ir pagriezies, mērot DEGREES vai TURNSViens pagrieziens 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 trim pieejamajiem motora objektiem, kā parādīts tālāk:

motors	Komanda
`intake_motor`	`intake_motor.set_position(position, units)` — Ieplūdes motors
`catapult_motor`	`catapult_motor.set_position(position, units)` — Katapultas motors
`catapult_tension_motor`	`catapult_tension_motor.set_position(position, units)` — Katapultas spriegošanas 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():
    # Set the Catapult Motor position, then return it to 0 degrees
    catapult_motor.set_position(2600, DEGREES)
    catapult_motor.spin_to_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 trim pieejamajiem motora objektiem, kā parādīts tālāk:

motors	Komanda
`intake_motor`	`intake_motor.set_velocity(velocity, units)` — Ieplūdes motors
`catapult_motor`	`catapult_motor.set_velocity(velocity, units)` — Katapultas motors
`catapult_tension_motor`	`catapult_tension_motor.set_velocity(velocity, units)` — Katapultas spriegošanas motors

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():
    # Set the Catapult Motor velocity before moving it
    catapult_motor.set_velocity(75, PERCENT)
    catapult_motor.spin_to_position(2600, 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 trim pieejamajiem motora objektiem, kā parādīts tālāk:

motors	Komanda
`intake_motor`	`intake_motor.set_timeout(value, units)` — Ieplūdes motors
`catapult_motor`	`catapult_motor.set_timeout(value, units)` — Katapultas motors
`catapult_tension_motor`	`catapult_tension_motor.set_timeout(value, units)` — Katapultas spriegošanas 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():
    # Limit how long the Catapult Motor waits to reach its target
    catapult_motor.set_timeout(2, SECONDS)
    catapult_motor.spin_to_position(5000, 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 trim pieejamajiem motora objektiem, kā parādīts tālāk:

motors	Komanda
`intake_motor`	`intake_motor.is_done()` — Ieplūdes motors
`catapult_motor`	`catapult_motor.is_done()` — Katapultas motors
`catapult_tension_motor`	`catapult_tension_motor.is_done()` — Katapultas spriegošanas 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 trim pieejamajiem motora objektiem, kā parādīts tālāk:

motors	Komanda
`intake_motor`	`intake_motor.is_spinning()` — Ieplūdes motors
`catapult_motor`	`catapult_motor.is_spinning()` — Katapultas motors
`catapult_tension_motor`	`catapult_tension_motor.is_spinning()` — Katapultas spriegošanas 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 trim pieejamajiem motora objektiem, kā parādīts tālāk:

motors	Komanda
`intake_motor`	`intake_motor.position(units)` — Ieplūdes motors
`catapult_motor`	`catapult_motor.position(units)` — Katapultas motors
`catapult_tension_motor`	`catapult_tension_motor.position(units)` — Katapultas spriegošanas motors

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

def main():
    # Print the current Catapult Motor position
    brain.screen.print(catapult_motor.position(DEGREES))

# VR threads — Do not delete
vr_thread(main)

ātrums #

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

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

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

motors	Komanda
`intake_motor`	`intake_motor.velocity(units)` — Ieplūdes motors
`catapult_motor`	`catapult_motor.velocity(units)` — Katapultas motors
`catapult_tension_motor`	`catapult_tension_motor.velocity(units)` — Katapultas spriegošanas motors

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

def main():
    # Print the current Intake Motor velocity
    brain.screen.print(intake_motor.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ē 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_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 #

Krāsa #

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: Krāsu sensors meklē nokrāsu diapazonus, kas atbilst norādītajai krāsai. Lai noteiktu konkrētu nokrāsu diapazonus, skatiet hue.

Usage:
color.color()

Parametri	Apraksts
	Šai metodei nav parametru.

def main():
    # Print the color detected by the Color Sensor
    brain.screen.print(color.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 krāsu sensoru tiek atstarots vairāk gaismas. Zemāks procentuālais daudzums nozīmē, ka atpakaļ tiek atstarots mazāk gaismas.

Usage:
color.brightness()

Parametri	Apraksts
	Šai metodei nav parametru.

def main():
    # Print the Color Sensor brightness
    brain.screen.print(color.brightness())

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

Parametri	Apraksts
	Šai metodei nav parametru.

def main():
    # Print the hue detected by the Color Sensor
    brain.screen.print(color.hue())

# VR threads — Do not delete
vr_thread(main)

ir_objekta_tuvumā #

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

True — Krāsu sensors nosaka objektu.
False – Krāsu sensors neuztver objektu.

Usage:
color.is_near_object()

Parametri	Apraksts
	Šai metodei nav parametru.

def main():
    # Print whether the Color Sensor detects an object nearby
    brain.screen.print(color.is_near_object())

# VR threads — Do not delete
vr_thread(main)