Kustība#

Ievads #

Motori kontrolē robota daļu kustību. Motorus var izmantot, lai paceltu roku, pagrieztu nagu, pagrieztu riteni vai pārvietotu citu konstrukcijas daļu. Divi motori var darboties kopā kā piedziņas ķēde, lai pārvietotu un pagrieztu visu robotu.

Katrs motors ir konfigurēts logā “Ierīces”. Atkarībā no versijas motoru nosaukumi var mainīties. Piemēram, Competition Advanced 2.0 versijai ir motors ar nosaukumu arm_motorPielāgots robots var izmantot dažādus motoru nosaukumus.

Pēc noklusējuma FORWARD griež motoru pretēji pulksteņrādītāja virzienam, bet REVERSE griež motoru pulksteņrādītāja virzienā. Ja ierīču logā ir iestatīts motora griešanās atpakaļgaitā, šie virzieni tiks apmainīti.

VEX GO motors, kas rāda uz priekšu vērstu virzienu, ko norāda pluszīme un bultiņa, kas norāda, ka tas griežas pa kreisi jeb pretēji pulksteņrādītāja virzienam.

VEX GO motors, kas rāda pretējo virzienu, ko norāda mīnusa zīme un bultiņa, kas norāda, ka tas griežas pa labi jeb pulksteņrādītāja virzienā.

Motorus var kodēt dažādos veidos. Zemāk ir visu kustību metožu saraksts:

Darbības — Apturēt un pagriezt motorus.

spin — Griež motoru uz priekšu vai atpakaļ bezgalīgi.
spin_for — Griež motoru noteiktu attālumu.
spin_to_position — Pagriež motoru uz noteiktu pozīciju.
stop — Aptur motora griešanos.

Mutatori — pielāgo motorikas iestatījumus.

set_velocity — Norāda motoram, cik ātri griezties.
set_max_torque — Nosaka, cik stipri motors drīkst spiest griešanās laikā.
set_position — Maina motora pašreizējo pozīciju uz jaunu vērtību.
set_stopping — Iestata, kā motors apturēs kustību: bremzējot, ripojot brīvgaitā vai turot.
set_timeout — Iestata, cik daudz laika motors mēģinās pabeigt kustību.

Getteri — pārbaudiet motora stāvokli.

get_position — Atgriež motora pašreizējo pozīciju.
get_velocity — Atgriež motora griešanās ātrumu procentos no -100% līdz 100%.
get_current — Atgriež, cik daudz enerģijas motors patērē no akumulatora, procentos no 0% līdz 100%.
is_stopped — Atgriež, vai motors ir beidzis kustību, kā Būla vērtību.
is_moving — Atgriež, vai motors griežas, kā Būla vērtību.

Darbības #

spin #

spin griež motoru uz priekšu vai atpakaļ bezgalīgi. Motors turpinās griezties, līdz tam tiks dota cita darbība, piemēram, griezties citā virzienā vai apstāties.

Usage:
arm_motor.spin(direction)

Parametri	Apraksts
`direction`	Motora griešanās virziens: `FORWARD` vai `REVERSE`.

# Build Used: Competition Advanced 2.0
def main():
    # Raise the ArmMotor, then stop
    arm_motor.spin(REVERSE)
    wait(1, SECONDS)
    arm_motor.stop()

# Start threads — Do not delete
start_thread(main)

spin_for #

spin_for griež motoru noteiktu attālumu. Griešanās ātrums ir relatīvs attiecībā pret motora pašreizējo pozīciju. Projekts gaidīs, līdz motors būs beidzis griezties, pirms tiks palaista nākamā koda rinda.

Usage:
arm_motor.spin_for(direction, angle, units, wait)

Parametri	Apraksts
`direction`	Motora griešanās virziens: `FORWARD` vai `REVERSE`.
`angle`	Attālums, kādā griežas motors. `DEGREES` izmanto veselus skaitļus. `TURNS` var izmantot veselus skaitļus vai decimālskaitļus.
`units`	Neobligāti. Attāluma mērvienība: `DEGREES` (pēc noklusējuma) vai `TURNS`.
`wait`	Neobligāti. `wait=True` (noklusējums) liek projektam gaidīt, līdz motors ir beidzis griezties, pirms tiek palaista nākamā koda rinda. `wait=False` liek nekavējoties palaist nākamo koda rindu.

# Build Used: Competition Advanced 2.0
def main():
    # Raise and lower the ArmMotor
    arm_motor.spin_for(REVERSE, 180, DEGREES)
    wait(1, SECONDS)
    arm_motor.spin_for(FORWARD, 180, DEGREES)

# Start threads — Do not delete
start_thread(main)

spin_to_position #

spin_to_position griež motoru uz noteiktu pozīciju.

Motora pozīcija ir tas, cik tālu tas ir pagriezies, mērot DEGREES vai TURNSViens pagrieziens ir vienāds ar 360 grādiem. Projekta sākumā motora pozīcija ir iestatīta uz 0 grādiem. Motora pozīciju var iestatīt arī, izmantojot metodi set_position.

Pozīcijas vērtības ir absolūtas. Tas nozīmē, ka griešanās virziens ir atkarīgs no motora pašreizējās pozīcijas.

Piemēram, ja motors iedarbojas pie 0 grādiem un griežas līdz 720 grādu pozīcijai, tas griezīsies divus apgriezienus uz priekšu. Ja tas pēc tam griežas līdz 360 grādu pozīcijai, tas griezīsies atpakaļ par vienu apgriezienu, jo 360 grādi ir mazāki par 720.

Usage:
arm_motor.spin_to_position(angle, units, wait)

Parametri	Apraksts
`angle`	Pozīcijas vērtība, līdz kurai motors griezīsies. `DEGREES` izmanto veselus skaitļus. `TURNS` var izmantot veselus skaitļus vai decimālskaitļus.
`units`	Pēc izvēles. Pozīcijas mērvienība: `DEGREES` (pēc noklusējuma) vai `TURNS`.
`wait`	Neobligāti. `wait=True` (noklusējums) liek projektam gaidīt, līdz motors ir beidzis griezties, pirms tiek palaista nākamā koda rinda. `wait=False` liek nekavējoties palaist nākamo koda rindu.

# Build Used: Competition Advanced 2.0
def main():
    # Return ArmMotor to 0 degrees after raising
    arm_motor.spin_for(REVERSE, 180, DEGREES)
    wait(1, SECONDS)
    arm_motor.spin_to_position(0, DEGREES)

# Start threads — Do not delete
start_thread(main)

stop #

stop aptur motora griešanos.

Usage:
arm_motor.stop()

Parametri	Apraksts
	Šai metodei nav parametru.

# Build Used: Competition Advanced 2.0
def main():
    # Raise the ArmMotor
    arm_motor.spin(REVERSE)
    wait(1, SECONDS)
    arm_motor.stop()

# Start threads — Do not delete
start_thread(main)

Mutatori #

set_velocity #

set_velocity norāda motoram, cik ātri griezties. Augstāka procentuālā vērtība liek motoram griezties ātrāk, bet zemāka procentuālā vērtība liek motoram griezties lēnāk.

Katrs projekts sākas ar to, ka katrs motors pēc noklusējuma griežas ar 50% ātrumu.

Piezīme: Lielāks ātrums liek motoram griezties ātrāk, bet tas var būt mazāk precīzs. Mazāks ātrums liek motoram griezties lēnāk, bet tas var būt precīzāks.

Usage:
arm_motor.set_velocity(velocity)

Parametri	Apraksts
`velocity`	Griešanās ātrums no 0% līdz 100%. Tas var būt vesels skaitlis `integer` vai decimālskaitlis (`float`).

# Build Used: Competition Advanced 2.0
def main():
    # Move the ArmMotor at different velocities
    arm_motor.spin_for(REVERSE, 180, DEGREES)
    wait(1, SECONDS)
    # Move slow
    arm_motor.set_velocity(20)
    arm_motor.spin_for(FORWARD, 180, DEGREES)
    wait(1, SECONDS)
    # Move fast
    arm_motor.set_velocity(100)
    arm_motor.spin_for(REVERSE, 180, DEGREES)

# Start threads — Do not delete
start_thread(main)

set_max_torque #

Griezes moments ir griešanās spēks. Tas parāda, cik stipri motors var stumt vai vilkt, kad tas griežas.

set_max_torque iestata maksimālo griezes momentu, ko motors drīkst izmantot.

Augstāka procentuālā vērtība ļauj motoram spiest spēcīgāk, piemēram, paceļot smagu priekšmetu. Zemāka procentuālā vērtība ierobežo, cik spēcīgi motors var spiest. Tas var palīdzēt aizsargāt robotu, ja motors iesprūst vai sasniedz kustības robežas.

Katrs projekts sākas ar katra motora griezes momentu pēc noklusējuma 50%.

Usage:
arm_motor.set_max_torque(value)

Parametri	Apraksts
`value`	Maksimālais griezes moments, ko motors var izmantot, no 0% līdz 100%. Tas var būt vesels skaitlis `integer` vai decimālskaitlis (`float`).

# Build Used: Competition Advanced 2.0
def main():
    # Move the ArmMotor at different torques
    arm_motor.spin_for(REVERSE, 180, DEGREES)
    wait(1, SECONDS)
    # Move with less torque
    arm_motor.set_max_torque(20)
    arm_motor.spin_for(FORWARD, 180, DEGREES)
    wait(1, SECONDS)
    # Move with maximum torque
    arm_motor.set_max_torque(100)
    arm_motor.spin_for(REVERSE, 180, DEGREES)

# Start threads — Do not delete
start_thread(main)

set_position #

Motora pozīcija ir tas, cik tālu tas ir pagriezies, mērot DEGREES vai TURNSViens pagrieziens ir vienāds ar 360 grādiem. set_position maina motora pašreizējo pozīciju uz jaunu vērtību.

Piemēram, ja motors ir pagriezies līdz 180 grādiem, pozīcijas iestatīšana uz 0 grādiem atiestatīs šo pozīciju no 180 uz 0 grādiem. Pēc tam motors var griezties pozīcijās, pamatojoties uz šo jauno vērtību.

Usage:
arm_motor.set_position(position, units)

Parametri	Apraksts
`position`	Motora pozīcijas vērtība, kas jāiestata. `DEGREES` izmanto veselus skaitļus. `TURNS` var izmantot veselus skaitļus vai decimālskaitļus.
`units`	Pēc izvēles. Pozīcijas mērvienība: `DEGREES` (pēc noklusējuma) vai `TURNS`.

# Build Used: Competition Advanced 2.0
def main():
    # Return ArmMotor to 0 degrees after raising
    arm_motor.set_position(0, DEGREES)
    arm_motor.spin_for(REVERSE, 180, DEGREES)
    wait(1, SECONDS)
    arm_motor.spin_to_position(0, DEGREES)

# Start threads — Do not delete
start_thread(main)

set_stopping #

set_stopping nosaka, kā motors apstāsies: bremzējot, ripojot vai turot.

Usage:
arm_motor.set_stopping(mode)

Parametri	Apraksts
`mode`	Kā motors apstāsies: `BRAKE` — Apstājas nekavējoties. `COAST` — Palēnina ātrumu līdz apstāšanai. `HOLD` — Apstājas nekavējoties un notur motora pozīciju.

Parametri

Apraksts

mode

Kā motors apstāsies:

BRAKE — Apstājas nekavējoties.
COAST — Palēnina ātrumu līdz apstāšanai.
HOLD — Apstājas nekavējoties un notur motora pozīciju.

Piemēram, ja tiek izmantota Competition Advanced 2.0 versija un arm_motor ir iestatīts uz HOLD, motors noturēs roku tās pašreizējā pozīcijā, līdz notiks nākamā rokas kustība. Tas nozīmē, ka motors darbosies pret gravitāciju, lai noturētu roku gaisā, ja motors tika apturēts ar paceltu roku.

Ja šī metode netiek izmantota, motors apstāšanās laikā izmantos BRAKE.

# Build Used: Competition Advanced 2.0
def main():
    # Move the ArmMotor, then coast to a stop
    arm_motor.set_velocity(20)
    arm_motor.set_stopping(COAST)
    arm_motor.spin(REVERSE)
    wait(1, SECONDS)
    arm_motor.stop()

# Start threads — Do not delete
start_thread(main)

set_timeout #

set_timeout nosaka, cik ilgi motors mēģinās pabeigt kustību. Ja motors nevar pabeigt šajā laikā, tas pārtrauks mēģinājumu un pāries uz nākamo koda rindiņu. Tas neļauj motoram iestrēgt kustībā.

Usage:
arm_motor.set_timeout(value, units)

Parametri	Apraksts
`value`	Laiks, kurā motors var mēģināt pabeigt kustību. Tas var būt pozitīvs skaitlis `integer` vai decimālskaitlis (`float`).
`units`	Neobligāti. Laika mērvienība: `SECONDS` (pēc noklusējuma) vai `MSEC` (milisekundes).

# Build Used: Competition Advanced 2.0
def main():
    # Move ArmMotor as far as possible for 1 second before resetting
    arm_motor.set_position(0, DEGREES)
    arm_motor.set_timeout(1, SECONDS)
    arm_motor.spin_for(REVERSE, 180, DEGREES)
    arm_motor.spin_to_position(0, DEGREES)

# Start threads — Do not delete
start_thread(main)

Getteri #

get_position #

Motora pozīcija norāda, cik tālu tas ir pagriezies, mērot DEGREES vai TURNSViens pagrieziens ir vienāds ar 360 grādiem. get_position atgriež motora pašreizējo pozīciju.

Projekta sākumā motora pozīcija ir iestatīta uz 0 grādiem. Ja motors griežas vienu apgriezienu uz priekšu, pozīcija būs 360 grādi jeb 1 apgrieziens. Ja motors griežas pretējā virzienā, pozīcija būs negatīva.

Usage:
arm_motor.get_position(units)

Parametri	Apraksts
`units`	Pēc izvēles. Vienība, kas atgriež motora pozīciju: `DEGREES` (pēc noklusējuma) vai `TURNS`.

# Build Used: Competition Advanced 2.0
def main():
    # Display how far the ArmMotor moves after one second
    arm_motor.set_position(0, DEGREES)
    console.print("Start: ")
    console.print(arm_motor.get_position(DEGREES))
    console.new_line()
    arm_motor.spin(REVERSE)
    wait(1, SECONDS)
    arm_motor.stop()
    console.print("After: ")
    console.print(arm_motor.get_position(DEGREES))

# Start threads — Do not delete
start_thread(main)

get_velocity #

get_velocity atgriež motora griešanās ātrumu procentos no -100% līdz 100%.

Pozitīva vērtība nozīmē, ka motors griežas uz priekšu. Negatīva vērtība nozīmē, ka motors griežas atpakaļgaitā.

Usage:
arm_motor.get_velocity()

Parametri	Apraksts
	Šai metodei nav parametru.

# Build Used: Competition Advanced 2.0
def main():
    # Display the ArmMotor's velocity when it moves
    console.print("Resting: ")
    console.print(arm_motor.get_velocity())
    console.new_line()
    arm_motor.spin(REVERSE)
    wait(1, SECONDS)
    console.print("Moving: ")
    console.print(arm_motor.get_velocity())
    arm_motor.stop()

# Start threads — Do not delete
start_thread(main)

get_current #

get_current atgriež, cik daudz enerģijas motors patērē no akumulatora, procentos no 0% līdz 100%.

Augstāka strāvas vērtība nozīmē, ka motors patērē vairāk jaudas. Tas var notikt, ja motors ceļ kaut ko smagu, spiežas pret priekšmetu vai mēģina kustēties, kad ir iestrēdzis.

Usage:
arm_motor.get_current()

Parametri	Apraksts
	Šai metodei nav parametru.

# Build Used: Competition Advanced 2.0
def main():
    # Display the motor's current when it moves
    console.print("Resting: ")
    console.print(arm_motor.get_current())
    console.new_line()
    arm_motor.spin(REVERSE)
    wait(1, SECONDS)
    console.print("Moving: ")
    console.print(arm_motor.get_current())
    arm_motor.stop()

# Start threads — Do not delete
start_thread(main)

is_stopped #

is_stopped atgriež, vai motors ir beidzis kustību, kā Būla vērtību. To var izmantot, lai kontrolētu citu darbību laiku, pamatojoties uz motora kustību.

True — Motors ir beidzis kustību.
False — Motors joprojām kustas.

Šī metode darbojas kopā ar šādām kustības metodēm, kurām ir parametrs wait : spin_for un spin_to_position.

Usage:
arm_motor.is_stopped()

Parametri	Apraksts
	Šai metodei nav parametru.

# Build Used: Competition Advanced 2.0
def main():
    # Turn the Eye Sensor's light on while ArmMotor is moving
    arm_motor.spin_for(REVERSE, 180, DEGREES, wait=False)
    wait(0.1, SECONDS)
    while True:
        if arm_motor.is_stopped():
            eye.set_light(OFF)
        else:
            eye.set_light(ON)

# Start threads — Do not delete
start_thread(main)

is_moving #

is_moving atgriež, vai motors griežas, kā Būla vērtību. To var izmantot, lai kontrolētu citu darbību laiku, pamatojoties uz motora kustību.

True — Motors griežas.
False — Motors negriežas.

Šī metode darbojas kopā ar šādām kustības metodēm, kurām ir parametrs wait : spin_for un spin_to_position.

Usage:
arm_motor.is_moving()

Parametri	Apraksts
	Šai metodei nav parametru.

# Build Used: Competition Advanced 2.0
def main():
    # Turn the Eye Sensor's light on while ArmMotor is moving
    arm_motor.spin_for(REVERSE, 180, DEGREES, wait=False)
    wait(0.1, SECONDS)
    while True:
        if arm_motor.is_moving():
            eye.set_light(ON)
        else:
            eye.set_light(OFF)

# Start threads — Do not delete
start_thread(main)