Python specyficzny dla robotów#

Wstęp #

Bohater Bot, Dex, ma dwa rodzaje silników: czujnik wizyjny AI, czujnik optyczny i czujnik systemu pozycjonowania gry (GPS).

Wszystkie standardowe metody VEXcode VR są dostępne do użycia na placu zabaw V5 25-26 Push Back.

Poniżej znajduje się lista wszystkich dostępnych metod specyficznych dla robotów:

Układ napędowy – poruszanie i obracanie robotem.

Akcje
- drive — Przesuwa robota do przodu lub do tyłu w nieskończoność.
- drive_for — Przesuwa robota do przodu lub do tyłu na określoną odległość.
- turn — Obraca robota w lewo lub prawo na zawsze.
- turn_for — Obraca robota w lewo lub prawo o określoną liczbę stopni.
- turn_to_heading — Obraca robota w kierunku określonego kierunku od -359 do 359 stopni.
- turn_to_rotation — Obraca robota o określoną wartość.
- stop — Zatrzymuje ruch robota.
Mutatory
- set_heading — Zmienia aktualny kierunek robota na nowy kierunek.
- set_rotation — Zmienia aktualny obrót robota na nowy obrót.
- set_timeout — Ustawia, ile czasu robot będzie próbował zakończyć ruch.
- set_drive_velocity — Informuje robota, z jaką prędkością ma jechać.
- set_turn_velocity — Informuje robota, jak szybko ma skręcić.
Getterzy
- heading — Zwraca aktualny kierunek robota od 0 do 359,99 stopni.
- rotation — Zwraca aktualny obrót robota.
- is_done — Zwraca wartość logiczną informującą, czy robot zakończył ruch.
- is_moving — Zwraca wartość logiczną informującą, czy robot się porusza.
- velocity — Zwraca prędkość, z jaką porusza się robot.

Ruch – poruszaj i śledź silniki robota.

Akcje
- spin — Obraca silnik do przodu lub do tyłu w nieskończoność.
- spin_for — Obraca silnik na określoną odległość.
- spin_to_position — Obraca silnik do określonej pozycji.
- stop — Zatrzymuje silnik przed wirowaniem.
Mutatory
- set_position — Zmienia aktualną pozycję silnika na nową wartość.
- set_velocity — Informuje silnik, jak szybko ma się kręcić.
- set_timeout — Ustawia, ile czasu silnik będzie próbował zakończyć ruch.
Getterzy
- is_done — Zwraca wartość logiczną, czy silnik zakończył ruch.
- is_spinning — Zwraca wartość logiczną, czy silnik się kręci.
- position — Zwraca aktualną pozycję silnika.
- velocity — Zwraca prędkość, z jaką obraca się silnik.

Wizja AI — przechwytywanie i analiza obiektów za pomocą czujnika wizji AI.

Getterzy
- take_snapshot – Zwraca krotkę wykrytych obiektów dla określonego podpisu.
Właściwości
- width – Szerokość wykrytego obiektu w pikselach.
- height – Wysokość wykrytego obiektu w pikselach.
- centerX – Pozycja X środka obiektu w pikselach.
- centerY – Pozycja Y środka obiektu w pikselach.
- originX – Pozycja X lewego górnego rogu obiektu w pikselach.
- originY – Pozycja Y lewego górnego rogu obiektu w pikselach.
- id – Klasyfikacja lub identyfikator tagu obiektu.

Konsola – Drukuj do konsoli i monitoruj wartości.

Wydrukować
- brain.screen.print — Wyświetla tekst, liczby lub wartości zmiennych w konsoli.
- brain.screen.next_row — Przesuwa kursor konsoli na początek następnego wiersza.
- brain.screen.clear_screen — Czyści wszystkie wiersze z konsoli.
Monitor
- monitor_variable — Dodaje jedną lub więcej predefiniowanych zmiennych do karty Monitor.
- monitor_sensor — Dodaje jedną lub więcej wartości czujnika do karty Monitor.

Czuwanie — wykorzystanie różnych czujników robota.

Optyczny
- is_near_object – Zwraca informację, czy czujnik optyczny wykrył obiekt w zasięgu.
- color – Zwraca kolor wykryty przez czujnik optyczny.
- brightness – Zwraca ilość światła odbitego od obiektu.
- hue – Zwraca odcień wykryty przez czujnik optyczny.
- object_detected – Rejestruje funkcję, która ma zostać wywołana, gdy czujnik optyczny wykryje obiekt.
- object_lost – Rejestruje funkcję, która ma zostać wywołana, gdy czujnik optyczny utraci obiekt.
GPS
- x_position – Zwraca aktualną współrzędną x czujnika GPS na polu.
- y_position – Zwraca aktualną współrzędną y czujnika GPS na polu.
- heading – Zwraca kierunek, w którym aktualnie skierowany jest robot, na podstawie odczytów czujnika GPS w zakresie od 0 do 359 stopni.

Przykłady na tej stronie wykorzystują domyślną pozycję startową placu zabaw.

Układ napędowy #

Układ napędowy kontroluje sposób jazdy i skręcania robota VR. Układ napędowy może poruszać się do przodu i do tyłu, skręcać w lewo i w prawo, zmieniać kierunki i śledzić swój obrót.

Akcje #

prowadzić #

Napęd drive porusza robota do przodu lub do tyłu w nieskończoność. Robot będzie się poruszał, dopóki nie otrzyma innej akcji, takiej jak obrót lub zatrzymanie.

Usage:
drivetrain.drive(direction)

Parametry	Opis
`direction`	Kierunek, w którym porusza się robot: `FORWARD` lub `REVERSE`.

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

# VR threads — Do not delete
vr_thread(main)

drive_for #

drive_for przesuwa robota do przodu lub do tyłu o określoną odległość. Projekt będzie czekał, aż robot zakończy ruch, zanim uruchomi się kolejny wiersz kodu.

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

Parametry	Opis
`direction`	Kierunek, w którym porusza się robot: `FORWARD` lub `REVERSE`.
`distance`	Odległość pokonywana przez robota. Może to być liczba całkowita `integer` lub liczba dziesiętna (`float`).
`units`	Opcjonalnie. Jednostka odległości: `INCHES` (domyślnie) lub `MM` (milimetry).
`wait`	Opcjonalnie. `wait=True` (domyślnie) powoduje, że projekt czeka, aż robot zakończy ruch, zanim zostanie wykonany kolejny wiersz kodu. `wait=False` powoduje, że następny wiersz kodu zostanie wykonany natychmiast.

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)

zakręt #

turn obraca robota w lewo lub w prawo w nieskończoność. Robot będzie się obracał, dopóki nie zostanie mu przydzielona inna czynność, taka jak jazda lub zatrzymanie.

Usage:
drivetrain.turn(direction)

Parametry	Opis
`direction`	Kierunek, w którym obraca się robot: `LEFT` lub `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 obraca robota w lewo lub w prawo o określoną liczbę stopni. Obrót jest względny do aktualnej pozycji robota. Projekt będzie czekał, aż robot zakończy obrót, zanim uruchomi się kolejny wiersz kodu.

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

Parametry	Opis
`direction`	Kierunek, w którym obraca się robot: `LEFT` lub `RIGHT`.
`angle`	Liczba stopni, o jaką obróci się robot. Może to być liczba całkowita `integer` lub liczba dziesiętna (`float`).
`units`	Opcjonalnie. Jednostka obrotu: `DEGREES` (domyślnie).
`wait`	Opcjonalnie. `wait=True` (domyślnie) powoduje, że projekt czeka, aż robot skończy się obracać, zanim zostanie wykonany kolejny wiersz kodu. `wait=False` powoduje, że następny wiersz kodu zostanie wykonany natychmiast.

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)

skręć_do_nagłówka #

Kurs to kierunek, w którym zwrócony jest robot, mierzony w stopniach. turn_to_heading obraca robota w określonym kierunku od -359 do 359 stopni. Robot obróci się w najkrótszym kierunku, aby osiągnąć docelowy kurs.

Początkowy kierunek robota wynosi 0 stopni.

Projekt będzie czekał, aż robot zakończy obracanie się, zanim zostanie uruchomiony kolejny wiersz kodu.

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

Parametry	Opis
`angle`	Kierunek, w którym robot powinien być zwrócony, wyrażony w stopniach. Może to być liczba całkowita `integer` lub liczba dziesiętna (`float`) z zakresu od -359 do 359.
`units`	Opcjonalnie. Jednostka obrotu: `DEGREES` (domyślnie).
`wait`	Opcjonalnie. `wait=True` (domyślnie) powoduje, że projekt czeka, aż robot skończy się obracać, zanim zostanie wykonany kolejny wiersz kodu. `wait=False` powoduje, że następny wiersz kodu zostanie wykonany natychmiast.

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)

obrót_do_obrotu #

turn_to_rotation obraca robota o określoną wartość.

Obrót to wartość obrotu robota, mierzona w stopniach. Na początku projektu wartość obrotu jest ustawiona na 0 stopni. Obrót można również ustawić za pomocą metody set_rotation.

Wartości obrotu są bezwzględne. Oznacza to, że kierunek obrotu zależy od aktualnego obrotu robota. Skręt w prawo zwiększa obrót, a w lewo zmniejsza.

Na przykład, jeśli robot zaczyna od 0 stopni i obrócisz go o 720 stopni, skręci w prawo dwa razy. Jeśli następnie obrócisz go o 360 stopni, skręci raz w lewo, ponieważ 360 stopni to mniej niż 720.

Projekt będzie czekał, aż robot zakończy obracanie się, zanim zostanie uruchomiony kolejny wiersz kodu.

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

Parametry	Opis
`angle`	Wartość obrotu, w stopniach, o którą obróci się robot. Może to być `integer` lub liczba dziesiętna (`float`).
`units`	Opcjonalnie. Jednostka obrotu: `DEGREES` (domyślnie).
`wait`	Opcjonalnie. `wait=True` (domyślnie) powoduje, że projekt czeka, aż robot skończy się obracać, zanim zostanie wykonany kolejny wiersz kodu. `wait=False` powoduje, że następny wiersz kodu zostanie wykonany natychmiast.

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)

zatrzymywać się #

stop zatrzymuje ruch robota.

Usage:
drivetrain.stop()

Parametry	Opis
	Ta metoda nie ma żadnych parametrów.

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

# VR threads — Do not delete
vr_thread(main)

Mutatory #

ustaw_nagłówek #

Kierunek to kierunek, w którym zwrócony jest robot, mierzony w stopniach. set_heading zmienia bieżący kierunek robota na nową wartość kierunku.

Na przykład, jeśli robot obrócił się w prawo, ustawienie kierunku na 0 stopni spowoduje, że ta pozycja skierowana w prawo stanie się nowym 0 stopniem. Następnie robot może obrócić się w inne pozycje w oparciu o ten nowy kierunek.

Usage:
drivetrain.set_heading(heading, units)

Parametry	Opis
`heading`	Wartość nagłówka (w stopniach), którą należy ustawić dla robota. Może to być `integer` lub liczba dziesiętna (`float`).
`units`	Opcjonalnie. Jednostka nagłówka: `DEGREES` (domyślna).

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)

ustaw_rotację #

Obrót to wartość obrotu robota, mierzona w stopniach. Na początku projektu wartość obrotu jest ustawiona na 0 stopni. set_rotation zmienia bieżący obrót robota na nową wartość.

Na przykład, jeśli robot wykonał dwa pełne obroty w prawo, jego wartość obrotu wyniesie 720 stopni. Ustawienie obrotu na 0 stopni zresetuje ten obrót z 720 do 0 stopni. Następnie robot może wykonać obrót w oparciu o tę nową wartość.

Usage:
drivetrain.set_rotation(rotation, units)

Parametry	Opis
`rotation`	Wartość obrotu w stopniach, którą należy ustawić dla robota. Może to być `integer` lub liczba dziesiętna (`float`).
`units`	Opcjonalnie. Jednostka obrotu: `DEGREES` (domyślnie).

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)

ustaw_limit_czasu #

set_timeout ustawia, ile czasu robot będzie próbował ukończyć ruch. Jeśli robot nie zdoła ukończyć ruchu w tym czasie, przerwie próby i przejdzie do następnego wiersza kodu. Zapobiega to zablokowaniu ruchu przez robota.

Usage:
drivetrain.set_timeout(value, units)

Parametry	Opis
`value`	Czas, w którym robot może próbować zakończyć ruch. Może to być dodatnia liczba całkowita `integer` lub liczba dziesiętna (`float`).
`units`	Jednostka czasu: `SECONDS` lub `MSEC` (milisekundy).

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)

ustaw_prędkość_napędu #

set_drive_velocity określa prędkość, z jaką robot ma jechać. Wyższy procent powoduje, że robot jedzie szybciej, a niższy – że jedzie wolniej.

Każdy projekt rozpoczyna się od tego, że robot domyślnie porusza się z prędkością równą 50%.

Uwaga: Większa prędkość sprawia, że robot jedzie szybciej, ale może być mniej precyzyjny. Niższa prędkość sprawia, że robot jedzie wolniej, ale może być bardziej precyzyjny.

Usage:
drivetrain.set_drive_velocity(velocity, units)

Parametry	Opis
`velocity`	Prędkość jazdy od 0% do 100%. Może to być liczba całkowita `integer` lub liczba dziesiętna (`float`).
`units`	Opcjonalnie. Jednostka prędkości: `PERCENT` (domyślnie).

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)

ustaw_prędkość_obrotu #

set_turn_velocity określa, jak szybko robot ma się skręcić. Wyższy procent powoduje, że robot skręca szybciej, a niższy – że skręca wolniej.

Każdy projekt rozpoczyna się od ustawienia robota tak, aby domyślnie obracał się z prędkością równą 50%.

Uwaga: Większa prędkość sprawia, że robot skręca szybciej, ale może być mniej precyzyjny. Niższa prędkość sprawia, że robot skręca wolniej, ale może być bardziej precyzyjny.

Usage:
drivetrain.set_turn_velocity(velocity, units)

Parametry	Opis
`velocity`	Prędkość obrotu od 0% do 100%. Może to być liczba całkowita `integer` lub liczba dziesiętna (`float`).
`units`	Opcjonalnie. Jednostka prędkości: `PERCENT` (domyślnie).

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)

Getters #

nagłówek #

Kurs to kierunek, w którym zwrócony jest robot, mierzony w stopniach. heading zwraca aktualny kurs robota z zakresu od 0 do 359,99 stopnia.

Początkowy kierunek robota wynosi 0 stopni.

Usage:
drivetrain.heading(units)

Parametry	Opis
`units`	Opcjonalnie. Jednostka nagłówka: `DEGREES` (domyślna).

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)

obrót #

Obrót to wartość obrotu robota, mierzona w stopniach. Na początku projektu wartość obrotu jest ustawiona na 0 stopni. rotation zwraca aktualny obrót robota.

Skręt w prawo zwiększa obrót, a skręt w lewo zmniejsza. Na przykład, wykonanie dwóch pełnych obrotów w prawo spowoduje obrót o 720 stopni.

Usage:
drivetrain.rotation(units)

Parametry	Opis
`units`	Opcjonalnie. Jednostka obrotu: `DEGREES` (domyślnie).

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)

jest_zrobione #

is_done zwraca wartość logiczną, czy robot zakończył ruch. Można jej użyć do kontrolowania czasu innych zachowań na podstawie ruchu robota.

True — Robot zakończył ruch.
False — Robot nadal się porusza.

Ta metoda działa razem z następującymi metodami Drivetrain, które mają parametr wait wait : drive_for, turn_for, turn_to_heading i turn_to_rotation.

Usage:
drivetrain.is_done()

Parametry	Opis
	Ta metoda nie ma żadnych parametrów.

jest_poruszający się #

is_moving zwraca wartość logiczną, czy robot się porusza. Można jej użyć do kontrolowania czasu innych zachowań na podstawie ruchu robota.

True — Robot się porusza.
False — Robot się nie porusza.

Usage:
drivetrain.is_moving()

Parametry	Opis
	Ta metoda nie ma żadnych parametrów.

prędkość #

velocity zwraca prędkość, z jaką porusza się robot, w procentach od -100% do 100%.

Usage:
drivetrain.velocity(units)

Parametry	Opis
`units`	Opcjonalnie. Jednostka prędkości: `PERCENT` (domyślnie).

Przykład

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

Ruch #

Dex używa silnika wlotowego do wciągania bloków do robota. Silnik przenośnika przesuwa bloki z wlotu na górę robota, aby można je było wepchnąć do celu.

Każdy silnik ma swoje własne zachowanie kierunkowe. Opisy kierunków wyjaśniają, jak każdy kierunek porusza dany silnik na Dex.

Akcje #

kręcić się #

spin obraca silnik do przodu lub do tyłu w nieskończoność. Silnik będzie się obracał, dopóki nie zostanie mu przydzielona inna czynność, np. obrót w innym kierunku lub zatrzymanie.

Zastosowanie:
Z tą metodą można używać jednego z dwóch dostępnych obiektów silnikowych, jak pokazano poniżej:

silnik	Rozkaz
`intake_motor`	`intake_motor.spin(direction)` — Silnik dolotowy
`conveyor_motor`	`conveyor_motor.spin(direction)` — Silnik przenośnika

Parametry

Opis

direction

Kierunek, w którym obraca się silnik:

FORWARD — Obraca silnik przenośnika w górę lub obraca silnik wlotowy w kierunku wlotu.
REVERSE — Obraca silnik przenośnika w dół lub obraca silnik wlotowy w kierunku wylotu.

def main():
    # Pick up a second Block
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 350, MM)

# VR threads — Do not delete
vr_thread(main)

spin_for #

spin_for obraca silnik na określoną odległość. Obrót jest względny do aktualnej pozycji silnika. Projekt będzie czekał, aż silnik zakończy obrót, zanim uruchomi się kolejny wiersz kodu.

Zastosowanie:
Z tą metodą można używać jednego z dwóch dostępnych obiektów silnikowych, jak pokazano poniżej:

silnik	Rozkaz
`intake_motor`	`intake_motor.spin_for(direction, distance, units, wait)` — Silnik dolotowy
`conveyor_motor`	`conveyor_motor.spin_for(direction, distance, units, wait)` — Silnik przenośnika

Parametry	Opis
`direction`	Kierunek, w którym obraca się silnik: `FORWARD` — Obraca silnik przenośnika w górę lub obraca silnik wlotowy w kierunku wlotu. `REVERSE` — Obraca silnik przenośnika w dół lub obraca silnik wlotowy w kierunku wylotu.
`distance`	Odległość, na jaką obraca się silnik. `DEGREES` używa liczb całkowitych. `TURNS` może używać liczb całkowitych lub dziesiętnych.
`units`	Opcjonalnie. Jednostka odległości: `DEGREES` (domyślna) lub `TURNS`.
`wait`	Opcjonalnie. `wait=True` (domyślnie) — powoduje, że projekt czeka, aż silnik zakończy pracę, zanim zostanie wykonany kolejny wiersz kodu. `wait=False` — powoduje, że kolejny wiersz kodu zostanie wykonany natychmiast.

def main():
    # Pick up a second Block
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 350, MM)

# VR threads — Do not delete
vr_thread(main)

obrót_do_pozycji #

spin_to_position obraca silnik do określonej pozycji.

Pozycja silnika to odległość, o jaką się obrócił, mierzona w DEGREES lub TURNS. Jeden obrót to 360 stopni. Na początku projektu położenie silnika jest ustawione na 0 stopni. Położenie silnika można również ustawić za pomocą metody set_position.

Wartości położenia są bezwzględne. Oznacza to, że kierunek obrotu zależy od aktualnego położenia silnika.

Na przykład, jeśli silnik zaczyna od 0 stopni i obraca się do pozycji 720 stopni, wykona dwa obroty do przodu. Jeśli następnie obraca się do pozycji 360 stopni, wykona jeden obrót do tyłu, ponieważ 360 stopni jest mniejsze niż 720 stopni.

Zastosowanie:
Z tą metodą można używać jednego z dwóch dostępnych obiektów silnikowych, jak pokazano poniżej:

silnik	Rozkaz
`intake_motor`	`intake_motor.spin_to_position(angle, units, wait=True)` — Silnik dolotowy
`conveyor_motor`	`conveyor_motor.spin_to_position(angle, units, wait=True)` — Silnik przenośnika

Parametry	Opis
`angle`	Wartość pozycji, do której silnik będzie się obracał. `DEGREES` używa liczb całkowitych. `TURNS` może używać liczb całkowitych lub dziesiętnych.
`units`	Opcjonalnie. Jednostka pozycji: `DEGREES` (domyślnie) lub `TURNS`.
`wait`	Opcjonalnie. `wait=True` (domyślnie) — powoduje, że projekt czeka, aż silnik zakończy pracę, zanim zostanie wykonany kolejny wiersz kodu. `wait=False` — powoduje, że kolejny wiersz kodu zostanie wykonany natychmiast.

Parametry

Opis

angle

Wartość pozycji, do której silnik będzie się obracał. DEGREES używa liczb całkowitych. TURNS może używać liczb całkowitych lub dziesiętnych.

units

Opcjonalnie. Jednostka pozycji: DEGREES (domyślnie) lub TURNS.

wait

Opcjonalnie.

wait=True (domyślnie) — powoduje, że projekt czeka, aż silnik zakończy pracę, zanim zostanie wykonany kolejny wiersz kodu.
wait=False — powoduje, że kolejny wiersz kodu zostanie wykonany natychmiast.

def main():
    # Pick up a second Block
    conveyor_motor.spin_to_position(150, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 350, MM)

# VR threads — Do not delete
vr_thread(main)

zatrzymywać się #

stop zatrzymuje silnik i uniemożliwia jego obrót.

Zastosowanie:
Z tą metodą można używać jednego z dwóch dostępnych obiektów silnikowych, jak pokazano poniżej:

silnik	Rozkaz
`intake_motor`	`intake_motor.stop()` — Silnik dolotowy
`conveyor_motor`	`conveyor_motor.stop()` — Silnik przenośnika

Parametry	Opis
	Ta metoda nie ma żadnych parametrów.

def main():
    # Pick up a second Block
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 350, MM)
    intake_motor.stop()

# VR threads — Do not delete
vr_thread(main)

Mutatory #

ustaw_pozycję #

Pozycja silnika to odległość, o jaką się obrócił, mierzona w DEGREES lub TURNS. Jeden obrót jest równy 360 stopniom. set_position zmienia bieżącą pozycję silnika na nową wartość.

Na przykład, jeśli silnik obrócił się o 180 stopni, ustawienie pozycji na 0 stopni spowoduje zresetowanie tej pozycji ze 180 do 0 stopni. Następnie silnik może obracać się do pozycji opartych na tej nowej wartości.

Zastosowanie:
Z tą metodą można używać jednego z dwóch dostępnych obiektów silnikowych, jak pokazano poniżej:

silnik	Rozkaz
`intake_motor`	`intake_motor.set_position(position, units)` — Silnik dolotowy
`conveyor_motor`	`conveyor_motor.set_position(position, units)` — Silnik przenośnika

Parametry	Opis
`position`	Wartość pozycji do ustawienia dla silnika. `DEGREES` używa liczb całkowitych. `TURNS` może używać liczb całkowitych lub dziesiętnych.
`units`	Opcjonalnie. Jednostka pozycji: `DEGREES` (domyślnie) lub `TURNS`.

def main():
    # Pick up a second Block
    conveyor_motor.set_position(-150, DEGREES)
    conveyor_motor.spin_to_position(0, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 350, MM)

# VR threads — Do not delete
vr_thread(main)

ustaw_prędkość #

set_velocity określa prędkość obrotową silnika. Wyższy procent powoduje, że silnik obraca się szybciej, a niższy – wolniej.

Każdy projekt rozpoczyna się od ustawienia silników tak, aby domyślnie kręciły się z prędkością 50%.

Uwaga: Wyższa prędkość sprawia, że silnik obraca się szybciej, ale może być mniej precyzyjny. Niższa prędkość sprawia, że silnik obraca się wolniej, ale może być bardziej precyzyjny.

Zastosowanie:
Z tą metodą można używać jednego z dwóch dostępnych obiektów silnikowych, jak pokazano poniżej:

silnik	Rozkaz
`intake_motor`	`intake_motor.set_velocity(velocity, units)` — Silnik dolotowy
`conveyor_motor`	`conveyor_motor.set_velocity(velocity, units)` — Silnik przenośnika

Parametry	Opis
`velocity`	Prędkość wirowania od 0% do 100%. Może to być liczba całkowita `integer` lub liczba dziesiętna (`float`).
`units`	Jednostka prędkości: `PERCENT`.

def main():
    # Pick up a second Block
    conveyor_motor.set_velocity(90, PERCENT)
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 400, MM)

# VR threads — Do not delete
vr_thread(main)

ustaw_limit_czasu #

set_timeout ustawia, ile czasu silnik będzie próbował zakończyć ruch. Jeśli silnik nie zdoła zakończyć ruchu w tym czasie, przerwie próby i przejdzie do następnego wiersza kodu. Zapobiega to zablokowaniu silnika podczas ruchu.

Zastosowanie:
Z tą metodą można używać jednego z dwóch dostępnych obiektów silnikowych, jak pokazano poniżej:

silnik	Rozkaz
`intake_motor`	`intake_motor.set_timeout(value, units)` — Silnik dolotowy
`conveyor_motor`	`conveyor_motor.set_timeout(value, units)` — Silnik przenośnika

Parametry	Opis
`value`	Czas, przez jaki silnik może próbować zakończyć ruch. Może to być dodatnia liczba całkowita `integer` lub liczba dziesiętna (`float`).
`units`	Jednostka czasu: `SECONDS` lub `MSEC` (milisekundy).

def main():
    # Pick up a second Block
    conveyor_motor.set_timeout(0.5, SECONDS)
    conveyor_motor.spin_to_position(1000, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 400, MM)

# VR threads — Do not delete
vr_thread(main)

Getters #

jest_zrobione #

is_done zwraca wartość logiczną, czy silnik zakończył ruch. Można jej użyć do sterowania czasem innych zachowań na podstawie ruchu silnika.

True — Silnik zakończył ruch.
False — Silnik nadal się porusza.

Ta metoda działa w połączeniu z następującymi metodami Motion, które mają parametr wait wait : spin_for i spin_to_position.

Zastosowanie:
Z tą metodą można używać jednego z dwóch dostępnych obiektów silnikowych, jak pokazano poniżej:

silnik	Rozkaz
`intake_motor`	`intake_motor.is_done()` — Silnik dolotowy
`conveyor_motor`	`conveyor_motor.is_done()` — Silnik przenośnika

Parametry	Opis
	Ta metoda nie ma żadnych parametrów.

def main():
    # Pick up a second Block
    conveyor_motor.spin_to_position(300, DEGREES, wait=False)
    wait(0.1, SECONDS)
    while not conveyor_motor.is_done():
        drivetrain.drive(FORWARD)
        intake_motor.spin(FORWARD)
        wait(5, MSEC)
    drivetrain.stop()
    intake_motor.stop()

# VR threads — Do not delete
vr_thread(main)

kręci się #

is_spinning zwraca wartość logiczną, czy silnik się obraca. Można jej użyć do sterowania czasem innych zachowań na podstawie ruchu silnika.

True — Silnik się kręci.
False — Silnik się nie obraca.

Ta metoda działa w połączeniu z następującymi metodami Motion, które mają parametr wait wait : spin_for i spin_to_position.

Zastosowanie:
Z tą metodą można używać jednego z dwóch dostępnych obiektów silnikowych, jak pokazano poniżej:

silnik	Rozkaz
`intake_motor`	`intake_motor.is_spinning()` — Silnik dolotowy
`conveyor_motor`	`conveyor_motor.is_spinning()` — Silnik przenośnika

Parametry	Opis
	Ta metoda nie ma żadnych parametrów.

def main():
    # Pick up a second Block
    conveyor_motor.spin_to_position(300, DEGREES, wait=False)
    wait(0.1, SECONDS)
    while conveyor_motor.is_spinning():
        drivetrain.drive_for(FORWARD, 200, MM)
        intake_motor.spin(FORWARD)

# VR threads — Do not delete
vr_thread(main)

pozycja #

Pozycja silnika to odległość, na jaką wykonał obrót, mierzona w DEGREES lub TURNS. Jeden obrót jest równy 360 stopniom. position zwraca aktualną pozycję silnika.

Na początku projektu położenie silnika jest ustawione na 0 stopni. Jeśli silnik wykona jeden pełny obrót do przodu, położenie będzie wynosić 360 stopni, czyli 1 obrót. Jeśli silnik obróci się w przeciwnym kierunku, położenie będzie ujemne.

Zastosowanie:
Z tą metodą można używać jednego z dwóch dostępnych obiektów silnikowych, jak pokazano poniżej:

silnik	Rozkaz
`intake_motor`	`intake_motor.position(units)` — Silnik dolotowy
`conveyor_motor`	`conveyor_motor.position(units)` — Silnik przenośnika

Parametry	Opis
`units`	Jednostka przywracająca położenie silnika w zakresie: `DEGREES` lub `TURNS`.

def main():
    # Pick up a second Block
    while conveyor_motor.position(DEGREES) < 150:
        conveyor_motor.spin(FORWARD)
        wait(2, MSEC)
    conveyor_motor.stop()
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 400, MM)

# VR threads — Do not delete
vr_thread(main)

prędkość #

velocity zwraca informację o tym, jak szybko obraca się silnik.

Wartość dodatnia oznacza, że silnik obraca się do przodu. Wartość ujemna oznacza, że silnik obraca się do tyłu.

Zastosowanie:
Z tą metodą można używać jednego z dwóch dostępnych obiektów silnikowych, jak pokazano poniżej:

silnik	Rozkaz
`intake_motor`	`intake_motor.velocity(units)` — Silnik dolotowy
`conveyor_motor`	`conveyor_motor.velocity(units)` — Silnik przenośnika

Parametry	Opis
`units`	Jednostka prędkości do zwrotu: `PERCENT`.

def main():
    # Pick up a second block
    conveyor_motor.set_velocity(100, PERCENT)
    conveyor_motor.spin_to_position(300, DEGREES, wait=False)
    wait(0.2, SECONDS)
    brain.screen.print(conveyor_motor.velocity(PERCENT))
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 400, MM)

# VR threads — Do not delete
vr_thread(main)

Wizja AI #

Getters #

zrób migawkę #

take_snapshot filtruje dane z ramki czujnika AI Vision do pojedynczego podpisu — zapisanego opisu czegoś, co czujnik może rozpoznać, na przykład elementu gry na boisku — i zwraca krotkę.

Krotka przechowuje obiekty uporządkowane od największego do najmniejszego według szerokości, zaczynając od indeksu 0. Dostęp do właściwości każdego obiektu jest możliwy za pomocą jego indeksu. Jeśli nie zostaną wykryte żadne pasujące obiekty, zwracana jest pusta krotka.

Usage:
ai_vision.take_snapshot(signature)

Parametry	Opis
`signature`	Filtruje zbiór danych, aby zawierał tylko dane o podanym podpisie. Dostępne podpisy to: `AiVision.ALL_AIOBJS` – Wykrywa czerwone i niebieskie bloki.

Parametry

Opis

signature

Filtruje zbiór danych, aby zawierał tylko dane o podanym podpisie. Dostępne podpisy to:

AiVision.ALL_AIOBJS – Wykrywa czerwone i niebieskie bloki.

def main():
    # If an object is detected, pick it up
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            intake_motor.spin(FORWARD)
            drivetrain.drive(FORWARD)
            while not bumper.pressing():
                wait(2, MSEC)
            drivetrain.stop()
            break

# VR threads — Do not delete
vr_thread(main)

Właściwości #

Każdy obiekt przechowywany w krotce zawiera siedem właściwości po użyciu take_snapshot.

Wszystkie wartości właściwości z wyjątkiem .id opisują położenie i rozmiar wykrytego obiektu w polu widzenia czujnika AI Vision w momencie użycia polecenia take_snapshot Wartości te są mierzone w pikselach, w oparciu o rozdzielczość czujnika wynoszącą 320 na 240 pikseli.

.szerokość #

.width zwraca szerokość wykrytego obiektu w pikselach, która jest liczbą całkowitą z przedziału od 1 do 320.

def main():
    # If an object is detected, approach and pick it up
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].width > 65:
                drivetrain.stop()
                break
            else:
                intake_motor.spin(FORWARD)
                drivetrain.drive(FORWARD)

# VR threads — Do not delete
vr_thread(main)

.wysokość #

.height zwraca wysokość wykrytego obiektu w pikselach, która jest liczbą całkowitą z przedziału od 1 do 240.

def main():
    # If an object is detected, approach and pick it up
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].height > 55:
                drivetrain.stop()
                break
            else:
                intake_motor.spin(FORWARD)
                drivetrain.drive(FORWARD)

# VR threads — Do not delete
vr_thread(main)

.centerX #

.centerX zwraca współrzędną x środka wykrytego obiektu w pikselach, która jest liczbą całkowitą z przedziału od 0 do 320.

def main():
    # Pick up a Block from the top left group
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    drivetrain.turn_for(LEFT, 80, DEGREES)
    drivetrain.drive_for(FORWARD, 200, MM)
    drivetrain.set_turn_velocity(20, PERCENT)
    drivetrain.turn(LEFT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if 140 < ai_objects[0].centerX < 180:
                intake_motor.spin(FORWARD)
                drivetrain.drive(FORWARD)
                while not bumper.pressing():
                    wait(2, MSEC)
                drivetrain.stop()

# VR threads — Do not delete
vr_thread(main)

.centerY #

.centerY zwraca współrzędną y środka wykrytego obiektu w pikselach, która jest liczbą całkowitą z przedziału od 0 do 240.

def main():
    # If an object is detected, approach and pick it up
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].centerY > 140:
                drivetrain.stop()
                break
            else:
                intake_motor.spin(FORWARD)
                drivetrain.drive(FORWARD)

# VR threads — Do not delete
vr_thread(main)

.originX #

.originX zwraca współrzędną x lewego górnego rogu ograniczającego pole wykrytego obiektu w pikselach. Jest to liczba całkowita z przedziału od 0 do 320.

def main():
    # Pick up a Block from the top left group
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    drivetrain.turn_for(LEFT, 80, DEGREES)
    drivetrain.drive_for(FORWARD, 300, MM)
    drivetrain.set_turn_velocity(20, PERCENT)
    drivetrain.turn(RIGHT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if 100 < ai_objects[0].originX < 140:
                intake_motor.spin(FORWARD)
                drivetrain.drive(FORWARD)
                while not bumper.pressing():
                    wait(2, MSEC)
                drivetrain.stop()

# VR threads — Do not delete
vr_thread(main)

.originY #

.originY zwraca współrzędną y lewego górnego rogu ograniczającego pola wykrytego obiektu w pikselach. Jest to liczba całkowita z przedziału od 0 do 240.

def main():
    # If an object is detected, approach and pick it up
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].originY > 120:
                drivetrain.stop()
                break
            else:
                intake_motor.spin(FORWARD)
                drivetrain.drive(FORWARD)

# VR threads — Do not delete
vr_thread(main)

.id #

.id zwraca identyfikator wykrytej klasyfikacji AI jako liczbę całkowitą.

Klasyfikacja AI	id	Podpis
Niebieski blok	1	`GameElements.BLUE_BLOCK`
Czerwony blok	2	`GameElements.RED_BLOCK`

def main():
    # Pick up a Red Block from the top left group
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    drivetrain.turn_for(LEFT, 80, DEGREES)
    drivetrain.drive_for(FORWARD, 300, MM)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            drivetrain.drive(FORWARD)
            if (ai_objects[0].id) == 2:
                intake_motor.spin(FORWARD)
                while not bumper.pressing():
                    wait(2, MSEC)
                drivetrain.stop()
                break

# VR threads — Do not delete
vr_thread(main)

Konsola #

Konsola wyświetla tekst, liczby i wartości zmiennych podczas działania projektu. Metody konsoli mogą również przenosić kursor do nowego wiersza, czyścić konsolę oraz dodawać zmienne lub wartości czujników do karty Monitor.

Wydrukować #

mózg.ekran.druk #

brain.screen.print wyświetla tekst, liczby lub wartości zmiennych w konsoli, używając bieżącej pozycji kursora.

Użyj brain.screen.next_row, jeśli chcesz, aby następna wydrukowana wartość zaczynała się w nowym wierszu.

Usage:
brain.screen.print(value)

Parametry	Opis
`value`	Tekst, liczba lub wartość zmiennej do wyświetlenia w konsoli.

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

# VR threads — Do not delete
vr_thread(main)

Konsola VEXcode z widoczną konsolą i tekstem „Witaj, robocie!”.

brain.screen.next_row #

brain.screen.next_row przenosi kursor do kolumny 1 w następnym wierszu w konsoli. Kolejna wydrukowana wartość pojawi się w tym wierszu.

Usage:
brain.screen.next_row()

Parametry	Opis
	Ta metoda nie ma żadnych parametrów.

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)

Konsola VEXcode, pokazująca konsolę i tekst „Wiersz 1” wyświetlany w pierwszym wierszu i „Wiersz 2” w drugim wierszu.

brain.screen.clear_screen #

brain.screen.clear_screen czyści wszystkie wiersze z konsoli i przenosi kursor z powrotem do wiersza 1.

Usage:
brain.screen.clear_screen()

Parametry	Opis
	Ta metoda nie ma żadnych parametrów.

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)

Monitor #

zmienna_monitora #

monitor_variable dodaje jedną lub więcej predefiniowanych zmiennych do zakładki Monitor w VEXcode. Pozwala to obserwować zmiany wartości zmiennej podczas działania projektu.

Zmienne muszą być globalne dla wartości monitor_variable aby można je było prawidłowo monitorować. Podaj nazwę każdej zmiennej jako ciąg znaków.

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

Parametry	Opis
`variable`	Nazwa predefiniowanej zmiennej globalnej do monitorowania, podana jako ciąg znaków. Aby monitorować więcej niż jedną zmienną, oddziel każdą nazwę zmiennej przecinkiem.

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)

czujnik_monitora #

monitor_sensor dodaje jedną lub więcej wartości czujników do zakładki Monitor w VEXcode. Pozwala to obserwować zmiany wartości czujników podczas działania projektu.

Podaj każdą wartość czujnika jako ciąg znaków.

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

Parametry	Opis
`sensor`	Wartość czujnika do monitorowania, podana jako ciąg znaków. Aby monitorować więcej niż jedną wartość czujnika, rozdziel każdą wartość przecinkiem. Obsługiwane identyfikatory czujników obejmują: Mózg `brain.timer.time` Układ napędowy `drivetrain.is_done` `drivetrain.is_moving` `drivetrain.heading` `drivetrain.rotation` `drivetrain.velocity` Silnik popychacza `pusher_motor.is_done` `pusher_motor.is_spinning` `pusher_motor.position` `pusher_motor.velocity` Silnik ramienia `arm_motor.is_done` `arm_motor.is_spinning` `arm_motor.position` `arm_motor.velocity` Czujnik odległości przedniej `front_distance.is_object_detected` `front_distance.object_distance_mm` `front_distance.object_distance_inches` Czujnik optyczny przedniej osi `front_optical.is_near_object` `front_optical.color` `front_optical.brightness` `front_optical.hue` Czujnik GPS `gps.position_mm` `gps.position_inches` `gps.heading` Czujnik obrotu popychacza `pusher_rotation.angle` `pusher_rotation.position` Czujnik AI Vision `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`

Parametry

Opis

sensor

Wartość czujnika do monitorowania, podana jako ciąg znaków. Aby monitorować więcej niż jedną wartość czujnika, rozdziel każdą wartość przecinkiem. Obsługiwane identyfikatory czujników obejmują:

Mózg
- brain.timer.time
Układ napędowy
- drivetrain.is_done
- drivetrain.is_moving
- drivetrain.heading
- drivetrain.rotation
- drivetrain.velocity
Silnik popychacza
- pusher_motor.is_done
- pusher_motor.is_spinning
- pusher_motor.position
- pusher_motor.velocity
Silnik ramienia
- arm_motor.is_done
- arm_motor.is_spinning
- arm_motor.position
- arm_motor.velocity
Czujnik odległości przedniej
- front_distance.is_object_detected
- front_distance.object_distance_mm
- front_distance.object_distance_inches
Czujnik optyczny przedniej osi
- front_optical.is_near_object
- front_optical.color
- front_optical.brightness
- front_optical.hue
Czujnik GPS
- gps.position_mm
- gps.position_inches
- gps.heading
Czujnik obrotu popychacza
- pusher_rotation.angle
- pusher_rotation.position
Czujnik AI Vision
- 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)

Wyczuwanie #

Optyczny #

jest_w_pobliżu_obiektu #

is_near_object zwraca wartość logiczną wskazującą, czy czujnik optyczny wykrył obiekt w zasięgu.

True – Czujnik optyczny wykrywa obiekt.
False – Czujnik optyczny nie wykrył obiektu.

Usage:
optical.is_near_object()

Parametry	Opis
	Ta metoda nie ma żadnych parametrów.

def main():
    # Move the preloaded Block to the top of the Conveyor
    conveyor_motor.spin(FORWARD)
    while not optical.is_near_object():
        wait(2, MSEC)
    conveyor_motor.stop()

# VR threads — Do not delete
vr_thread(main)

kolor #

color zwraca instancję klasy Color na podstawie wykrytej wartości odcienia. Można je porównać z predefiniowanymi obiektami Color , aby utworzyć instrukcje warunkowe.

Możliwe kolory:

NONE
RED - Wartość odcienia pomiędzy 340° - 20°
GREEN - Wartość odcienia pomiędzy 80° - 140°
BLUE - Wartość odcienia pomiędzy 200° - 240°
YELLOW - Wartość odcienia pomiędzy 40° - 60°
ORANGE - Wartość odcienia pomiędzy 20° - 40°
PURPLE - Wartość odcienia pomiędzy 240° - 280°
CYAN - Wartość odcienia pomiędzy 140° - 200°

Uwaga: Czujnik optyczny wyszukuje zakresy odcieni odpowiadające określonemu kolorowi. Aby wykryć konkretne zakresy odcieni, zobacz hue.

Usage:
optical.color()

Parametry	Opis
	Ta metoda nie ma żadnych parametrów.

def main():
    # Pick up and move a Blue Block to the top of the Conveyor
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 360, MM)
    conveyor_motor.spin(FORWARD)
    while not optical.color() == BLUE:
        wait(2, MSEC)
    conveyor_motor.stop()

# VR threads — Do not delete
vr_thread(main)

jasność #

brightness zwraca ilość światła odbitego od obiektu jako liczbę dziesiętną (float) reprezentującą procent.

Wyższy procent oznacza, że więcej światła odbija się z powrotem do czujnika optycznego. Niższy procent oznacza, że mniej światła odbija się z powrotem.

Usage:
optical.brightness()

Parametry	Opis
	Ta metoda nie ma żadnych parametrów.

def main():
    # Move the preloaded Block to the top of the Conveyor
    conveyor_motor.spin(FORWARD)
    while not 0 < optical.brightness():
        wait(2, MSEC)
    conveyor_motor.stop()

# VR threads — Do not delete
vr_thread(main)

odcień #

hue zwraca wartość odcienia wykrytego koloru jako liczbę dziesiętną (float) od 0 do 359.

Odcień to sposób opisywania koloru za pomocą liczb znajdujących się na kole barw.

Koło barw wyświetlające pełne spektrum odcieni oznaczonych wartościami stopni na obwodzie, zwiększającymi się co 30 stopni od 0° u góry do 360°.

Usage:
optical.hue()

Parametry	Opis
	Ta metoda nie ma żadnych parametrów.

def main():
    # Pick up and move a Blue Block to the top of the Conveyor
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 360, MM)
    conveyor_motor.spin(FORWARD)
    while not 220 < optical.hue() < 260:
        wait(2, MSEC)
    conveyor_motor.stop()

# VR threads — Do not delete
vr_thread(main)

wykryto_obiekt #

object_detected rejestruje funkcję, która ma zostać wywołana za każdym razem, gdy czujnik optyczny wykryje nowy obiekt.

Usage:
optical.object_detected(callback, arg)

Parametry	Opis
`callback`	Wcześniej zdefiniowana funkcja, która jest wykonywana, gdy czujnik optyczny wykryje nowy obiekt.
`arg`	Opcjonalnie. Krotka krotka zawierająca argumenty do przekazania do funkcji wywołania zwrotnego. Więcej informacji można znaleźć w sekcji Używanie funkcji z parametrami.

def ready_block():
  # Stop the conveyor when Block is at the Sensor
  conveyor_motor.stop()

def main():
  # Move the preloaded Block near the top of the Conveyor
  conveyor_motor.spin(FORWARD)
  optical.object_detected(ready_block)

# VR threads — Do not delete
vr_thread(main)

obiekt_utracony #

object_lost rejestruje funkcję, która ma zostać wywołana za każdym razem, gdy czujnik optyczny utraci wykryty obiekt.

Usage:
optical.object_lost(callback, arg)

Parametry	Opis
`callback`	Wcześniej zdefiniowana funkcja, która jest wykonywana, gdy czujnik optyczny utraci wykryty obiekt.
`arg`	Opcjonalnie. Krotka krotka zawierająca argumenty do przekazania do funkcji wywołania zwrotnego. Więcej informacji można znaleźć w sekcji Używanie funkcji z parametrami.

def ready_block():
  # Stop the conveyor when Block is at the top
  conveyor_motor.stop()

def main():
  # Move the preloaded Block to the top of the Conveyor
  conveyor_motor.spin(FORWARD)
  optical.object_lost(ready_block)

# VR threads — Do not delete
vr_thread(main)

GPS #

x_position #

x_position zwraca aktualną współrzędną x czujnika GPS (Game Positioning System™) na boisku.

Usage:
gps.x_position(units)

Parametry	Opis
jednostki	Jednostka wartości przesunięcia: `INCHES` lub `MM`

def main():
    # Pick up a second Block
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive(FORWARD)
    while not gps.x_position(MM) > -795:
        wait(2, MSEC)
    drivetrain.stop()

# VR threads — Do not delete
vr_thread(main)

pozycja y #

y_position zwraca aktualną współrzędną y czujnika GPS (Game Positioning System™) na boisku.

Usage:
gps.y_position(units)

Parametry	Opis
jednostki	Jednostka wartości przesunięcia: `INCHES` lub `MM`

def main():
    # Pick up a second Block
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive(FORWARD)
    while not -450 > gps.y_position(MM):
        wait(2, MSEC)
    drivetrain.stop()

# VR threads — Do not delete
vr_thread(main)

nagłówek #

heading zwraca kierunek, w którym aktualnie zwrócony jest robot, na podstawie odczytów czujnika GPS (Game Positioning System™) w zakresie od 0 do 359 stopni.

Usage:
gps.heading()

Parametry	Opis
	Ta metoda nie ma żadnych parametrów.

def main():
    # Score the preloaded Block into a Center Goal
    drivetrain.set_turn_velocity(30, PERCENT)
    drivetrain.turn(LEFT)
    while not 40 > gps.heading():
        wait(2, MSEC)
    drivetrain.drive_for(FORWARD, 1000, MM)
    drivetrain.turn(RIGHT)
    while not gps.heading() > 310:
        wait(2, MSEC)
    drivetrain.drive_for(REVERSE, 400, MM)
    conveyor_motor.spin(FORWARD)

# VR threads — Do not delete
vr_thread(main)