Robotams skirtas Python#

Įvadas #

„Hero Bot“ robotas „Byte“ turi dvi variklių grupių parinktis ir optinį jutiklį.

Visi standartiniai VEXcode VR metodai yra prieinami IQ 23-24 Full Volume žaidimų aikštelėje.

Žemiau pateikiamas visų galimų robotams skirtų metodų sąrašas:

Pavaros sistema – judinkite ir pasukite robotą.

Veiksmai
- drive — Robotas judina pirmyn arba atgal amžinai.
- drive_for — Robotas juda pirmyn arba atgal tam tikru atstumu.
- turn — Robotas visam laikui pasukamas į kairę arba į dešinę.
- turn_for — Robotas pasukamas į kairę arba į dešinę tam tikru laipsnių skaičiumi.
- turn_to_heading — Robotas pasukamas tam tikra kryptimi nuo -359 iki 359 laipsnių.
- turn_to_rotation — Įjungia roboto sukimąsi konkrečia kryptimi.
- stop — Sustabdo roboto judėjimą.
Mutatoriai
- set_heading — Pakeičia dabartinę roboto kryptį į naują.
- set_rotation — Pakeičia dabartinį roboto sukimąsi į naują.
- set_timeout — Nustato, kiek laiko robotas bandys užbaigti judesį.
- set_drive_velocity — Nurodo robotui, kokiu greičiu važiuoti.
- set_turn_velocity — Nurodo robotui, kaip greitai jis turi suktis.
Getteriai
- heading — Grąžina dabartinę roboto kryptį nuo 0 iki 359,99 laipsnių.
- rotation — Grąžina dabartinį roboto sukimąsi.
- is_done — Grąžina, ar robotas baigė judėti, kaip loginę reikšmę.
- is_moving — Grąžina, ar robotas juda, kaip loginę reikšmę.
- velocity — Grąžina roboto važiavimo greitį.

Judėjimas – judinkite ir sekite roboto variklių grupes.

Veiksmai
- spin — Suka motorinę grupę pirmyn arba atgal amžinai.
- spin_for — Suka variklio grupę tam tikrą atstumą.
- spin_to_position — Suka variklio grupę į konkrečią padėtį.
- stop — Sustabdo variklio grupės sukimąsi.
Mutatoriai
- set_position — Pakeičia variklio grupės dabartinę padėtį į naują reikšmę.
- set_velocity — Nurodo motorinei grupei, kaip greitai suktis.
- set_timeout — Nustato, kiek laiko motorinė grupė bandys užbaigti judesį.
Getteriai
- is_done – Grąžina, ar variklio grupė baigė judėti, kaip loginę reikšmę.
- is_spinning — Grąžina, ar variklio grupė sukasi, kaip loginę reikšmę.
- position — Grąžina dabartinę variklio grupės padėtį.
- velocity — Grąžina variklio grupės sukasi greitį.

Konsolė – spausdinti į konsolę ir stebėti vertes.

Spausdinti
- brain.screen.print — Konsolėje rodo tekstą, skaičius arba kintamųjų reikšmes.
- brain.screen.next_row — Perkelia konsolės žymeklį į kitos eilutės pradžią.
- brain.screen.clear_screen — Išvalo visas eilutes iš konsolės.
Monitorius
- monitor_variable – Į skirtuką „Monitorius“ įtraukia vieną ar daugiau iš anksto apibrėžtų kintamųjų.
- monitor_sensor – Į skirtuką „Monitorius“ įtraukia vieną ar daugiau jutiklio reikšmių.

Jutikliai – Išnaudokite įvairius roboto jutiklius.

Optinis
- is_near_object – Grąžina, ar optinis jutiklis aptinka objektą diapazone.
- color – Grąžina optinio jutiklio aptiktą spalvą.
- brightness – Grąžina nuo objekto atsispindinčios šviesos kiekį.
- hue – Grąžina optinio jutiklio aptiktą atspalvį.
- object_detected – Registruoja funkciją, kuri bus iškviečiama, kai optinis jutiklis aptiks objektą.
- object_lost – Registruoja funkciją, kuri bus iškviesta, kai optinis jutiklis pames objektą.

Šiame puslapyje pateiktuose pavyzdžiuose naudojama numatytoji „Playground“ pradžios pozicija.

Pavarų dėžė #

Pavaros sistema kontroliuoja VR roboto judėjimą ir posūkius. Pavaros sistema gali judėti pirmyn arba atgal, pasukti į kairę arba į dešinę, pasukti norima kryptimi ir sekti savo sukimąsi.

Veiksmai #

vairuoti #

drive robotą judina pirmyn arba atgal amžinai. Robotas judės tol, kol jam bus duotas kitas veiksmas, pvz., pasisukti arba sustoti.

Usage:
drivetrain.drive(direction)

Parametrai	Aprašymas
`direction`	Roboto judėjimo kryptis: `FORWARD` arba `REVERSE`.

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

# VR threads — Do not delete
vr_thread(main)

važiuoti_į #

drive_for robotą judina pirmyn arba atgal tam tikru atstumu. Projektas lauks, kol robotas baigs judėti, prieš paleidžiant kitą kodo eilutę.

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

Parametrai	Aprašymas
`direction`	Roboto judėjimo kryptis: `FORWARD` arba `REVERSE`.
`distance`	Atstumas, kurį nuvažiuoja robotas. Tai gali būti sveikasis skaičius `integer` arba dešimtainis skaičius (`float`).
`units`	Pasirinktinai. Atstumo vienetas: `INCHES` (numatytasis) arba `MM` (milimetrai).
`wait`	Pasirinktinai. `wait=True` (numatytasis) priverčia projektą laukti, kol robotas baigs judėti, prieš paleidžiant kitą kodo eilutę. `wait=False` priverčia kitą kodo eilutę paleisti iš karto.

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)

posūkis #

turn suka robotą į kairę arba į dešinę amžinai. Robotas suksis tol, kol jam bus duotas kitas veiksmas, pavyzdžiui, važiuoti arba sustoti.

Usage:
drivetrain.turn(direction)

Parametrai	Aprašymas
`direction`	Roboto sukimosi kryptis: `LEFT` arba `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 pasuka robotą į kairę arba į dešinę tam tikru laipsnių skaičiumi. Posūkis yra santykinis dabartinės roboto padėties atžvilgiu. Projektas lauks, kol robotas baigs pasisukti, prieš paleidžiant kitą kodo eilutę.

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

Parametrai	Aprašymas
`direction`	Roboto sukimosi kryptis: `LEFT` arba `RIGHT`.
`angle`	Laipsnių, kuriais robotas pasisuka, skaičius. Tai gali būti sveikasis skaičius `integer` arba dešimtainis skaičius (`float`).
`units`	Pasirinktinai. Pasukimo vienetas: `DEGREES` (numatytasis).
`wait`	Pasirinktinai. `wait=True` (numatytasis) priverčia projektą laukti, kol robotas baigs suktis, prieš paleidžiant kitą kodo eilutę. `wait=False` priverčia kitą kodo eilutę paleidžiama iš karto.

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)

posūkis_į_vadovą #

Kryptis – tai roboto pasukimo kryptis, matuojama laipsniais. turn_to_heading pasuka robotą tam tikra kryptimi nuo -359 iki 359 laipsnių. Robotas pasuks trumpiausia kryptimi, kad pasiektų tikslinę kryptį.

Roboto pradinė kryptis yra 0 laipsnių.

Projektas lauks, kol robotas baigs suktis, prieš paleidžiant kitą kodo eilutę.

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

Parametrai	Aprašymas
`angle`	Kryptis, kuria robotas turėtų pasukti, laipsniais. Tai gali būti sveikasis skaičius `integer` arba dešimtainis skaičius (`float`) nuo -359 iki 359.
`units`	Pasirinktinai. Pasukimo vienetas: `DEGREES` (numatytasis).
`wait`	Pasirinktinai. `wait=True` (numatytasis) priverčia projektą laukti, kol robotas baigs suktis, prieš paleidžiant kitą kodo eilutę. `wait=False` priverčia kitą kodo eilutę paleidžiama iš karto.

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)

apsisukimas #

turn_to_rotation pasuka robotą į tam tikrą sukimosi kryptį.

Sukimas rodo, kiek robotas pasisuko, matuojamas laipsniais. Projekto pradžioje sukimosi vertė nustatoma į 0 laipsnių. Sukimą taip pat galima nustatyti naudojant set_rotation metodą.

Sukimosi vertės yra absoliučios. Tai reiškia, kad posūkio kryptis priklauso nuo roboto dabartinio sukimosi. Sukant į dešinę, sukimasis padidėja, o sukant į kairę – sumažėja.

Pavyzdžiui, jei robotas pradeda judėti nuo 0 laipsnių ir jūs pasisukate 720 laipsnių kampu, jis du kartus pasisuks į dešinę. Jei tada pasisuksite 360 laipsnių kampu, jis vieną kartą pasisuks į kairę, nes 360 laipsnių yra mažiau nei 720.

Projektas lauks, kol robotas baigs suktis, prieš paleidžiant kitą kodo eilutę.

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

Parametrai	Aprašymas
`angle`	Roboto sukimosi vertė laipsniais. Tai gali būti sveikasis skaičius `integer` arba dešimtainis skaičius (`float`).
`units`	Pasirinktinai. Pasukimo vienetas: `DEGREES` (numatytasis).
`wait`	Pasirinktinai. `wait=True` (numatytasis) priverčia projektą laukti, kol robotas baigs suktis, prieš paleidžiant kitą kodo eilutę. `wait=False` priverčia kitą kodo eilutę paleidžiama iš karto.

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)

sustoti #

stop sustabdo roboto judėjimą.

Usage:
drivetrain.stop()

Parametrai	Aprašymas
	Šis metodas neturi parametrų.

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

# VR threads — Do not delete
vr_thread(main)

Mutatoriai #

antraštės_rinkinys #

Kryptis – tai roboto judėjimo kryptis, matuojama laipsniais. set_heading pakeičia dabartinę roboto kryptį į naują krypties reikšmę.

Pavyzdžiui, jei robotas pasisuko veidu į dešinę, nustačius 0 laipsnių kryptį, ta nukreipta į dešinę pozicija tampa nauja 0 laipsnių. Tada robotas gali pasisukti į kitas pozicijas, remdamasis ta nauja kryptimi.

Usage:
drivetrain.set_heading(heading, units)

Parametrai	Aprašymas
`heading`	Roboto krypties vertė laipsniais. Tai gali būti sveikasis skaičius `integer` arba dešimtainis skaičius (`float`).
`units`	Pasirinktinai. Antraštės vienetas: `DEGREES` (numatytasis).

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 #

Sukimas rodo, kiek robotas pasisuko, matuojamas laipsniais. Projekto pradžioje sukimosi vertė nustatoma į 0 laipsnių. set_rotation pakeičia dabartinę roboto sukimosi vertę į naują.

Pavyzdžiui, jei robotas atliko du pilnus posūkius į dešinę, jo sukimosi vertė bus 720 laipsnių. Nustačius sukimąsi į 0 laipsnių, sukimasis bus atstatytas iš 720 į 0 laipsnių. Tada robotas galės atlikti sukimus pagal tą naują vertę.

Usage:
drivetrain.set_rotation(rotation, units)

Parametrai	Aprašymas
`rotation`	Roboto sukimosi vertė laipsniais. Tai gali būti sveikasis skaičius `integer` arba dešimtainis skaičius (`float`).
`units`	Pasirinktinai. Pasukimo vienetas: `DEGREES` (numatytasis).

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)

nustatytas_laikas #

set_timeout nustato, kiek laiko robotas bandys užbaigti judesį. Jei robotas negali užbaigti per tą laiką, jis nustos bandyti ir pereis prie kitos kodo eilutės. Tai neleidžia robotui užstrigti ties judesiu.

Usage:
drivetrain.set_timeout(value, units)

Parametrai	Aprašymas
`value`	Laikas, per kurį robotas gali bandyti užbaigti judesį. Tai gali būti teigiamas sveikasis skaičius `integer` arba dešimtainis skaičius (`float`).
`units`	Laiko vienetas: `SECONDS` arba `MSEC` (milisekundės).

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)

nustatytas_važiavimo_greitis #

set_drive_velocity nurodo robotui, kokiu greičiu važiuoti. Didesnis procentas leidžia robotui važiuoti greičiau, o mažesnis – lėčiau.

Kiekvienas projektas prasideda nuo to, kad robotas pagal numatytuosius nustatymus važiuoja 50 % greičiu.

Pastaba: Didesnis greitis leidžia robotui važiuoti greičiau, bet gali būti mažiau tikslus. Mažesnis greitis leidžia robotui važiuoti lėčiau, bet gali būti tiksliau.

Usage:
drivetrain.set_drive_velocity(velocity, units)

Parametrai	Aprašymas
`velocity`	Važiavimo greitis nuo 0 % iki 100 %. Tai gali būti sveikasis skaičius `integer` arba dešimtainis skaičius (`float`).
`units`	Pasirinktinai. Greičio vienetas: `PERCENT` (numatytasis).

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)

nustatytas_posūkio_greitis #

set_turn_velocity nurodo robotui, kaip greitai jis turi suktis. Didesnis procentas leidžia robotui suktis greičiau, o mažesnis – lėčiau.

Kiekvienas projektas prasideda nuo to, kad robotas pagal numatytuosius nustatymus sukasi 50 % greičiu.

Pastaba: Didesnis greitis leidžia robotui sukasi greičiau, bet gali būti mažiau tikslus. Mažesnis greitis leidžia robotui sukasi lėčiau, bet gali būti tiksliau.

Usage:
drivetrain.set_turn_velocity(velocity, units)

Parametrai	Aprašymas
`velocity`	Sukimosi greitis nuo 0 % iki 100 %. Tai gali būti sveikasis skaičius `integer` arba dešimtainis skaičius (`float`).
`units`	Pasirinktinai. Greičio vienetas: `PERCENT` (numatytasis).

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)

Getteriai #

antraštė #

Kryptis – tai roboto pasukimo kryptis, matuojama laipsniais. heading grąžina dabartinę roboto kryptį nuo 0 iki 359,99 laipsnių.

Roboto pradinė kryptis yra 0 laipsnių.

Usage:
drivetrain.heading(units)

Parametrai	Aprašymas
`units`	Pasirinktinai. Antraštės vienetas: `DEGREES` (numatytasis).

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)

rotacija #

Sukimas rodo, kiek robotas pasisuko, matuojamas laipsniais. Projekto pradžioje sukimosi vertė nustatoma į 0 laipsnių. rotation grąžina dabartinį roboto sukimąsi.

Sukant į dešinę, sukimasis padidėja, o sukant į kairę – sumažėja. Pavyzdžiui, padarius du pilnus posūkius į dešinę, sukimasis bus 720 laipsnių.

Usage:
drivetrain.rotation(units)

Parametrai	Aprašymas
`units`	Pasirinktinai. Pasukimo vienetas: `DEGREES` (numatytasis).

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)

baigta #

is_done grąžina, ar robotas baigė judėti, kaip loginę reikšmę. Tai gali būti naudojama kitų veiksmų, pagrįstų roboto judėjimu, laikui valdyti.

True — Robotas baigė judėti.
False — Robotas vis dar juda.

Šis metodas veikia kartu su šiais „Drivetrain“ metodais, turinčiais parametrą wait : drive_for, turn_for, turn_to_heading ir turn_to_rotation.

Usage:
drivetrain.is_done()

Parametrai	Aprašymas
	Šis metodas neturi parametrų.

juda #

is_moving grąžina, ar robotas juda, kaip loginę reikšmę. Tai gali būti naudojama kitų veiksmų, pagrįstų roboto judėjimu, laikui valdyti.

True — Robotas juda.
False — Robotas nejuda.

Usage:
drivetrain.is_moving()

Parametrai	Aprašymas
	Šis metodas neturi parametrų.

greitis #

velocity grąžina roboto važiavimo greitį procentais nuo -100 % iki 100 %.

Usage:
drivetrain.velocity(units)

Parametrai	Aprašymas
`units`	Pasirinktinai. Greičio vienetas: `PERCENT` (numatytasis).

Pavyzdys

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

Judesys #

„Byte“ naudoja rankos variklio grupę, kad pakeltų ir nuleistų ranką, kad būtų galima transportuoti blokus. Įsiurbimo variklio grupė suka priekinius ratus, kad surinktų blokus, arba važiuoja atbuline eiga, kad juos surinktų arba numestų.

Kiekviena variklių grupė turi savo krypties elgseną. Krypties aprašymai paaiškina, kaip kiekviena kryptis judina tą variklių grupę baitų skaičiumi.

Veiksmai #

sukimasis #

spin suka motorinę grupę pirmyn arba atgal amžinai. Motorinė grupė toliau suksis, kol jai bus duotas kitas veiksmas, pavyzdžiui, suktis kita kryptimi arba sustoti.

Naudojimas:
Su šiuo metodu galima naudoti vieną iš dviejų galimų motorinių grupių objektų, kaip parodyta toliau:

variklis	Komanda
`arm_motor_group`	`arm_motor_group.spin(direction)` — Rankos variklių grupė
`intake_motor_group`	`intake_motor_group.spin(direction)` — Įsiurbimo variklio grupė

Parametrai

Aprašymas

direction

Variklių grupės sukimosi kryptis:

FORWARD — Pakelia svirties variklių grupę arba suka įsiurbimo variklių grupę įsiurbimo kryptimi.
REVERSE — Nuleidžia svirties variklių grupę arba suka įsiurbimo variklių grupę išsiurbimo kryptimi.

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

# VR threads — Do not delete
vr_thread(main)

sukimo_skirtas #

spin_for suka variklių grupę tam tikru atstumu. Sukimas yra santykinis dabartinės variklių grupės padėties atžvilgiu. Projektas lauks, kol variklių grupė baigs suktis, prieš paleidžiant kitą kodo eilutę.

Naudojimas:
Su šiuo metodu galima naudoti vieną iš dviejų galimų motorinių grupių objektų, kaip parodyta toliau:

variklis	Komanda
`arm_motor_group`	`arm_motor_group.spin_for(direction, distance, units, wait)` — Įjungti variklių grupę
`intake_motor_group`	`intake_motor_group.spin_for(direction, distance, units, wait)` — Įsiurbimo variklių grupė

Parametrai	Aprašymas
`direction`	Variklių grupės sukimosi kryptis: `FORWARD` — Pakelia svirties variklių grupę arba suka įsiurbimo variklių grupę įsiurbimo kryptimi. `REVERSE` — Nuleidžia svirties variklių grupę arba suka įsiurbimo variklių grupę išsiurbimo kryptimi.
`distance`	Atstumas, kuriuo sukasi motorinė grupė. `DEGREES` – naudokite sveikuosius skaičius. `TURNS` galite naudoti sveikuosius arba dešimtainius skaičius.
`units`	Pasirinktinai. Atstumo vienetas: `DEGREES` (numatytasis) arba `TURNS`.
`wait`	Pasirinktinai. `wait=True` (numatytasis) — Projektas laukia, kol variklio grupė baigs suktis, prieš paleidžiant kitą kodo eilutę. `wait=False` — Kita kodo eilutė paleidžiama iš karto.

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

# VR threads — Do not delete
vr_thread(main)

sukimo_į_poziciją #

spin_to_position suka variklio grupę į konkrečią padėtį.

Variklių grupės padėtis rodo, kiek toli ji apsisuko, matuojama DEGREES arba TURNSVienas apsisukimas lygus 360 laipsnių. Projekto pradžioje variklių grupės padėtis nustatoma į 0 laipsnių. Variklių grupės padėtį taip pat galima nustatyti naudojant set_position metodą.

Padėties vertės yra absoliučios. Tai reiškia, kad sukimosi kryptis priklauso nuo variklio grupės dabartinės padėties.

Pavyzdžiui, jei motorinė grupė pradeda nuo 0 laipsnių ir sukasi iki 720 laipsnių padėties, ji suksis du apsisukimus į priekį. Jei ji tada suksis iki 360 laipsnių padėties, ji suksis vieną apsisukimą atgal, nes 360 yra mažiau nei 720.

Naudojimas:
Su šiuo metodu galima naudoti vieną iš dviejų galimų motorinių grupių objektų, kaip parodyta toliau:

variklis	Komanda
`arm_motor_group`	`arm_motor_group.spin_to_position(angle, units, wait=True)` — Variklio grupės rankos
`intake_motor_group`	`intake_motor_group.spin_to_position(angle, units, wait=True)` — Įsiurbimo variklių grupė

Parametrai	Aprašymas
`angle`	Padėties vertė, iki kurios suksis variklio grupė. `DEGREES` – naudokite sveikuosius skaičius. `TURNS` galite naudoti sveikuosius arba dešimtainius skaičius.
`units`	Pasirinktinai. Padėties vienetas: `DEGREES` (numatytasis) arba `TURNS`.
`wait`	Pasirinktinai. `wait=True` (numatytasis) — Projektas laukia, kol variklio grupė baigs suktis, prieš paleidžiant kitą kodo eilutę. `wait=False` — Kita kodo eilutė paleidžiama iš karto.

Parametrai

Aprašymas

angle

Padėties vertė, iki kurios suksis variklio grupė. DEGREES – naudokite sveikuosius skaičius. TURNS galite naudoti sveikuosius arba dešimtainius skaičius.

units

Pasirinktinai. Padėties vienetas: DEGREES (numatytasis) arba TURNS.

wait

Pasirinktinai.

wait=True (numatytasis) — Projektas laukia, kol variklio grupė baigs suktis, prieš paleidžiant kitą kodo eilutę.
wait=False — Kita kodo eilutė paleidžiama iš karto.

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

# VR threads — Do not delete
vr_thread(main)

sustoti #

stop sustabdo variklio grupės sukimąsi.

Naudojimas:
Su šiuo metodu galima naudoti vieną iš dviejų galimų motorinių grupių objektų, kaip parodyta toliau:

variklis	Komanda
`arm_motor_group`	`arm_motor_group.stop()` — Variklių grupės rankos
`intake_motor_group`	`intake_motor_group.stop()` — Įsiurbimo variklių grupė

Parametrai	Aprašymas
	Šis metodas neturi parametrų.

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

# VR threads — Do not delete
vr_thread(main)

Mutatoriai #

nustatyta_pozicija #

Variklių grupės padėtis nurodo, kiek toli ji apsisuko, matuojama DEGREES arba TURNSVienas apsisukimas lygus 360 laipsnių. set_position pakeičia dabartinę variklio grupės padėtį į naują reikšmę.

Pavyzdžiui, jei variklių grupė pasisuko iki 180 laipsnių, nustatant 0 laipsnių padėtį, ši padėtis bus atkurta iš 180 į 0 laipsnių. Tada variklių grupė gali pasisukti į pozicijas pagal tą naują reikšmę.

Naudojimas:
Su šiuo metodu galima naudoti vieną iš dviejų galimų motorinių grupių objektų, kaip parodyta toliau:

variklis	Komanda
`arm_motor_group`	`arm_motor_group.set_position(position, units)` — Variklio rankenos grupė
`intake_motor_group`	`intake_motor_group.set_position(position, units)` — Įsiurbimo variklių grupė

Parametrai	Aprašymas
`position`	Variklių grupei nustatyta padėties vertė. `DEGREES` – naudokite sveikuosius skaičius. `TURNS` – naudokite sveikuosius arba dešimtainius skaičius.
`units`	Pasirinktinai. Padėties vienetas: `DEGREES` (numatytasis) arba `TURNS`.

def main():
    # Set the current motor position to 90 degrees
    intake_motor_group.set_position(90, DEGREES)
    # Spin the intake motor back to 0 degrees
    intake_motor_group.spin_to_position(0, DEGREES)

# VR threads — Do not delete
vr_thread(main)

nustatytas_greitis #

set_velocity nurodo variklių grupei, kaip greitai suktis. Didesnis procentas leidžia variklių grupei suktis greičiau, o mažesnis – lėčiau.

Kiekvienas projektas pradedamas kiekvienai variklio grupei sukant 50 % greitį pagal numatytuosius nustatymus.

Pastaba: Didesnis greitis priverčia motorinę grupę sukasi greičiau, bet gali būti mažiau tikslus. Mažesnis greitis priverčia motorinę grupę sukasi lėčiau, bet gali būti tiksliau.

Naudojimas:
Su šiuo metodu galima naudoti vieną iš dviejų galimų motorinių grupių objektų, kaip parodyta toliau:

variklis	Komanda
`arm_motor_group`	`arm_motor_group.set_velocity(velocity, units)` — „Arm“ variklių grupė
`intake_motor_group`	`intake_motor_group.set_velocity(velocity, units)` — Įsiurbimo variklių grupė

Parametrai	Aprašymas
`velocity`	Sukimosi greitis nuo 0% iki 100%. Tai gali būti sveikasis skaičius `integer` arba dešimtainis skaičius (`float`).
`units`	Greičio vienetas: `PERCENT`.

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

# VR threads — Do not delete
vr_thread(main)

nustatytas_laikas #

set_timeout nustato, kiek laiko motorų grupė bandys užbaigti judesį. Jei motorų grupė negali baigti per tą laiką, ji nustos bandyti ir pereis prie kitos kodo eilutės. Tai neleidžia motorų grupei užstrigti ties judesiu.

Naudojimas:
Su šiuo metodu galima naudoti vieną iš dviejų galimų motorinių grupių objektų, kaip parodyta toliau:

variklis	Komanda
`arm_motor_group`	`arm_motor_group.set_timeout(value, units)` — Įjungti variklių grupę
`intake_motor_group`	`intake_motor_group.set_timeout(value, units)` — Įsiurbimo variklio grupė

Parametrai	Aprašymas
`value`	Laikas, per kurį motorinė grupė gali bandyti užbaigti judesį. Tai gali būti teigiamas sveikasis skaičius `integer` arba dešimtainis skaičius (`float`).
`units`	Laiko vienetas: `SECONDS` arba `MSEC` (milisekundės).

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

# VR threads — Do not delete
vr_thread(main)

Getteriai #

baigta #

is_done grąžina, ar motorinė grupė baigė judėti, kaip loginę reikšmę. Tai gali būti naudojama kitų veiksmų, pagrįstų motorinės grupės judėjimu, laikui valdyti.

True — Variklių grupė baigė judėti.
False — Variklių grupė vis dar juda.

Šis metodas veikia kartu su šiais „Motion“ metodais, turinčiais parametrą wait : spin_for ir spin_to_position.

Naudojimas:
Su šiuo metodu galima naudoti vieną iš dviejų galimų motorinių grupių objektų, kaip parodyta toliau:

variklis	Komanda
`arm_motor_group`	`arm_motor_group.is_done()` — Variklių grupės rankos
`intake_motor_group`	`intake_motor_group.is_done()` — Įsiurbimo variklio grupė

Parametrai	Aprašymas
	Šis metodas neturi parametrų.

sukasi #

is_spinning grąžina, ar motorinė grupė sukasi, kaip loginę reikšmę. Tai gali būti naudojama kitų elgsenų laikui valdyti, remiantis motorinės grupės judėjimu.

True — Variklių grupė sukasi.
False — Variklio grupė nesisuka.

Šis metodas veikia kartu su šiais „Motion“ metodais, turinčiais parametrą wait : spin_for ir spin_to_position.

Naudojimas:
Su šiuo metodu galima naudoti vieną iš dviejų galimų motorinių grupių objektų, kaip parodyta toliau:

variklis	Komanda
`arm_motor_group`	`arm_motor_group.is_spinning()` — Rankos variklių grupė
`intake_motor_group`	`intake_motor_group.is_spinning()` — Įsiurbimo variklio grupė

Parametrai	Aprašymas
	Šis metodas neturi parametrų.

pozicija #

Variklių grupės padėtis nurodo, kiek toli ji apsisuko, matuojama DEGREES arba TURNSVienas apsisukimas lygus 360 laipsnių. position grąžina dabartinę variklio grupės padėtį.

Projekto pradžioje variklių grupės padėtis nustatyta į 0 laipsnių. Jei variklių grupė sukasi vieną pilną apsisukimą į priekį, padėtis bus 360 laipsnių arba 1 apsisukimas. Jei variklių grupė sukasi kita kryptimi, padėtis bus neigiama.

Naudojimas:
Su šiuo metodu galima naudoti vieną iš dviejų galimų motorinių grupių objektų, kaip parodyta toliau:

variklis	Komanda
`arm_motor_group`	`arm_motor_group.position(units)` — Variklio rankenos grupė
`intake_motor_group`	`intake_motor_group.position(units)` — Įsiurbimo variklio grupė

Parametrai	Aprašymas
`units`	Įrenginys, kuris grąžina variklio grupės padėtį: `DEGREES` arba `TURNS`.

greitis #

velocity grąžina variklio grupės sukasi greitį.

Teigiama vertė reiškia, kad variklių grupė sukasi pirmyn. Neigiama vertė reiškia, kad variklių grupė sukasi atgal.

Naudojimas:
Su šiuo metodu galima naudoti vieną iš dviejų galimų motorinių grupių objektų, kaip parodyta toliau:

variklis	Komanda
`arm_motor_group`	`arm_motor_group.velocity(units)` — Rankos variklių grupė
`intake_motor_group`	`intake_motor_group.velocity(units)` — Įsiurbimo variklių grupė

Parametrai	Aprašymas
`units`	Grąžintinas greičio vienetas: `PERCENT`.

Konsolė #

Kol projektas vykdomas, konsolėje rodomas tekstas, skaičiai ir kintamųjų reikšmės. Konsolės metodai taip pat gali perkelti žymeklį į naują eilutę, išvalyti konsolę ir pridėti kintamuosius arba jutiklių reikšmes į skirtuką „Monitorius“.

Spausdinti #

smegenų.ekranas.spausdintas #

brain.screen.print konsolėje rodo tekstą, skaičius arba kintamųjų reikšmes, naudodamas dabartinę žymeklio padėtį.

Naudokite brain.screen.next_row, jei norite, kad kita spausdinama reikšmė prasidėtų naujoje eilutėje.

Usage:
brain.screen.print(value)

Parametrai	Aprašymas
`value`	Tekstas, skaičius arba kintamojo reikšmė, kuri bus rodoma konsolėje.

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

# VR threads — Do not delete
vr_thread(main)

! VEXcode konsolė, kurioje rodoma konsolė ir tekstas „Labas, robote!“

smegenų.ekranas.kita_eilutė #

brain.screen.next_row perkelia žymeklį į 1 stulpelį kitoje konsolės eilutėje. Kita atspausdinta reikšmė bus rodoma toje eilutėje.

Usage:
brain.screen.next_row()

Parametrai	Aprašymas
	Šis metodas neturi parametrų.

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 konsolė, kurioje pirmoje eilutėje rodomas konsolės pavadinimas ir tekstas „1 eilutė“, o antroje – „2 eilutė“.

smegenų.ekranas.aiškus_ekranas #

brain.screen.clear_screen išvalo visas eilutes iš konsolės ir perkelia žymeklį atgal į 1 eilutę.

Usage:
brain.screen.clear_screen()

Parametrai	Aprašymas
	Šis metodas neturi parametrų.

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)

Monitorius #

monitoriaus_kintamasis #

monitor_variable prideda vieną ar daugiau iš anksto apibrėžtų kintamųjų į „VEXcode“ skirtuką „Monitor“. Tai leidžia stebėti kintamojo reikšmės pasikeitimą projekto vykdymo metu.

Kad monitor_variable sėkmingai stebėtų kintamuosius, jie turi būti globalūs. Kiekvieno kintamojo pavadinimą pateikite kaip eilutę.

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

Parametrai	Aprašymas
`variable`	Iš anksto apibrėžto stebimo globalaus kintamojo pavadinimas, pateiktas kaip eilutė. Norėdami stebėti daugiau nei vieną kintamąjį, atskirkite kiekvieno kintamojo pavadinimą kableliu.

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)

monitoriaus_jutiklis #

monitor_sensor prideda vieną ar daugiau jutiklio verčių į „VEXcode“ skirtuką „Monitorius“. Tai leidžia stebėti jutiklio verčių pokyčius projekto vykdymo metu.

Pateikite kiekvieno jutiklio reikšmę kaip eilutę.

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

Parametrai	Aprašymas
`sensor`	Jutiklio reikšmė, kurią reikia stebėti, pateikiama kaip eilutė. Norėdami stebėti daugiau nei vieną jutiklio reikšmę, kiekvieną jutiklio reikšmę atskirkite kableliu. Palaikomi jutiklių identifikatoriai: 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` Svirties variklių grupė `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` Įsiurbimo variklis `intake_motor.is_done` `intake_motor.is_spinning` `intake_motor.position_degrees` `intake_motor.position_turns` `intake_motor.velocity_rpm` `intake_motor.velocity_percent` Įsiurbimo variklių grupė `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` Katapultos variklis `catapult_motor.is_done` `catapult_motor.is_spinning` `catapult_motor.position_degrees` `catapult_motor.position_turns` `catapult_motor.velocity_rpm` `catapult_motor.velocity_percent` Katapultos įtempimo variklis `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` Bamperiai `intake_bumper.pressing` `bumper.pressing` Priekinis atstumo jutiklis `front_distance.is_object_detected` `front_distance.object_distance_mm` `front_distance.object_distance_inches` Priekinis optinis jutiklis `front_optical.is_near_object` `front_optical.color` `front_optical.brightness` `front_optical.hue` Spalvų jutiklis `color.is_near_object` `color.color` `color.brightness` `color.hue`

Parametrai

Aprašymas

sensor

Jutiklio reikšmė, kurią reikia stebėti, pateikiama kaip eilutė. Norėdami stebėti daugiau nei vieną jutiklio reikšmę, kiekvieną jutiklio reikšmę atskirkite kableliu. Palaikomi jutiklių identifikatoriai:

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
Svirties variklių grupė
- 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
Įsiurbimo variklis
- intake_motor.is_done
- intake_motor.is_spinning
- intake_motor.position_degrees
- intake_motor.position_turns
- intake_motor.velocity_rpm
- intake_motor.velocity_percent
Įsiurbimo variklių grupė
- 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
Katapultos variklis
- catapult_motor.is_done
- catapult_motor.is_spinning
- catapult_motor.position_degrees
- catapult_motor.position_turns
- catapult_motor.velocity_rpm
- catapult_motor.velocity_percent
Katapultos įtempimo variklis
- 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
Bamperiai
- intake_bumper.pressing
- bumper.pressing
Priekinis atstumo jutiklis
- front_distance.is_object_detected
- front_distance.object_distance_mm
- front_distance.object_distance_inches
Priekinis optinis jutiklis
- front_optical.is_near_object
- front_optical.color
- front_optical.brightness
- front_optical.hue
Spalvų jutiklis
- 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)

Jutimas #

Optinis #

yra_netoli_objekto #

is_near_object grąžina loginę reikšmę, nurodančią, ar optinis jutiklis aptinka objektą diapazone.

True – Optinis jutiklis aptinka objektą.
False – Optinis jutiklis neaptinka objekto.

Usage:
optical.is_near_object()

Parametrai	Aprašymas
	Šis metodas neturi parametrų.

spalva #

color grąžina Color klasės egzempliorių, pagrįstą aptikta atspalvio reikšme. Juos galima palyginti su iš anksto apibrėžtais Color objektais, norint sukurti sąlyginius teiginius.

Galimos spalvos yra:

NONE
RED – atspalvio reikšmė nuo 340° iki 20°
GREEN – atspalvio reikšmė nuo 80° iki 140°
BLUE – atspalvio reikšmė nuo 200° iki 240°
YELLOW – atspalvio reikšmė nuo 40° iki 60°
ORANGE – atspalvio reikšmė nuo 20° iki 40°
PURPLE – atspalvio reikšmė nuo 240° iki 280°
CYAN – atspalvio reikšmė nuo 140° iki 200°

Pastaba: Optinis jutiklis ieško atspalvių diapazonų, kurie atitiktų nurodytą spalvą. Norėdami aptikti konkrečius atspalvių diapazonus, žr. hue.

Usage:
optical.color()

Parametrai	Aprašymas
	Šis metodas neturi parametrų.

ryškumas #

brightness grąžina nuo objekto atspindėtos šviesos kiekį dešimtainiu skaičiumi (float), reiškiančiu procentą.

Didesnis procentas reiškia, kad daugiau šviesos atsispindi atgal į optinį jutiklį. Mažesnis procentas reiškia, kad atsispindi mažiau šviesos.

Usage:
optical.brightness()

Parametrai	Aprašymas
	Šis metodas neturi parametrų.

atspalvis #

hue grąžina aptiktos spalvos atspalvio reikšmę dešimtainiu skaičiumi (float) nuo 0 iki 359.

Atspalvis yra būdas apibūdinti spalvą skaičiais aplink spalvų ratą.

Apskritas spalvų ratas, rodantis visą atspalvių spektrą, pažymėtą laipsnių reikšmėmis aplink perimetrą, didėjant 30 laipsnių žingsniais nuo 0° viršuje iki 360°.

Usage:
optical.hue()

Parametrai	Aprašymas
	Šis metodas neturi parametrų.

objektas_aptiktas #

object_detected užregistruoja funkciją, kuri bus iškviečiama kaskart, kai optinis jutiklis aptiks naują objektą.

Usage:
optical.object_detected(callback, arg)

Parametrai	Aprašymas
`callback`	Anksčiau apibrėžta function, kuri vykdoma, kai optinis jutiklis aptinka naują objektą.
`arg`	Pasirinktinai. Tuple su argumentais, kuriuos reikia perduoti atgalinio iškvietimo funkcijai. Daugiau informacijos žr. Funkcijų su parametrais naudojimas.

prarastas objektas #

object_lost užregistruoja funkciją, kuri bus iškviečiama kaskart, kai optinis jutiklis pameta aptiktą objektą.

Usage:
optical.object_lost(callback, arg)

Parametrai	Aprašymas
`callback`	Anksčiau apibrėžta function, kuri vykdoma, kai optinis jutiklis praranda aptiktą objektą.
`arg`	Pasirinktinai. Tuple su argumentais, kuriuos reikia perduoti atgalinio iškvietimo funkcijai. Daugiau informacijos žr. Funkcijų su parametrais naudojimas.