Piedziņa#

Ievads #

VEX IQ (2. paaudzes) robots braukšanai un pagriešanai izmanto piedziņas sistēmu. Piedziņas sistēmu veido motori un riteņi, kas kopā darbojas, lai pārvietotu robotu.

Konfigurēta piedziņas sistēma var izmantot pievienotu žiroskopisko sensoru, smadzenēs iebūvēto inerciālo sensoru vai arī neizmantot sensoru. Kad tiek izmantots sensors, piedziņas sistēma to izmanto, lai palīdzētu robotam precīzi kustēties un pagriezties. Katra projekta sākumā piedziņas sistēma automātiski kalibrē sensoru. Kalibrēšanas laikā robotam apmēram 2 sekundes jātur nekustīgs, lai tas varētu pareizi kustēties un pagriezties.

Šajā lapā kā piedziņas mehānisma nosaukuma piemērs tiek izmantots drivetrain Ja nepieciešams, nomainiet to ar savu konfigurēto nosaukumu.

Ir daudz veidu, kā kodēt piedziņas sistēmu. Zemāk ir visu piedziņas sistēmas metožu saraksts:

Darbības — Pārvietot un pagriezt robotu.

drive — Pārvieto robotu uz priekšu vai atpakaļ uz visiem laikiem.
drive_for — Pārvieto robotu uz priekšu vai atpakaļ noteiktu attālumu.
turn — Pagriež robotu pa kreisi vai pa labi uz visiem laikiem.
turn_for — Pagriež robotu pa kreisi vai pa labi par noteiktu grādu skaitu.
turn_to_heading — Pagriež robotu noteiktā virzienā no -359 līdz 359 grādiem. Robots pagriezīsies īsākajā virzienā, lai sasniegtu mērķa virzienu.
turn_to_rotation — Pagriež robotu noteiktā rotācijā.
stop — Aptur robota kustību.
calibrate_drivetrain — Kalibrē sensoru, kas konfigurēts ar piedziņas sistēmu.

Mutatori — pielāgo piedziņas mehānisma iestatījumus.

set_drive_velocity — Norāda robotam, cik ātri braukt.
set_turn_velocity — Norāda robotam, cik ātri griezties.
set_stopping — Norāda, kā robots pārtrauks kustību: bremzējot, braucot brīvi vai turoties.
set_timeout — Iestata, cik daudz laika robots mēģinās pabeigt kustību.
set_heading — Maina robota pašreizējo virzienu uz jaunu virzienu.
set_rotation — Maina robota pašreizējo rotāciju uz jaunu rotāciju.
set_turn_threshold — Norāda, cik tuvu robotam jāpienāk mērķa leņķim, pirms pagrieziens ir pabeigts.
set_turn_constant — Maina, cik spēcīgi robots koriģē savus pagriezienus.

Getteri — pārbaudiet kustības statusu.

heading — Atgriež robota pašreizējo virzienu no 0 līdz 359 grādiem.
rotation — Atgriež robota pašreizējo rotāciju.
velocity — Atgriež robota braukšanas ātrumu.
current — Atgriež, cik daudz elektriskās strāvas patērē piedziņas sistēma.
is_moving — Atgriež, vai robots kustas, kā Būla vērtību.
is_done — Atgriež, vai robots ir pabeidzis kustību, kā Būla vērtību.
is_turning — Atgriež, vai robots griežas, kā Būla vērtību.
power — Atgriež, cik ātri piedziņas sistēma patērē enerģiju.
torque — Atgriež piedziņas piedziņas izmantoto griezes momentu.
efficiency — Atgriež, cik efektīvi piedziņas sistēma izmanto jaudu.
temperature — Atgriež piedziņas sistēmas siltumu.

Konstruktori — manuāli izveidojiet un konfigurējiet piedziņas sistēmu.

DriveTrain — Izveido piedziņas sistēmu bez žiroskopiskā sensora vai inerciālā sensora.
SmartDrive — Izveido piedziņas sistēmu ar žiroskopisko sensoru vai inerciālo sensoru.

Darbības #

drive #

drive pārvieto robotu uz priekšu vai atpakaļ bezgalīgi. Robots turpinās kustēties, līdz tam tiks dota cita darbība, piemēram, pagriešana vai apstāšanās.

Usage:
drivetrain.drive(direction, velocity, units)

Parametri	Apraksts
`direction`	Robota kustības virziens: `FORWARD` vai `REVERSE`.
`velocity`	Optional. The velocity to drive with from 0% to 100% when using `PERCENT`, from 0 to 120 rpm when using `RPM`, or from 0 to 720 degrees per second when using `VelocityUnits.DPS`. This can be an `integer` or decimal (`float`). If no velocity is provided, the robot drives at the current drive velocity.
`units`	Neobligāti. Ātruma mērvienība: `PERCENT` (pēc noklusējuma), `RPM` (apgriezieni minūtē) vai `VelocityUnits.DPS` (grādi sekundē).

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

# Drive slowly in reverse then stop
drivetrain.drive(REVERSE, 20, PERCENT)
wait(2, SECONDS)
drivetrain.stop()

drive_for #

drive_for pārvieto robotu uz priekšu vai atpakaļ noteiktu attālumu. Projekts gaidīs, līdz robots būs pabeidzis kustību, pirms tiks palaista nākamā koda rinda.

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

Parametri	Apraksts
`direction`	Robota kustības virziens: `FORWARD` vai `REVERSE`.
`distance`	Robota nobrauktais attālums. Tas var būt vesels skaitlis `integer` vai decimālskaitlis (`float`).
`units`	Neobligāti. Attāluma mērvienība: `INCHES` (pēc noklusējuma), `MM` (milimetri) vai `DistanceUnits.CM` (centimetri).
`velocity`	Optional. The velocity to drive with from 0% to 100% when using `PERCENT`, from 0 to 120 rpm when using `RPM`, or from 0 to 720 degrees per second when using `VelocityUnits.DPS`. This can be an `integer` or decimal (`float`). If no velocity is provided, the robot drives at the current drive velocity.
`units_v`	Neobligāti. Ātruma mērvienība: `RPM` (apgriezieni minūtē, pēc noklusējuma), `PERCENT`vai `VelocityUnits.DPS` (grādi sekundē).
`wait`	Neobligāti. `wait=True` (noklusējums) liek projektam gaidīt, līdz robots ir beidzis kustību, pirms tiek palaista nākamā koda rinda. `wait=False` liek nekavējoties palaist nākamo koda rindu.

# Drive forward and backward
drivetrain.drive_for(FORWARD, 10)
drivetrain.drive_for(REVERSE, 10)

# Quickly drive forward and backward
drivetrain.drive_for(FORWARD, 200, MM, 100, PERCENT)
drivetrain.drive_for(REVERSE, 200, MM, 100, PERCENT)

turn #

turn pagriež robotu pa kreisi vai pa labi uz visiem laikiem. Robots turpinās griezties, līdz tam tiks dota cita darbība, piemēram, braukšana vai apstāšanās.

Usage:
drivetrain.turn(direction, velocity, units)

Parametri	Apraksts
`direction`	Robota griešanās virziens: `LEFT` vai `RIGHT`.
`velocity`	Optional. The velocity to turn with from 0% to 100% when using `PERCENT`, from 0 to 120 rpm when using `RPM`, or from 0 to 720 degrees per second when using `VelocityUnits.DPS`. This can be an `integer` or decimal (`float`). If no velocity is provided, the robot turns at the current turn velocity.
`units`	Neobligāti. Ātruma mērvienība: `RPM` (apgriezieni minūtē, pēc noklusējuma), `PERCENT`vai `VelocityUnits.DPS` (grādi sekundē).

# Turn right and left, then stop
drivetrain.turn(RIGHT)
wait(2, SECONDS)
drivetrain.turn(LEFT)
wait(2, SECONDS)
drivetrain.stop()

# Quickly turn right and left, then stop
drivetrain.turn(RIGHT, 100, PERCENT)
wait(2, SECONDS)
drivetrain.turn(LEFT, 100, PERCENT)
wait(2, SECONDS)
drivetrain.stop()

turn_for #

turn_for pagriež robotu pa kreisi vai pa labi par noteiktu grādu vai pagriezienu skaitu. Pagrieziens ir relatīvs attiecībā pret robota pašreizējo pozīciju. Projekts gaidīs, līdz robots būs pabeidzis pagriešanos, pirms tiks palaista nākamā koda rinda.

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

Parametri	Apraksts
`direction`	Robota griešanās virziens: `LEFT` vai `RIGHT`.
`angle`	Robota pagrieziena apjoms. Tas var būt vesels skaitlis `integer` vai decimālskaitlis (`float`).
`units`	Pēc izvēles. Pagrieziena mērvienība: `DEGREES` (pēc noklusējuma) vai `TURNS`Viens pagrieziens ir vienāds ar 360 grādiem.
`velocity`	Optional. The velocity to turn with from 0% to 100% when using `PERCENT`, from 0 to 120 rpm when using `RPM`, or from 0 to 720 degrees per second when using `VelocityUnits.DPS`. This can be an `integer` or decimal (`float`). If no velocity is provided, the robot turns at the current turn velocity.
`units_v`	Neobligāti. Ātruma mērvienība: `RPM` (apgriezieni minūtē, pēc noklusējuma), `PERCENT`vai `VelocityUnits.DPS` (grādi sekundē).
`wait`	Neobligāti. `wait=True` (noklusējums) liek projektam gaidīt, līdz robots ir pabeidzis pagriešanos, pirms tiek palaista nākamā koda rinda. `wait=False` liek nekavējoties palaist nākamo koda rindu.

# Turn the robot right and left
drivetrain.turn_for(RIGHT, 90, DEGREES)
wait(1, SECONDS)
drivetrain.turn_for(LEFT, 90, DEGREES)

# Quickly turn the robot right and left
drivetrain.turn_for(RIGHT, 90, DEGREES, 100, PERCENT)
wait(1, SECONDS)
drivetrain.turn_for(LEFT, 90, DEGREES, 100, PERCENT)

turn_to_heading #

Virziens ir virziens, kurā robots ir pagriezies, mērot grādos. turn_to_heading pagriež robotu noteiktā virzienā no -359 līdz 359 grādiem. Robots pagriezīsies īsākajā virzienā, lai sasniegtu mērķa virzienu.

Robota sākuma virziens ir 0 grādi.

Projekts gaidīs, līdz robots būs pabeidzis griešanos, pirms tiks palaista nākamā koda rinda.

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

Parametri	Apraksts
`angle`	Virziens, kurā robotam jābūt pagrieztam, grādos. Tas var būt vesels skaitlis `integer` vai decimālskaitlis (`float`) no -359 līdz 359.
`units`	Neobligāti. Virziena mērvienība: `DEGREES` (pēc noklusējuma).
`velocity`	Optional. The velocity to turn with from 0% to 100% when using `PERCENT`, from 0 to 120 rpm when using `RPM`, or from 0 to 720 degrees per second when using `VelocityUnits.DPS`. This can be an `integer` or decimal (`float`). If no velocity is provided, the robot turns at the current turn velocity.
`units_v`	Neobligāti. Ātruma mērvienība: `PERCENT` (pēc noklusējuma), `RPM` (apgriezieni minūtē) vai `VelocityUnits.DPS` (grādi sekundē).
`wait`	Neobligāti. `wait=True` (noklusējums) liek projektam gaidīt, līdz robots ir pabeidzis pagriešanos, pirms tiek palaista nākamā koda rinda. `wait=False` liek nekavējoties palaist nākamo koda rindu.

# 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)

# Turn twice slowly
drivetrain.turn_to_heading(90, DEGREES, 20, PERCENT)
wait(1, SECONDS)
drivetrain.turn_to_heading(180, DEGREES, 20, PERCENT)

turn_to_rotation #

turn_to_rotation pagriež robotu noteiktā rotācijā.

Rotācija ir robota pagrieziena lielums, mērot grādos vai pagriezienos. Projekta sākumā rotācijas vērtība tiek iestatīta uz 0 grādiem. Rotāciju var iestatīt arī, izmantojot metodi set_rotation.

Rotācijas vērtības ir absolūtas. Tas nozīmē, ka pagrieziena virziens ir atkarīgs no robota pašreizējās rotācijas. Pagriežoties pa labi, rotācija palielinās, bet pagriežoties pa kreisi, tā samazinās.

Piemēram, ja robots sāk darboties no 0 grādiem un jūs pagriežaties par 720 grādiem, tas divreiz pagriezīsies pa labi. Ja pēc tam pagriezīsities par 360 grādiem, tas vienreiz pagriezīsies pa kreisi, jo 360 grādi ir mazāki par 720.

Projekts gaidīs, līdz robots būs pabeidzis griešanos, pirms tiks palaista nākamā koda rinda.

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

Parametri	Apraksts
`angle`	Rotācijas vērtība grādos vai pagriezienos, kādā robots pagriezīsies. Tā var būt vesels skaitlis `integer` vai decimālskaitlis (`float`).
`units`	Pēc izvēles. Rotācijas vienība: `DEGREES` (pēc noklusējuma) vai `TURNS`Viens pagrieziens ir vienāds ar 360 grādiem.
`velocity`	Optional. The velocity to turn with from 0% to 100% when using `PERCENT`, from 0 to 120 rpm when using `RPM`, or from 0 to 720 degrees per second when using `VelocityUnits.DPS`. This can be an `integer` or decimal (`float`). If no velocity is provided, the robot turns at the current turn velocity.
`units_v`	Neobligāti. Ātruma mērvienība: `PERCENT` (pēc noklusējuma), `RPM` (apgriezieni minūtē) vai `VelocityUnits.DPS` (grādi sekundē).
`wait`	Neobligāti. `wait=True` (noklusējums) liek projektam gaidīt, līdz robots ir pabeidzis pagriešanos, pirms tiek palaista nākamā koda rinda. `wait=False` liek nekavējoties palaist nākamo koda rindu.

# 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)

# Turn left then slowly spin in a
# circle clockwise
drivetrain.turn_to_rotation(-90, DEGREES)
wait(1, SECONDS)
drivetrain.turn_to_rotation(450, DEGREES, 20, PERCENT)

stop #

stop aptur robota kustību.

Usage:
drivetrain.stop(mode)

Parametri	Apraksts
`mode`	Pēc izvēles. Kā robots apstāsies: `BRAKE` (pēc noklusējuma), `COAST`vai `HOLD` `BRAKE` — Apstājas nekavējoties. `COAST` — Palēnina ātrumu līdz apstājas. `HOLD` — Apstājas nekavējoties un notur riteņu pozīciju.

Parametri

Apraksts

mode

Pēc izvēles. Kā robots apstāsies: BRAKE (pēc noklusējuma), COASTvai HOLD

BRAKE — Apstājas nekavējoties.
COAST — Palēnina ātrumu līdz apstājas.
HOLD — Apstājas nekavējoties un notur riteņu pozīciju.

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

# Drive forward and coast to a stop
drivetrain.set_drive_velocity(100, PERCENT)
drivetrain.drive(FORWARD)
wait(2, SECONDS)
drivetrain.stop(COAST)

calibrate_drivetrain #

calibrate_drivetrain ir iebūvēta funkcija, kas kalibrē žiroskopisko sensoru vai inerciālo sensoru, kas konfigurēts kopā ar piedziņas sistēmu.

Kalibrēšana palīdz sensoram pareizi izmērīt kustību. Kalibrēšanas laikā robotam jāturas nekustīgi apmēram 2 sekundes. Ja robots kalibrēšanas laikā kustas, sensors var nepareizi izmērīt kustību.

Projekts gaidīs, līdz tiks pabeigta kalibrēšana, pirms tiks palaista nākamā koda rinda.

Piezīme: Šo funkciju nevar izmantot VS Code ietvaros.

Usage:
calibrate_drivetrain()

Parametri	Apraksts
	Šai funkcijai nav parametru.

Mutatori #

set_drive_velocity #

set_drive_velocity norāda robotam, cik ātri jābrauc. Augstāka procentuālā vērtība liek robotam braukt ātrāk, bet zemāka procentuālā vērtība liek robotam braukt lēnāk.

Katrs projekts sākas ar robota kustību ar noklusējuma ātrumu 50%.

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

Usage:
drivetrain.set_drive_velocity(velocity, units)

Parametri	Apraksts
`velocity`	The velocity to drive with from 0% to 100% when using `PERCENT`, from 0 to 120 rpm when using `RPM`, or from 0 to 720 degrees per second when using `VelocityUnits.DPS`. This can be an `integer` or decimal (`float`).
`units`	Neobligāti. Ātruma mērvienība: `PERCENT` (pēc noklusējuma), `RPM` (apgriezieni minūtē) vai `VelocityUnits.DPS` (grādi sekundē).

# 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)

set_turn_velocity #

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

Katrs projekts sākas ar robota griešanos ar noklusējuma ātrumu 50%.

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

Usage:
drivetrain.set_turn_velocity(velocity, units)

Parametri	Apraksts
`velocity`	Griešanās ātrums no 0% līdz 100%, izmantojot `PERCENT`, no 0 līdz 120 apgr./min, izmantojot `RPM`, vai no 0 līdz 720 grādiem sekundē, izmantojot `VelocityUnits.DPS`Tas var būt vesels skaitlis `integer` decimālskaitlis (`float`).
`units`	Neobligāti. Ātruma mērvienība: `PERCENT` (pēc noklusējuma), `RPM` (apgriezieni minūtē) vai `VelocityUnits.DPS` (grādi sekundē).

# Turn at different velocities
# Default velocity
drivetrain.turn_for(RIGHT, 360)
wait(1, SECONDS)
# Turn slower
drivetrain.set_turn_velocity(20, PERCENT)
drivetrain.turn_for(RIGHT, 360)
wait(1, SECONDS)
# Turn faster
drivetrain.set_turn_velocity(100, PERCENT)
drivetrain.turn_for(RIGHT, 360)

set_stopping #

set_stopping nosaka, kā robots pārtrauks kustību: bremzējot, braucot brīvi vai turoties.

Usage:
drivetrain.set_stopping(mode)

Parametri	Apraksts
`mode`	Kā robots apstāsies: `BRAKE` — Apstājas nekavējoties. `COAST` — Palēnina gaitu līdz apstājas. `HOLD` — Apstājas nekavējoties un notur riteņu pozīciju.

Parametri

Apraksts

mode

Kā robots apstāsies:

BRAKE — Apstājas nekavējoties.
COAST — Palēnina gaitu līdz apstājas.
HOLD — Apstājas nekavējoties un notur riteņu pozīciju.

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

set_timeout #

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

Usage:
drivetrain.set_timeout(value, units)

Parametri	Apraksts
`value`	Laiks, kurā robots 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: `MSEC` (milisekundes, pēc noklusējuma) vai `SECONDS`.

# Turn right after driving forward
drivetrain.set_timeout(1, SECONDS)
drivetrain.drive_for(FORWARD, 25, INCHES)
drivetrain.turn_for(RIGHT, 90)

set_heading #

Virziens ir virziens, kurā robots ir pagriezies, mērot grādos. set_heading maina robota pašreizējo virzienu uz jaunu virziena vērtību.

Piemēram, ja robots ir pagriezies pa labi, iestatot virzienu uz 0 grādiem, šī pozīcija, kas vērsta pa labi, kļūst par jauno 0 grādu pozīciju. Pēc tam robots var pagriezties uz citām pozīcijām, pamatojoties uz šo jauno virzienu.

Usage:
drivetrain.set_heading(heading, units)

Parametri	Apraksts
`heading`	Virziena vērtība grādos vai pagriezienos, kas jāiestata robotam. Tā var būt vesels skaitlis `integer` vai decimālskaitlis (`float`).
`units`	Neobligāti. Virziena mērvienība: `DEGREES` (pēc noklusējuma) vai `TURNS`Viens pagrieziens ir vienāds ar 360 grādiem.

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

set_rotation #

Rotācija ir robota pagrieziena lielums, mērot grādos vai pagriezienos. Projekta sākumā rotācijas vērtība ir iestatīta uz 0 grādiem. set_rotation maina robota pašreizējo rotāciju uz jaunu vērtību.

Piemēram, ja robots ir veicis divus pilnus pagriezienus pa labi, tā rotācijas vērtība būs 720 grādi. Iestatot rotāciju uz 0 grādiem, šī rotācija tiks atiestatīta no 720 uz 0 grādiem. Pēc tam robots var veikt rotācijas, pamatojoties uz šo jauno vērtību.

Usage:
drivetrain.set_rotation(rotation, units)

Parametri	Apraksts
`rotation`	Robota iestatāmā rotācijas vērtība grādos vai pagriezienos. Tā var būt vesels skaitlis `integer` vai decimālskaitlis (`float`).
`units`	Pēc izvēles. Rotācijas vienība: `DEGREES` (pēc noklusējuma) vai `TURNS`Viens pagrieziens ir vienāds ar 360 grādiem.

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

set_turn_threshold #

set_turn_threshold nosaka, cik tuvu robotam jāpienāk mērķa leņķim, pirms pagrieziens ir pabeigts.

Mazāks slieksnis var padarīt pagriezienus precīzākus, taču robotam var būt nepieciešams ilgāks laiks, lai pabeigtu pagriezienu. Lielāks slieksnis var padarīt pagriezienus ātrākus, taču tie var būt mazāk precīzi.

Usage:
drivetrain.set_turn_threshold(value)

Parametri	Apraksts
`value`	Pagrieziena slieksnis grādos. Tas var būt vesels skaitlis `integer` vai decimālskaitlis (`float`). Noklusējuma pagrieziena slieksnis ir 1 grāds.

# Set the turn threshold to 5 degrees
drivetrain.set_turn_threshold(5)

set_turn_constant #

set_turn_constant maina, cik spēcīgi robots koriģē savus pagriezienus.

Augstāka vērtība liek robotam spēcīgāk koriģēt pagriezienus. Zemāka vērtība liek robotam maigāk koriģēt pagriezienus. Noklusējuma vērtība ir 1,0.

Usage:
drivetrain.set_turn_constant(value)

Parametri	Apraksts
`value`	Pagrieziena konstante. Tā var būt decimālskaitlis (`float`) no 0,1 līdz 4,0. Noklusējuma vērtība ir 1,0.

# Increase the turn constant to 2.0
drivetrain.set_turn_constant(2.0)

Getteri #

heading #

Virziens ir virziens, kurā robots ir pagriezies, mērot grādos. heading atgriež robota pašreizējo virzienu no 0 līdz 359 grādiem.

Robota sākuma virziens ir 0 grādi.

Usage:
drivetrain.heading(units)

Parametri	Apraksts
`units`	Neobligāti. Vienība, kurā jāatgriež kurss: `DEGREES` (pēc noklusējuma) vai `TURNS`Viens pagrieziens ir vienāds ar 360 grādiem.

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

rotation #

Rotācija ir robota pagrieziena lielums, mērot grādos vai pagriezienos. Projekta sākumā rotācijas vērtība ir iestatīta uz 0 grādiem. rotation atgriež robota pašreizējo rotāciju.

Pagriežoties pa labi, rotācija palielinās, bet pagriežoties pa kreisi, tā samazinās. Piemēram, veicot divus pilnus pagriezienus pa labi, rotācija būs 720 grādi.

Usage:
drivetrain.rotation(units)

Parametri	Apraksts
`units`	Neobligāti. Mērvienība, kas jāatgriež rotācijā: `DEGREES` (pēc noklusējuma) vai `TURNS`Viens pagrieziens ir vienāds ar 360 grādiem.

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

velocity #

velocity atgriež robota braukšanas ātrumu.

Tas var atgriezt ātrumu procentos no -100% līdz 100%, RPM no -127 apgr./min līdz 127 apgr./min vai VelocityUnits.DPS (grādi sekundē). Pozitīva vērtība nozīmē, ka robots brauc uz priekšu. Negatīva vērtība nozīmē, ka robots brauc atpakaļgaitā.

Usage:
drivetrain.velocity(units)

Parametri	Apraksts
`units`	Neobligāti. Mērvienība, kas jāatgriež ātrumā: `PERCENT` (noklusējums), `RPM` (apgriezieni minūtē) vai `VelocityUnits.DPS` (grādi sekundē).

current #

current atgriež piedziņas mehānisma patērētās elektriskās strāvas daudzumu, mērot ampēros (ampēros). Strāva ir elektroenerģijas daudzums, kas plūst caur piedziņas mehānismu.

Augstāka strāvas vērtība nozīmē, ka piedziņas sistēma patērē vairāk elektriskās strāvas. Tas var notikt, ja robots spiežas pret objektu vai mēģina kustēties, kad ir iestrēdzis.

To var izmantot, lai pārbaudītu, vai piedziņas mehānismam ir grūtības kustības laikā. Ja strāva saglabājas augsta, piedziņas mehānisms var sakarst vai mazāk efektīvi izmantot jaudu.

Usage:
drivetrain.current(units)

Parametri	Apraksts
`units`	Neobligāti. Mērvienība, kurā atgriezt strāvu: `CurrentUnits.AMP` (ampēri, noklusējums).

is_moving #

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

True — Robots kustas.
False — Robots nekustas.

Šī metode darbojas kopā ar šādām Drivetrain metodēm, kurām ir parametrs wait : drive_for, turn_for, turn_to_heading un turn_to_rotation.

Usage:
drivetrain.is_moving()

Parametri	Apraksts
	Šai metodei nav parametru.

is_done #

is_done atgriež, vai robots ir pabeidzis kustību, kā Būla vērtību. To var izmantot, lai kontrolētu citu darbību laiku, pamatojoties uz robota kustību.

True — Robots ir pabeidzis kustību.
False — Robots joprojām kustas.

Šī metode darbojas kopā ar šādām Drivetrain metodēm, kurām ir parametrs wait : drive_for, turn_for, turn_to_heading un turn_to_rotation.

Usage:
drivetrain.is_done()

Parametri	Apraksts
	Šai metodei nav parametru.

is_turning #

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

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

Šī metode darbojas kopā ar šādām Drivetrain metodēm, kurām ir parametrs wait : turn_for, turn_to_heading un turn_to_rotation.

Usage:
drivetrain.is_turning()

Parametri	Apraksts
	Šai metodei nav parametru.

power #

power atgriež piedziņas patērēto jaudu, mērot vatos. Jauda parāda, cik ātri piedziņa patērē enerģiju.

Augstāka jaudas vērtība nozīmē, ka piedziņas sistēma patērē enerģiju ātrāk. Tas var notikt, ja robots spiežas pret objektu vai mēģina kustēties, kad ir iestrēdzis.

To var izmantot, lai salīdzinātu kustības vai pārbaudītu, vai transmisijai ir problēmas. Ja jauda saglabājas augsta, transmisija var sakarst vai mazāk efektīvi izmantot enerģiju.

Usage:
drivetrain.power()

Parametri	Apraksts
	Šai metodei nav parametru.

torque #

Griezes moments parāda, cik stipri piedziņa var stumt vai vilkt, kamēr riteņi griežas.

torque atgriež piedziņas izmantoto griezes momentu, mērot ņūtonmetros (Nm) vai collās-mārciņās (InLb).

Augstāka griezes momenta vērtība nozīmē, ka piedziņas sistēma spiež vai velk spēcīgāk. Tas var notikt, ja robots spiežas pret objektu vai mēģina kustēties, kad ir iestrēdzis.

To var izmantot, lai pārbaudītu, vai transmisijai ir problēmas, vai lai salīdzinātu, cik liels grūdiens nepieciešams dažādām kustībām.

Usage:
drivetrain.torque(units)

Parametri	Apraksts
`units`	Neobligāti. Mērvienība griezes momenta atgriežamajai vērtībai: `TorqueUnits.NM` (ņūtonmetri, pēc noklusējuma) vai `TorqueUnits.INLB` (collas mārciņas).

efficiency #

efficiency atgriež piedziņas mehānisma jaudu izmantošanas efektivitāti procentos no 0% līdz 100%.

Efektivitāte parāda, cik liela daļa piedziņas mehānisma jaudas tiek izmantota kustībai. Augstāka efektivitātes vērtība nozīmē, ka lielāka daļa piedziņas mehānisma jaudas tiek izmantota kustībai. Zemāka efektivitātes vērtība var rasties, ja piedziņa strādā intensīvi, bet nekustas daudz, piemēram, ja robots ir iestrēdzis vai spiežas pret kādu objektu.

To var izmantot, lai salīdzinātu kustības vai pārbaudītu, vai piedziņa neizšķiež jaudu, nevis izmanto to kustībai.

Usage:
drivetrain.efficiency()

Parametri	Apraksts
	Šai metodei nav parametru.

temperature #

temperature atgriež piedziņas mehānisma vidējo temperatūru atlasītajā temperatūras vienībā.

Temperatūra parāda, cik silti ir piedziņas motori. Augstāka temperatūra nozīmē, ka motori darbības laikā kļūst siltāki. Lai motori darbotos ar pilnu jaudu, to temperatūrai jābūt zem 55 °C.

Ja motori kļūst pārāk karsti, tie samazina maksimālo strāvu, lai sevi pasargātu. Sasniedzot 70 °C temperatūru, motori pārstāj darboties, līdz tie atdziest.

To var izmantot, lai pārbaudītu, vai piedziņas sistēma kļūst pārāk karsta atkārtotu kustību, garu braucienu laikā vai spiežoties pret kādu objektu.

Usage:
drivetrain.temperature(units)

Parametri	Apraksts
`units`	Neobligāti. Temperatūras atgriežamā mērvienība: `TemperatureUnits.CELSIUS` (pēc noklusējuma) vai `TemperatureUnits.FAHRENHEIT`.

Konstruktori #

Konstruktori tiek izmantoti, lai kodā izveidotu DriveTrain un SmartDrive objektus. Tas ir noderīgi, konfigurējot piedziņas sistēmu, neizmantojot logu Devices (Ierīces).

Pirms piedziņas mehānisma izveides ir jāizveido vismaz divi Motor vai MotorGroup objekti.

DriveTrain #

DriveTrain izveido piedziņas sistēmu bez žiroskopiskā sensora vai inerciālā sensora.

Usage:
DriveTrain(lm, rm, wheelTravel, trackWidth, wheelBase, units, externalGearRatio)

Parametrs	Apraksts
`lm`	Kreisais motors vai motoru grupa.
`rm`	Labais motors vai motoru grupa.
`wheelTravel`	Pēc izvēles. Piedziņas riteņu apkārtmērs. Noklusējuma vērtība ir 300 milimetri.
`trackWidth`	Pēc izvēles. Attālums starp kreiso un labo riteni. Noklusējuma vērtība ir 320 milimetri.
`wheelBase`	Pēc izvēles. Attālums starp priekšējiem un aizmugurējiem riteņiem. Noklusējuma vērtība ir 320 milimetri.
`units`	Neobligāti. Vienība `wheelTravel`, `trackWidth`un `wheelBase`: `MM` (milimetri, pēc noklusējuma), `INCHES`vai `DistanceUnits.CM` (centimetri).
`externalGearRatio`	Neobligāti. Pārnesumu attiecība, ko izmanto, lai pielāgotu piedziņas attālumus, ja tiek izmantoti pārnesumi. Tā var būt vesels skaitlis `integer` vai decimālskaitlis (`float`). Noklusējuma vērtība ir 1,0.

# Create left and right drive motor objects
left_drive_smart = Motor(Ports.PORT1, 1.0, False)
right_drive_smart = Motor(Ports.PORT2, 1.0, True)

'''
Create a Drivetrain with the following values:
wheelTravel: 200
trackWidth: 173
wheelBase: 76
units: MM
externalGearRatio: 1
'''
drivetrain = DriveTrain(left_drive_smart, right_drive_smart, 200, 173, 76, MM, 1)

# Create two motor group objects for left and right motors
left_motor_a = Motor(Ports.PORT1, 1.0, False)
left_motor_b = Motor(Ports.PORT2, 1.0, False)
left_drive_smart = MotorGroup(left_motor_a, left_motor_b)

right_motor_a = Motor(Ports.PORT3, 1.0, True)
right_motor_b = Motor(Ports.PORT4, 1.0, True)
right_drive_smart = MotorGroup(right_motor_a, right_motor_b)

'''
Create a Drivetrain with the following values:
wheelTravel: 200
trackWidth: 173
wheelBase: 76
units: MM
externalGearRatio: 1
'''
drivetrain = DriveTrain(left_drive_smart, right_drive_smart, 200, 173, 76, MM, 1)

SmartDrive #

SmartDrive izveido piedziņas sistēmu ar žiroskopisko sensoru vai inerciālo sensoru.

Usage:
SmartDrive(lm, rm, g, wheelTravel, trackWidth, wheelBase, units, externalGearRatio)

Parametrs	Apraksts
`lm`	Kreisais motors vai motoru grupa.
`rm`	Labais motors vai motoru grupa.
`g`	Piedziņas mehānismā izmantotais žiroskopiskais sensors vai inerciālais sensors.
`wheelTravel`	Pēc izvēles. Piedziņas riteņu apkārtmērs. Noklusējuma vērtība ir 300 milimetri.
`trackWidth`	Pēc izvēles. Attālums starp kreiso un labo riteni. Noklusējuma vērtība ir 320 milimetri.
`wheelBase`	Pēc izvēles. Attālums starp priekšējiem un aizmugurējiem riteņiem. Noklusējuma vērtība ir 320 milimetri.
`units`	Neobligāti. Vienība `wheelTravel`, `trackWidth`un `wheelBase`: `MM` (milimetri, pēc noklusējuma), `INCHES`vai `DistanceUnits.CM` (centimetri).
`externalGearRatio`	Neobligāti. Pārnesumu attiecība, ko izmanto, lai pielāgotu piedziņas attālumus, ja tiek izmantoti pārnesumi. Tā var būt vesels skaitlis `integer` vai decimālskaitlis (`float`). Noklusējuma vērtība ir 1,0.

# Create the Inertial Sensor
brain_inertial = Inertial()

# Make left and right drive motors
left_drive_smart = Motor(Ports.PORT1, 1.0, False)
right_drive_smart = Motor(Ports.PORT6, 1.0, True)

# Create a SmartDrive object with wheelTravel 200
drivetrain = SmartDrive(left_drive_smart, right_drive_smart, brain_inertial, 200)

Ja veidojat viedu piedziņas sistēmu ar vairākiem motoriem, motori ir jāizveido atsevišķi, pirms tos grupējat motoru grupā.

# Create the Inertial Sensor
brain_inertial = Inertial()

# Create two motor groups for left and right motors
left_motor_a = Motor(Ports.PORT1, 1.0, False)
left_motor_b = Motor(Ports.PORT2, 1.0, False)
left_drive_smart = MotorGroup(left_motor_a, left_motor_b)

right_motor_a = Motor(Ports.PORT5, 1.0, True)
right_motor_b = Motor(Ports.PORT6, 1.0, True)
right_drive_smart = MotorGroup(right_motor_a, right_motor_b)

# Create a SmartDrive object with wheelTravel 200 mm
drivetrain = SmartDrive(left_drive_smart, right_drive_smart, brain_inertial, 200)