Robotams skirtas Python#

Įvadas #

„Hero Bot“ „Swish“ turi vieną variklio parinktį, vieną variklių grupės parinktį ir optinį jutiklį.

Visi standartiniai VEXcode VR metodai yra prieinami IQ 24-25 Rapid Relay ž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 variklį ir variklių grupę.

Veiksmai
- spin — Variklis arba variklių grupė sukasi pirmyn arba atgal amžinai.
- spin_for — Suka variklį arba variklių grupę tam tikrą atstumą.
- spin_to_position — Suka variklį arba variklių grupę į konkrečią padėtį.
- stop — Sustabdo variklio arba variklių grupės sukimąsi.
Mutatoriai
- set_position — Pakeičia variklio arba variklių grupės dabartinę padėtį į naują reikšmę.
- set_velocity — Nurodo varikliui arba variklių grupei, kokiu greičiu suktis.
- set_timeout — Nustato, kiek laiko variklis arba variklių grupė bandys užbaigti judesį.
Getteriai
- is_done – Grąžina, ar variklis arba variklių grupė baigė judėti, kaip loginę reikšmę.
- is_spinning — Grąžina, ar sukasi variklis, ar variklių grupė, kaip loginę reikšmę.
- position — Grąžina dabartinę variklio arba variklių grupės padėtį.
- velocity — Grąžina variklio arba variklių 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`	Atstumo vienetas: `INCHES` 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`	Sukimosi vienetas: `DEGREES`.
`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`	Sukimosi vienetas: `DEGREES`.
`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`	Sukimosi vienetas: `DEGREES`.
`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`	Krypties vienetas: `DEGREES`.

def main():
    # Face the new 0 degrees
    drivetrain.set_heading(90, DEGREES)
    drivetrain.turn_to_heading(0, DEGREES)

# VR threads — Do not delete
vr_thread(main)

set_rotation #

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`	Sukimosi vienetas: `DEGREES`.

def main():
    # Spin counterclockwise two times
    drivetrain.set_rotation(720, DEGREES)
    drivetrain.turn_to_rotation(0, DEGREES)

# VR threads — Do not delete
vr_thread(main)

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`	Greičio vienetas: `PERCENT`.

def main():
    # Drive forward at different velocities
    # Default velocity
    drivetrain.drive_for(FORWARD, 150, MM)
    wait(1, SECONDS)
    # Drive slower
    drivetrain.set_drive_velocity(20, PERCENT)
    drivetrain.drive_for(FORWARD, 150, MM)
    wait(1, SECONDS)
    # Drive faster
    drivetrain.set_drive_velocity(100, PERCENT)
    drivetrain.drive_for(FORWARD, 150, MM)

# VR threads — Do not delete
vr_thread(main)

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`	Greičio vienetas: `PERCENT`.

def main():
    # Turn at different velocities
    # Default velocity
    drivetrain.turn_for(RIGHT, 120, DEGREES)
    wait(1, SECONDS)
    # Turn slower
    drivetrain.set_turn_velocity(20, PERCENT)
    drivetrain.turn_for(RIGHT, 120, DEGREES)
    wait(1, SECONDS)
    # Turn faster
    drivetrain.set_turn_velocity(100, PERCENT)
    drivetrain.turn_for(RIGHT, 120, DEGREES)

# VR threads — Do not delete
vr_thread(main)

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`	Krypties vienetas: `DEGREES`.

def main():
    # Display the heading after turning
    drivetrain.turn_for(RIGHT, 450, DEGREES)
    brain.screen.print("Heading: ")
    brain.screen.print(drivetrain.heading(DEGREES))

# VR threads — Do not delete
vr_thread(main)

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`	Sukimosi vienetas: `DEGREES`.

def main():
    # Display the rotation after turning
    drivetrain.turn_for(RIGHT, 450, DEGREES)
    brain.screen.print("Rotation: ")
    brain.screen.print(drivetrain.rotation(DEGREES))

# VR threads — Do not delete
vr_thread(main)

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`	Greičio vienetas: `PERCENT`.

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 #

„Swish“ naudoja įsiurbimo variklį kamuoliukams surinkti ir perkelti juos ant katapultos. Katapultos variklių grupė nuleidžia ir atleidžia katapultos svirtį, kad paleistų kamuoliukus.

Kiekvienas variklis ir variklių grupė turi savo krypties elgseną. Krypties aprašymuose paaiškinama, kaip kiekviena kryptis judina tą variklį arba variklių grupę „Swish“ programoje.

Veiksmai #

sukimasis #

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

Naudojimas:
Šiuo metodu galima naudoti vieną iš dviejų galimų variklio arba variklių grupės objektų, kaip parodyta toliau:

variklis	Komanda
`intake_motor`	`intake_motor.spin(direction)` — Įsiurbimo variklis
`catapult_group`	`catapult_group.spin(direction)` — Katapultų grupė

Parametrai

Aprašymas

direction

Variklio arba variklių grupės sukimosi kryptis:

FORWARD — Suka įsiurbimo variklį įsiurbimo kryptimi arba nuleidžia katapultų grupę.
REVERSE — Suka įsiurbimo variklį išsiurbimo kryptimi arba atleidžia katapultų grupę.

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

# VR threads — Do not delete
vr_thread(main)

sukimo_skirtas #

spin_for suka variklį arba variklių grupę tam tikru atstumu. Sukimasis yra santykinis pagal dabartinę variklio arba variklių grupės padėtį. Projektas lauks, kol variklis arba variklių grupė baigs suktis, prieš paleidžiant kitą kodo eilutę.

Naudojimas:
Šiuo metodu galima naudoti vieną iš dviejų galimų variklio arba variklių grupės objektų, kaip parodyta toliau:

variklis	Komanda
`intake_motor`	`intake_motor.spin_for(direction, distance, units, wait=True)` — Įsiurbimo variklis
`catapult_group`	`catapult_group.spin_for(direction, distance, units, wait=True)` — Katapultų grupė

Parametrai	Aprašymas
`direction`	Variklio arba variklių grupės sukimosi kryptis: `FORWARD` — Suka įsiurbimo variklį įsiurbimo kryptimi arba nuleidžia katapultų grupę. `REVERSE` — Suka įsiurbimo variklį išsiurbimo kryptimi arba atleidžia katapultų grupę.
`distance`	Atstumas, kuriuo sukasi variklis arba variklių 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 variklis arba variklių grupė baigs suktis, prieš paleidžiant kitą kodo eilutę. `wait=False` — Kita kodo eilutė paleidžiama iš karto.

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

# VR threads — Do not delete
vr_thread(main)

sukimo_į_poziciją #

spin_to_position suka variklį arba variklių grupę į konkrečią padėtį.

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

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

Naudojimas:
Šiuo metodu galima naudoti vieną iš dviejų galimų variklio arba variklių grupės objektų, kaip parodyta toliau:

variklis	Komanda
`intake_motor`	`intake_motor.spin_to_position(angle, units, wait=True)` — Įsiurbimo variklis
`catapult_group`	`catapult_group.spin_to_position(angle, units, wait=True)` — Katapultų grupė

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

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

# VR threads — Do not delete
vr_thread(main)

sustabdyti variklį #

stop sustabdo variklio arba variklių grupės sukimąsi.

Naudojimas:
Šiuo metodu galima naudoti vieną iš dviejų galimų variklio arba variklių grupės objektų, kaip parodyta toliau:

variklis	Komanda
`intake_motor`	`intake_motor.stop()` — Įsiurbimo variklis
`catapult_group`	`catapult_group.stop()` — Katapultų grupė

Parametrai	Aprašymas
	Šis metodas neturi parametrų.

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

# VR threads — Do not delete
vr_thread(main)

Mutatoriai #

nustatyta_pozicija #

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

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

Naudojimas:
Šiuo metodu galima naudoti vieną iš dviejų galimų variklio arba variklių grupės objektų, kaip parodyta toliau:

variklis	Komanda
`intake_motor`	`intake_motor.set_position(position, units)` — Įsiurbimo variklis
`catapult_group`	`catapult_group.set_position(position, units)` — Katapultų grupė

Parametrai	Aprašymas
`position`	Variklio arba variklių grupės 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():
    # Lower the Catapult to prepare to load another Ball
    catapult_group.spin_to_position(1260, DEGREES)
    # Set the new Catapult position to be 0 degrees
    catapult_group.set_position(0, DEGREES)

# VR threads — Do not delete
vr_thread(main)

nustatytas_greitis #

set_velocity nurodo varikliui arba variklių grupei, kokiu greičiu suktis. Didesnis procentas leidžia varikliui arba variklių grupei suktis greičiau, o mažesnis procentas – lėčiau.

Kiekvienas projektas pradedamas nuo to, kad kiekvienas variklis arba variklių grupė pagal numatytuosius nustatymus sukasi 50 % greičiu.

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

Naudojimas:
Šiuo metodu galima naudoti vieną iš dviejų galimų variklio arba variklių grupės objektų, kaip parodyta toliau:

variklis	Komanda
`intake_motor`	`intake_motor.set_velocity(velocity, units)` — Įsiurbimo variklis
`catapult_group`	`catapult_group.set_velocity(velocity, units)` — Katapultų grupė

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():
    # Start spinning the Intake Motor to prepare for picking up a Ball
    intake_motor.set_velocity(100, PERCENT)
    intake_motor.spin(FORWARD)

# VR threads — Do not delete
vr_thread(main)

nustatytas_laikas #

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

Naudojimas:
Šiuo metodu galima naudoti vieną iš dviejų galimų variklio arba variklių grupės objektų, kaip parodyta toliau:

variklis	Komanda
`intake_motor`	`intake_motor.set_timeout(value, units)` — Įsiurbimo variklis
`catapult_group`	`catapult_group.set_timeout(value, units)` — Katapultų grupė

Parametrai	Aprašymas
`value`	Laikas, per kurį variklis arba variklių 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():
    # Limit how long the Catapult waits to reach its target
    catapult_group.set_timeout(2, SECONDS)
    catapult_group.spin_for(FORWARD, 2160, DEGREES)

# VR threads — Do not delete
vr_thread(main)

Getteriai #

baigta #

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

True — Variklis arba variklių grupė baigė judėti.
False — Variklis arba variklių grupė 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š dviejų galimų variklio arba variklių grupės objektų, kaip parodyta toliau:

variklis	Komanda
`intake_motor`	`intake_motor.is_done()` — Įsiurbimo variklis
`catapult_group`	`catapult_group.is_done()` — Katapultų grupė

Parametrai	Aprašymas
	Šis metodas neturi parametrų.

sukasi #

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

True — Variklis arba variklių grupė sukasi.
False — Variklis arba variklių grupė 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š dviejų galimų variklio arba variklių grupės objektų, kaip parodyta toliau:

variklis	Komanda
`intake_motor`	`intake_motor.is_spinning()` — Įsiurbimo variklis
`catapult_group`	`catapult_group.is_spinning()` — Katapultų grupė

Parametrai	Aprašymas
	Šis metodas neturi parametrų.

pozicija #

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

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

Naudojimas:
Šiuo metodu galima naudoti vieną iš dviejų galimų variklio arba variklių grupės objektų, kaip parodyta toliau:

variklis	Komanda
`intake_motor`	`intake_motor.position(units)` — Įsiurbimo variklis
`catapult_group`	`catapult_group.position(units)` — Katapultų grupė

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

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

# VR threads — Do not delete
vr_thread(main)

greitis #

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

Teigiama reikšmė reiškia, kad variklis arba variklių grupė sukasi pirmyn. Neigiama reikšmė reiškia, kad variklis arba variklių grupė sukasi atgal.

Naudojimas:
Šiuo metodu galima naudoti vieną iš dviejų galimų variklio arba variklių grupės objektų, kaip parodyta toliau:

variklis	Komanda
`intake_motor`	`intake_motor.velocity(units)` — Įsiurbimo variklis
`catapult_group`	`catapult_group.velocity(units)` — Katapultų grupė

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

def main():
    # Print the current Catapult velocity
    brain.screen.print(catapult_group.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į. Tai veikia kaip print konsolės API puslapyje.

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

Parametrai	Aprašymas
	Šis metodas neturi parametrų.

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

# VR threads — Do not delete
vr_thread(main)

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

Parametrai	Aprašymas
	Šis metodas neturi parametrų.

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

# VR threads — Do not delete
vr_thread(main)

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

Parametrai	Aprašymas
	Šis metodas neturi parametrų.

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

# VR threads — Do not delete
vr_thread(main)

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

Parametrai	Aprašymas
	Šis metodas neturi parametrų.

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

# VR threads — Do not delete
vr_thread(main)

objektas_aptiktas #

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

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

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

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

# VR threads — Do not delete
vr_thread(main)

prarastas objektas #

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

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

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

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

# VR threads — Do not delete
vr_thread(main)