Robotams skirtas Python#

Įvadas #

„Hero Bot“ robotas „Huey“ turi dvi variklio parinktis: „IQ AI“ regėjimo jutiklį, optinį jutiklį ir jutiklinį LED.

Visi standartiniai VEXcode VR metodai yra prieinami IQ 25-26 Mix & Match ž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į.

AI vizija – fiksuokite ir analizuokite objektus naudodami IQ AI vizijos jutiklį.

Getteriai
- take_snapshot – Grąžina aptiktų objektų rinkinį, skirtą konkrečiam parašui.
Ypatybės
- width – Aptikto objekto plotis pikseliais.
- height – Aptikto objekto aukštis pikseliais.
- centerX – objekto centro X padėtis pikseliais.
- centerY – Objekto centro Y padėtis pikseliais.
- originX – objekto viršutinio kairiojo kampo X padėtis pikseliais.
- originY – objekto viršutinio kairiojo kampo Y padėtis pikseliais.
- id – Objekto klasifikacija arba žymės ID.

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.

Lietiklinis šviesos diodas
- set_color – Nustato jutiklinį LED į pasirinktą spalvą.
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 #

Huey naudoja žnyplių variklį žnyplėms atidaryti ir uždaryti, kad būtų galima pakelti arba numesti kaiščius ir sijas. Kėlimo variklis pakelia ir nuleidžia kaiščius arba sijas, kad juos būtų galima sujungti vieną su kitu.

Kiekvienas variklis turi savo krypties elgseną. Krypties aprašymai paaiškina, kaip kiekviena kryptis judina tą variklį „Huey“ raketėje.

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š dviejų galimų motorinių objektų, kaip parodyta toliau:

variklis	Komanda
`claw_motor`	`claw_motor.spin(direction)` — Nagų variklis
`lift_motor`	`lift_motor.spin(direction)` — Kėlimo variklis

Parametrai

Aprašymas

direction

Variklio sukimosi kryptis:

FORWARD — Atidaro griebtuvą arba nuleidžia keltuvą.
REVERSE — Uždaro griebtuvą arba pakelia keltuvą.

def main():
    # Raise the lift, drive forward, then open the claw.
    lift_motor.spin_for(REVERSE, 600, DEGREES)
    drivetrain.drive_for(FORWARD, 140, MM)
    claw_motor.spin(FORWARD)

# 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š dviejų galimų motorinių objektų, kaip parodyta toliau:

variklis	Komanda
`claw_motor`	`claw_motor.spin_for(direction, distance, units, wait=True)` — Nagų variklis
`lift_motor`	`lift_motor.spin_for(direction, distance, units, wait=True)` — Kėlimo variklis

Parametrai	Aprašymas
`direction`	Variklio sukimosi kryptis: `FORWARD` — Atidaro griebtuvą arba nuleidžia keltuvą. `REVERSE` — Uždaro griebtuvą arba pakelia keltuvą.
`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():
    # Raise the lift, drive forward, then open the claw.
    lift_motor.spin_for(REVERSE, 600, DEGREES)
    drivetrain.drive_for(FORWARD, 140, MM)
    claw_motor.spin(FORWARD)

# 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š dviejų galimų motorinių objektų, kaip parodyta toliau:

variklis	Komanda
`claw_motor`	`claw_motor.spin_to_position(angle, units, wait=True)` — Nagų variklis
`lift_motor`	`lift_motor.spin_to_position(angle, units, wait=True)` — Kėlimo 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():
    # Raise the lift to a known position, drive, then open the claw
    lift_motor.spin_to_position(-720, DEGREES)
    drivetrain.drive_for(FORWARD, 140, MM)
    claw_motor.spin(FORWARD)

# VR threads — Do not delete
vr_thread(main)

sustabdyti variklį #

stop sustabdo variklio sukimąsi.

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

variklis	Komanda
`claw_motor`	`claw_motor.stop()` — Nagų variklis
`lift_motor`	`lift_motor.stop()` — Kėlimo variklis

Parametrai	Aprašymas
	Šis metodas neturi parametrų.

def main():
    # Raise the lift for 2 seconds, then stop
    lift_motor.spin(REVERSE)
    wait(2, SECONDS)
    lift_motor.stop()
    drivetrain.drive_for(FORWARD, 140, MM)
    claw_motor.spin(FORWARD)

# 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š dviejų galimų motorinių objektų, kaip parodyta toliau:

variklis	Komanda
`claw_motor`	`claw_motor.set_position(position, units)` — Nagų variklis
`lift_motor`	`lift_motor.set_position(position, units)` — Kėlimo 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():
    # Reset the lift position, then move to a new target.
    lift_motor.set_position(100, DEGREES)
    lift_motor.spin_to_position(-500, DEGREES)
    drivetrain.drive_for(FORWARD, 140, MM)
    claw_motor.spin(FORWARD)

# 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š dviejų galimų motorinių objektų, kaip parodyta toliau:

variklis	Komanda
`claw_motor`	`claw_motor.set_velocity(velocity, units)` — Nagų variklis
`lift_motor`	`lift_motor.set_velocity(velocity, units)` — Kėlimo variklis

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():
    # Set lift speed, then raise it.
    lift_motor.set_velocity(100, PERCENT)
    lift_motor.spin_for(REVERSE, 600, DEGREES)
    drivetrain.drive_for(FORWARD, 140, MM)
    claw_motor.spin(FORWARD)

# 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š dviejų galimų motorinių objektų, kaip parodyta toliau:

variklis	Komanda
`claw_motor`	`claw_motor.set_timeout(value, units)` — Nagų variklis
`lift_motor`	`lift_motor.set_timeout(value, units)` — Kėlimo 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 lift waits to reach its target.
    lift_motor.set_timeout(2, SECONDS)
    lift_motor.spin_for(REVERSE, 1800, DEGREES)
    drivetrain.drive_for(FORWARD, 140, MM)
    claw_motor.spin(FORWARD)

# 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š dviejų galimų motorinių objektų, kaip parodyta toliau:

variklis	Komanda
`claw_motor`	`claw_motor.is_done()` — Nagų variklis
`lift_motor`	`lift_motor.is_done()` — Kėlimo variklis

Parametrai	Aprašymas
	Šis metodas neturi parametrų.

def main():
    # Flash the Touch LED while the lift is moving.
    lift_motor.spin_for(REVERSE, 600, DEGREES, wait=False)
    wait(0.1, SECONDS)
    while not lift_motor.is_done():
        touchled.set_color(RED)
        wait(0.5, SECONDS)
        touchled.set_color(NONE)
        wait(0.5, SECONDS)

# VR threads — Do not delete
vr_thread(main)

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š dviejų galimų motorinių objektų, kaip parodyta toliau:

variklis	Komanda
`claw_motor`	`claw_motor.is_spinning()` — Nagų variklis
`lift_motor`	`lift_motor.is_spinning()` — Kėlimo variklis

Parametrai	Aprašymas
	Šis metodas neturi parametrų.

def main():
    # Flash the Touch LED while the lift is spinning.
    lift_motor.spin_for(REVERSE, 600, DEGREES, wait=False)
    wait(0.1, SECONDS)
    while lift_motor.is_spinning():
        touchled.set_color(RED)
        wait(0.5, SECONDS)
        touchled.set_color(NONE)
        wait(0.5, SECONDS)

# VR threads — Do not delete
vr_thread(main)

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š dviejų galimų motorinių objektų, kaip parodyta toliau:

variklis	Komanda
`claw_motor`	`claw_motor.position(units)` — Nagų variklis
`lift_motor`	`lift_motor.position(units)` — Kėlimo variklis

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

def main():
    # Raise the lift until it reaches roughly 600 degrees.
    lift_motor.spin(REVERSE)
    while not lift_motor.position(DEGREES) <= -600:
        wait(2, MSEC)
    lift_motor.stop()
    drivetrain.drive_for(FORWARD, 140, MM)
    claw_motor.spin(FORWARD)

# 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š dviejų galimų motorinių objektų, kaip parodyta toliau:

variklis	Komanda
`claw_motor`	`claw_motor.velocity(units)` — Nagų variklis
`lift_motor`	`lift_motor.velocity(units)` — Kėlimo variklis

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

def main():
    # Print the lift velocity while it is moving.
    lift_motor.set_velocity(100, PERCENT)
    lift_motor.spin_for(REVERSE, 600, DEGREES, wait=False)
    wait(0.5, SECONDS)
    brain.screen.print(lift_motor.velocity(PERCENT))

# VR threads — Do not delete
vr_thread(main)

Dirbtinio intelekto vizija #

Getteriai #

fotografuoti_momentinę nuotrauką #

take_snapshot filtruoja duomenis iš IQ AI regėjimo jutiklio kadro į vieną parašą – išsaugotą aprašymą to, ką jutiklis gali atpažinti, pvz., žaidimo elementą lauke, – ir grąžina rinkinį.

Šiame rinkinyje objektai saugomi surūšiuoti nuo didžiausio iki mažiausio pagal plotį, pradedant nuo indekso 0. Kiekvieno objekto properties galima pasiekti naudojant jo indeksą. Jei nerandama atitinkamų objektų, grąžinama tuščia rinkinio reikšmė.

Usage:
ai_vision.take_snapshot(signature)

Parametrai	Aprašymas
`signature`	Filtruoja duomenų rinkinį, kad būtų įtraukti tik nurodyto parašo duomenys. Galimi parašai: `AiVision.ALL_AIOBJS` – Aptinka spindulius ir mėlynus, raudonus bei oranžinius kontaktus.

Parametrai

Aprašymas

signature

Filtruoja duomenų rinkinį, kad būtų įtraukti tik nurodyto parašo duomenys. Galimi parašai:

AiVision.ALL_AIOBJS – Aptinka spindulius ir mėlynus, raudonus bei oranžinius kontaktus.

def main():
    # Place the Red Pin on the top-left Blue Pin.
    lift_motor.spin_for(REVERSE, 600, DEGREES)
    drivetrain.turn_for(LEFT, 38, DEGREES)

    ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
    while not ai_objects[0].width > 48:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        drivetrain.drive(FORWARD)

    drivetrain.drive_for(FORWARD, 160, MM)
    claw_motor.spin(FORWARD)

# VR threads — Do not delete
vr_thread(main)

Ypatybės #

Kiekvienam objektui, saugomam rinkinyje po take_snapshot, panaudojimo, priskiriamos septynios savybės.

Visos ypatybių reikšmės, išskyrus .id apibūdina aptikto objekto padėtį ir dydį IQ AI regėjimo jutiklio rodinyje tuo metu, kai buvo naudojamas take_snapshot Šios reikšmės matuojamos pikseliais, remiantis jutiklio 320 x 240 pikselių skiriamąja geba.

.plotis #

.width grąžina aptikto objekto plotį pikseliais, kuris yra sveikasis skaičius nuo 1 iki 320.

def main():
    ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
    if len(ai_objects) > 0:
        brain.screen.print(ai_objects[0].width)

# VR threads — Do not delete
vr_thread(main)

.aukštis #

.height grąžina aptikto objekto aukštį pikseliais, kuris yra sveikasis skaičius nuo 1 iki 240.

def main():
    ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
    if len(ai_objects) > 0:
        brain.screen.print(ai_objects[0].height)

# VR threads — Do not delete
vr_thread(main)

.centerX #

.centerX grąžina aptikto objekto centro x koordinatę pikseliais, kuri yra sveikasis skaičius nuo 0 iki 320.

def main():
    ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
    if len(ai_objects) > 0:
        brain.screen.print(ai_objects[0].centerX)

# VR threads — Do not delete
vr_thread(main)

.centerY #

.centerY grąžina aptikto objekto centro y koordinatę pikseliais, kuri yra sveikasis skaičius nuo 0 iki 240.

def main():
    ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
    if len(ai_objects) > 0:
        brain.screen.print(ai_objects[0].centerY)

# VR threads — Do not delete
vr_thread(main)

.originX #

.originX grąžina aptikto objekto ribojančio langelio viršutinio kairiojo kampo x koordinatę pikseliais, kuri yra sveikasis skaičius nuo 0 iki 320.

def main():
    ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
    if len(ai_objects) > 0:
        brain.screen.print(ai_objects[0].originX)

# VR threads — Do not delete
vr_thread(main)

.originY #

.originY grąžina aptikto objekto ribojančio langelio viršutinio kairiojo kampo y koordinatę pikseliais, kurie yra sveikasis skaičius nuo 0 iki 240.

def main():
    ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
    if len(ai_objects) > 0:
        brain.screen.print(ai_objects[0].originY)

# VR threads — Do not delete
vr_thread(main)

.id #

.id grąžina aptiktos dirbtinio intelekto klasifikacijos ID kaip sveikąjį skaičių.

DI klasifikacija	id	Parašas
Spindulys	0	`GameElements.BEAM`
Mėlynas smeigtukas	1	`GameElements.BLUE_PIN`
Raudonas smeigtukas	2	`GameElements.RED_PIN`
Oranžinis smeigtukas	3	`GameElements.ORANGE_PIN`

def main():
    # Find the nearest Blue Pin in the current snapshot.
    lift_motor.spin_for(REVERSE, 600, DEGREES)
    object_count = 1
    ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)

    if len(ai_objects) > 0:
        for repeat_count in range(len(ai_objects)):
            if ai_objects[repeat_count].id == GameElements.BLUE_PIN:
                brain.screen.print(str("Closest Blue Pin is ") + str(object_count))
                break
            object_count = object_count + 1

# 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` Pusher Motor `pusher_motor.is_done` `pusher_motor.is_spinning` `pusher_motor.position` `pusher_motor.velocity` Arm Motor `arm_motor.is_done` `arm_motor.is_spinning` `arm_motor.position` `arm_motor.velocity` 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` GPS jutiklis `gps.position_mm` `gps.position_inches` `gps.heading` Stūmiklio sukimosi jutiklis `pusher_rotation.angle` `pusher_rotation.position` Dirbtinio intelekto vaizdo jutiklis `ai_vision.object_count` `ai_vision.height` `ai_vision.width` `ai_vision.centerX` `ai_vision.centerY` `ai_vision.originX` `ai_vision.originY` `ai_vision.id`

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
Pusher Motor
- pusher_motor.is_done
- pusher_motor.is_spinning
- pusher_motor.position
- pusher_motor.velocity
Arm Motor
- arm_motor.is_done
- arm_motor.is_spinning
- arm_motor.position
- arm_motor.velocity
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
GPS jutiklis
- gps.position_mm
- gps.position_inches
- gps.heading
Stūmiklio sukimosi jutiklis
- pusher_rotation.angle
- pusher_rotation.position
Dirbtinio intelekto vaizdo jutiklis
- ai_vision.object_count
- ai_vision.height
- ai_vision.width
- ai_vision.centerX
- ai_vision.centerY
- ai_vision.originX
- ai_vision.originY
- ai_vision.id

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 #

Jutiklinis šviesos diodas #

nustatyti_spalvą #

set_color nustato jutiklinio LED spalvą.

Usage:
touchled.set_color(color)

Parametrai	Aprašymas
`color`	Jutiklinio LED indikatoriaus spalva: `NONE` – Išjungia jutiklinį LED indikatorių `RED` `GREEN` `BLUE` `YELLOW` `ORANGE` `PURPLE` `WHITE` `RED_VIOLET` `VIOLET` `BLUE_VIOLET` `BLUE_GREEN` `YELLOW_GREEN` `YELLOW_ORANGE` `RED_ORANGE`

Parametrai

Aprašymas

color

Jutiklinio LED indikatoriaus spalva:

NONE – Išjungia jutiklinį LED indikatorių
RED
GREEN
BLUE
YELLOW
ORANGE
PURPLE
WHITE
RED_VIOLET
VIOLET
BLUE_VIOLET
BLUE_GREEN
YELLOW_GREEN
YELLOW_ORANGE
RED_ORANGE

def main():
    # Light the Touch LED while placing a Pin.
    touchled.set_color(RED)
    lift_motor.spin_for(REVERSE, 600, DEGREES)
    drivetrain.drive_for(FORWARD, 140, MM)
    claw_motor.spin(FORWARD)
    touchled.set_color(NONE)

# VR threads — Do not delete
vr_thread(main)

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ų.

def main():
    # Wait until the claw no longer detects an object, then lower the lift.
    lift_motor.spin_for(REVERSE, 600, DEGREES)
    drivetrain.drive_for(FORWARD, 140, MM)
    claw_motor.spin(FORWARD)
    while optical.is_near_object():
        wait(2, MSEC)
    lift_motor.spin_to_position(0, 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:
optical.color()

Parametrai	Aprašymas
	Šis metodas neturi parametrų.

def main():
    # Wait until the Optical Sensor detects red, then lower the lift.
    lift_motor.spin_for(REVERSE, 600, DEGREES)
    drivetrain.drive_for(FORWARD, 140, MM)
    claw_motor.spin(FORWARD)
    while not optical.color() == RED:
        wait(5, MSEC)
    lift_motor.spin_to_position(0, 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:
optical.brightness()

Parametrai	Aprašymas
	Šis metodas neturi parametrų.

def main():
    # Lower the lift once the claw sees a darker object.
    lift_motor.spin_for(REVERSE, 600, DEGREES)
    drivetrain.drive_for(FORWARD, 140, MM)
    claw_motor.spin(FORWARD)
    while not 30 > optical.brightness():
        wait(5, MSEC)
    lift_motor.spin_to_position(0, 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:
optical.hue()

Parametrai	Aprašymas
	Šis metodas neturi parametrų.

def main():
    # Lower the lift once the Optical Sensor reports a hue value.
    lift_motor.spin_for(REVERSE, 600, DEGREES)
    drivetrain.drive_for(FORWARD, 140, MM)
    claw_motor.spin(FORWARD)
    while not optical.hue() > 0:
        wait(5, MSEC)
    lift_motor.spin_to_position(0, 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:
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 pin_in_claw():
    touchled.set_color(RED)

def main():
    # Change the Touch LED color when the claw detects an object.
    optical.object_detected(pin_in_claw)
    touchled.set_color(GREEN)
    lift_motor.spin_for(REVERSE, 600, DEGREES)
    drivetrain.drive_for(FORWARD, 140, MM)
    claw_motor.spin(FORWARD)

# 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:
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_lift():
    # Lower the lift when the claw no longer holds an object.
    lift_motor.spin_to_position(0, DEGREES)

def main():
    optical.object_lost(lower_lift)
    lift_motor.spin_for(REVERSE, 600, DEGREES)
    drivetrain.drive_for(FORWARD, 140, MM)
    claw_motor.spin(FORWARD)

# VR threads — Do not delete
vr_thread(main)