Robotams skirtas Python#

Įvadas #

„Hero Bot“ „Fling“ turi tris variklio parinktis ir spalvų jutiklį.

Visi standartiniai VEXcode VR metodai yra prieinami IQ 21-22 Pitching In ž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 variklius.

Veiksmai
- spin — Variklis sukasi pirmyn arba atgal amžinai.
- spin_for — Suka variklį tam tikrą atstumą.
- spin_to_position — Suka variklį į konkrečią padėtį.
- stop — Sustabdo variklio sukimąsi.
Mutatoriai
- set_position — Pakeičia dabartinę variklio padėtį į naują reikšmę.
- set_velocity — Nurodo varikliui sukimosi greitį.
- set_timeout — Nustato, kiek laiko variklis bandys užbaigti judesį.
Getteriai
- is_done — Grąžina, ar variklis baigė judėti, kaip loginę reikšmę.
- is_spinning — Grąžina, ar variklis sukasi, kaip loginę reikšmę.
- position — Grąžina dabartinę variklio padėtį.
- velocity — Grąžina variklio sukimosi 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.

Spalva
- color – Grąžina spalvų jutiklio aptiktą spalvą.
- brightness – Grąžina nuo objekto atsispindinčios šviesos kiekį.
- hue – Grąžina spalvų jutiklio aptiktą atspalvį.
- is_near_object – Grąžina, ar spalvų jutiklis aptinka objektą diapazone.

Š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 judėjimo kryptis, matuojama laipsniais. heading grąžina dabartinę roboto judėjimo 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 #

„Fling“ naudoja įsiurbimo variklį kamuoliukams įtraukti arba išstumti. Katapulta ir katapultos svirties įtempimo varikliai paleidžia kamuoliukus, o įtempimas keičia jų skrydžio atstumą.

Kiekvienas variklis turi savo krypties elgseną. Krypties aprašymai paaiškina, kaip kiekviena kryptis judina tą variklį „Fling“ režime.

Veiksmai #

sukimasis #

spin suka variklį pirmyn arba atgal amžinai. Variklis suksis tol, kol jam bus duotas kitas veiksmas, pavyzdžiui, suktis kita kryptimi arba sustoti.

Naudojimas:
Šiuo metodu galima naudoti vieną iš trijų galimų motorinių objektų, kaip parodyta toliau:

variklis	Komanda
`intake_motor`	`intake_motor.spin(direction)` — Įsiurbimo variklis
`catapult_motor`	`catapult_motor.spin(direction)` — Katapultos variklis
`catapult_tension_motor`	`catapult_tension_motor.spin(direction)` — Katapultos įtempimo variklis

Parametrai	Aprašymas
`direction`	Variklio sukimosi kryptis priklauso nuo pasirinkto variklio: `FORWARD` — Suka įsiurbimo variklį įsiurbimo kryptimi arba judina pasirinktą katapultos variklį į priekį. `REVERSE` — Suka įsiurbimo variklį išsiurbimo kryptimi arba judina pasirinktą katapultos variklį atgal.

Parametrai

Aprašymas

direction

Variklio sukimosi kryptis priklauso nuo pasirinkto variklio:

FORWARD — Suka įsiurbimo variklį įsiurbimo kryptimi arba judina pasirinktą katapultos variklį į priekį.
REVERSE — Suka įsiurbimo variklį išsiurbimo kryptimi arba judina pasirinktą katapultos variklį atgal.

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)

sukimo_skirtas #

spin_for suka variklį tam tikrą atstumą. Sukimasis yra santykinis pagal dabartinę variklio padėtį. Projektas lauks, kol variklis baigs suktis, prieš paleidžiant kitą kodo eilutę.

Naudojimas:
Šiuo metodu galima naudoti vieną iš trijų galimų motorinių objektų, kaip parodyta toliau:

variklis	Komanda
`intake_motor`	`intake_motor.spin_for(direction, distance, units, wait=True)` — Įsiurbimo variklis
`catapult_motor`	`catapult_motor.spin_for(direction, distance, units, wait=True)` — Katapultos variklis
`catapult_tension_motor`	`catapult_tension_motor.spin_for(direction, distance, units, wait=True)` — Katapultos įtempimo variklis

Parametrai	Aprašymas
`direction`	Variklio sukimosi kryptis priklauso nuo pasirinkto variklio: `FORWARD` arba `REVERSE`.
`distance`	Variklio sukamasis atstumas. `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 variklis baigs suktis, prieš paleidžiant kitą kodo eilutę. `wait=False` — Kita kodo eilutė paleidžiama iš karto.

def main():
    # Collect a Ball with the Intake Motor
    intake_motor.spin_for(FORWARD, 360, DEGREES)

# VR threads — Do not delete
vr_thread(main)

sukimo_į_poziciją #

spin_to_position suka variklį į tam tikrą padėtį.

Variklio padėtis rodo, kiek jis apsisuko, matuojant DEGREES arba TURNSVienas apsisukimas lygus 360 laipsnių. Projekto pradžioje variklio padėtis nustatoma į 0 laipsnių. Variklio 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 dabartinės variklio padėties.

Pavyzdžiui, jei variklis užsiveda esant 0 laipsnių kampui ir sukasi iki 720 laipsnių padėties, jis suksis du apsisukimus į priekį. Jei jis tada suksis iki 360 laipsnių padėties, jis suksis vieną apsisukimą atgal, nes 360 yra mažiau nei 720.

Naudojimas:
Šiuo metodu galima naudoti vieną iš trijų galimų motorinių objektų, kaip parodyta toliau:

variklis	Komanda
`intake_motor`	`intake_motor.spin_to_position(angle, units, wait=True)` — Įsiurbimo variklis
`catapult_motor`	`catapult_motor.spin_to_position(angle, units, wait=True)` — Katapultos variklis
`catapult_tension_motor`	`catapult_tension_motor.spin_to_position(angle, units, wait=True)` — Katapultos įtempimo variklis

Parametrai	Aprašymas
`angle`	Padėties vertė, iki kurios suksis variklis. `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 variklis 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 variklis. 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 variklis baigs suktis, prieš paleidžiant kitą kodo eilutę.
wait=False — Kita kodo eilutė paleidžiama iš karto.

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)

sustabdyti variklį #

stop sustabdo variklio sukimąsi.

Naudojimas:
Šiuo metodu galima naudoti vieną iš trijų galimų motorinių objektų, kaip parodyta toliau:

variklis	Komanda
`intake_motor`	`intake_motor.stop()` — Įsiurbimo variklis
`catapult_motor`	`catapult_motor.stop()` — Katapultos variklis
`catapult_tension_motor`	`catapult_tension_motor.stop()` — Katapultos įtempimo variklis

Parametrai	Aprašymas
	Šis metodas neturi parametrų.

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)

Mutatoriai #

nustatyta_pozicija #

Variklio padėtis nurodo, kiek toli jis apsisuko, matuojant DEGREES arba TURNSVienas apsisukimas lygus 360 laipsnių. set_position pakeičia dabartinę variklio padėtį į naują reikšmę.

Pavyzdžiui, jei variklis apsisuko iki 180 laipsnių, nustatant 0 laipsnių padėtį, ši padėtis bus atkurta iš 180 į 0 laipsnių. Tada variklis gali suktis į padėtis, pagrįstas ta nauja verte.

Naudojimas:
Šiuo metodu galima naudoti vieną iš trijų galimų motorinių objektų, kaip parodyta toliau:

variklis	Komanda
`intake_motor`	`intake_motor.set_position(position, units)` — Įsiurbimo variklis
`catapult_motor`	`catapult_motor.set_position(position, units)` — Katapultos variklis
`catapult_tension_motor`	`catapult_tension_motor.set_position(position, units)` — Katapultos įtempimo variklis

Parametrai	Aprašymas
`position`	Variklio padėties vertė, kurią reikia nustatyti. `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 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)

nustatytas_greitis #

set_velocity nurodo varikliui, kokiu greičiu jis turi suktis. Didesnis procentas leidžia varikliui suktis greičiau, o mažesnis – lėčiau.

Kiekvienas projektas pradedamas, kai kiekvienas variklis pagal numatytuosius nustatymus sukasi 50 % greičiu.

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

Naudojimas:
Šiuo metodu galima naudoti vieną iš trijų galimų motorinių objektų, kaip parodyta toliau:

variklis	Komanda
`intake_motor`	`intake_motor.set_velocity(velocity, units)` — Įsiurbimo variklis
`catapult_motor`	`catapult_motor.set_velocity(velocity, units)` — Katapultos variklis
`catapult_tension_motor`	`catapult_tension_motor.set_velocity(velocity, units)` — Katapultos įtempimo variklis

Parametrai	Aprašymas
`velocity`	Sukimosi greitis nuo -100 % iki 100 %. Tai gali būti sveikasis skaičius `integer` arba dešimtainis skaičius (`float`).
`units`	Greičio vienetas: `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)

nustatytas_laikas #

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

Naudojimas:
Šiuo metodu galima naudoti vieną iš trijų galimų motorinių objektų, kaip parodyta toliau:

variklis	Komanda
`intake_motor`	`intake_motor.set_timeout(value, units)` — Įsiurbimo variklis
`catapult_motor`	`catapult_motor.set_timeout(value, units)` — Katapultos variklis
`catapult_tension_motor`	`catapult_tension_motor.set_timeout(value, units)` — Katapultos įtempimo variklis

Parametrai	Aprašymas
`value`	Laikas, per kurį variklis 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():
    # 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)

Getteriai #

baigta #

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

True — Variklis nustojo judėti.
False — Variklis vis dar juda.

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

Naudojimas:
Šiuo metodu galima naudoti vieną iš trijų galimų motorinių objektų, kaip parodyta toliau:

variklis	Komanda
`intake_motor`	`intake_motor.is_done()` — Įsiurbimo variklis
`catapult_motor`	`catapult_motor.is_done()` — Katapultos variklis
`catapult_tension_motor`	`catapult_tension_motor.is_done()` — Katapultos įtempimo variklis

Parametrai	Aprašymas
	Šis metodas neturi parametrų.

sukasi #

is_spinning grąžina, ar variklis sukasi, kaip loginę reikšmę. Tai gali būti naudojama kitų veiksmų, pagrįstų variklio judėjimu, laikui valdyti.

True — Variklis sukasi.
False — Variklis nesisuka.

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

Naudojimas:
Šiuo metodu galima naudoti vieną iš trijų galimų motorinių objektų, kaip parodyta toliau:

variklis	Komanda
`intake_motor`	`intake_motor.is_spinning()` — Įsiurbimo variklis
`catapult_motor`	`catapult_motor.is_spinning()` — Katapultos variklis
`catapult_tension_motor`	`catapult_tension_motor.is_spinning()` — Katapultos įtempimo variklis

Parametrai	Aprašymas
	Šis metodas neturi parametrų.

pozicija #

Variklio padėtis nurodo, kiek jis apsisuko, matuojant DEGREES arba TURNSVienas apsisukimas lygus 360 laipsnių. position grąžina dabartinę variklio padėtį.

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

Naudojimas:
Šiuo metodu galima naudoti vieną iš trijų galimų motorinių objektų, kaip parodyta toliau:

variklis	Komanda
`intake_motor`	`intake_motor.position(units)` — Įsiurbimo variklis
`catapult_motor`	`catapult_motor.position(units)` — Katapultos variklis
`catapult_tension_motor`	`catapult_tension_motor.position(units)` — Katapultos įtempimo variklis

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

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

# VR threads — Do not delete
vr_thread(main)

greitis #

velocity grąžina variklio sukasi greitį.

Teigiama reikšmė reiškia, kad variklis sukasi į priekį. Neigiama reikšmė reiškia, kad variklis sukasi atgal.

Naudojimas:
Šiuo metodu galima naudoti vieną iš trijų galimų motorinių objektų, kaip parodyta toliau:

variklis	Komanda
`intake_motor`	`intake_motor.velocity(units)` — Įsiurbimo variklis
`catapult_motor`	`catapult_motor.velocity(units)` — Katapultos variklis
`catapult_tension_motor`	`catapult_tension_motor.velocity(units)` — Katapultos įtempimo variklis

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

def main():
    # Print the current Intake Motor velocity
    brain.screen.print(intake_motor.velocity(PERCENT))

# VR threads — Do not delete
vr_thread(main)

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 #

Spalva #

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: Spalvų jutiklis ieško atspalvių diapazonų, kurie atitiktų nurodytą spalvą. Norėdami aptikti konkrečius atspalvių diapazonus, žr. hue.

Usage:
color.color()

Parametrai	Aprašymas
	Šis metodas neturi parametrų.

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

# VR threads — Do not delete
vr_thread(main)

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 į spalvų jutiklį. Mažesnis procentas reiškia, kad atsispindi mažiau šviesos.

Usage:
color.brightness()

Parametrai	Aprašymas
	Šis metodas neturi parametrų.

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

# VR threads — Do not delete
vr_thread(main)

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 laipsnių viršuje iki 360 laipsnių.

Usage:
color.hue()

Parametrai	Aprašymas
	Šis metodas neturi parametrų.

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

# VR threads — Do not delete
vr_thread(main)

yra_netoli_objekto #

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

True – Spalvų jutiklis aptinka objektą.
False – Spalvų jutiklis neaptinka objekto.

Usage:
color.is_near_object()

Parametrai	Aprašymas
	Šis metodas neturi parametrų.

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)