Kustība#

Ievads #

VEX AIR dronam ir četri propelleru dzinēji, kas ļauj tam pārvietoties jebkurā virzienā un neatkarīgi rotēt. Kustība nodrošina kustības, pagriešanās, ātruma regulēšanas un pozīcijas izsekošanas metodes.

Apļveida kompasa ciparnīca no 0 līdz 360 grādiem, kas apņem dronu ar 4 propelleriem. Drona priekšpuse ir vērsta 0 grādu leņķī uz kompasa ciparnīcas.

Zemāk ir visu pieejamo metožu saraksts:

Darbības

take_off – Paceļ dronu līdz norādītajam augstumam.
land – Nosēžas drons.
hover — Notur dronu tā pozīcijā.
climb – Pārvieto dronu noteiktā vertikālā virzienā.
climb_for – Pārvieto dronu noteiktā vertikālā virzienā noteiktā attālumā.
climb_to – Pārvieto dronu uz norādīto augstumu.
move_at – Pārvieto dronu ar noteiktu virzienu un ātrumu.
move_for – Pārvieto dronu noteiktā virzienā noteiktā attālumā.
move_to – Pārvieto dronu uz noteiktu pozīciju, saglabājot to pašu kursu.
turn – Pagriež dronu pa kreisi vai pa labi.
turn_for – Pagriež dronu par noteiktu grādu skaitu.
turn_to – Pagriež dronu noteiktā virzienā.
move_with_vectors – Pārvieto dronu, izmantojot uz vektoriem balstītas x, y, z un rotācijas vērtības.

Mutatori

set_steering_mode – Iestata drona stūrēšanas skatupunktu (POV).
set_movement_mode – Iestata drona kustības stilu.
set_climb_velocity – Iestata noklusējuma kāpšanas ātrumu.
set_move_velocity – Iestata noklusējuma kustības ātrumu.
set_turn_velocity — Iestata noklusējuma pagrieziena ātrumu.
set_max_z_height — Nosaka ierobežojumu drona lidošanas augstumam.
set_xyz_position – Iestata drona pašreizējo pozīciju.

Geters

get_max_z_height – Atgriež maksimālo augstumu, ko drons var sasniegt.
get_flight_state – Atgriež drona pašreizējo stāvokli.
get_x_position – Atgriež drona x koordinātu.
get_y_position – Atgriež drona y koordinātu.
get_z_position – Atgriež drona z koordinātu.
get_safe_mode – Atgriež drona propellera bloķēšanas stāvokli.
is_climb_active – Atgriež, vai drons pašlaik kāpj.
is_move_active – Atgriež, vai drons pašlaik kustas.
is_turn_active – Atgriež, vai drons pašlaik griežas.
is_hovering — Atgriež, vai drons pašlaik atrodas gaisā.
is_taking_off – Atgriež, vai drons pašlaik paceļas.
is_landing – Atgriež, vai drons pašlaik nolaižas.
is_landed — Atgriež, vai drons pašlaik ir nosēdies.

Darbības #

take_off #

take_off iedarbina propellerus un paceļ dronu gaisā. Šī metode jāizmanto pirms citu kustību veikšanas.

Lietojums:

drone.take_off(climb_to, units, wait)

Parametri	Apraksts
`climb_to`	Z pozīcija (augstums), uz kuru drons lidos.
`units`	Lietojamā mērvienība: `CM` - centimetri `MM` - milimetri `INCHES`
`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.

Parametri

Apraksts

climb_to

Z pozīcija (augstums), uz kuru drons lidos.

units

Lietojamā mērvienība:

CM - centimetri
MM - milimetri
INCHES

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.

# Fly for 1 second
drone.take_off(climb_to=500)
wait(1, SECONDS)
drone.land()

land #

land nolaiž dronu uz zemes. Propelleri turpinās darboties, līdz projekts tiks apturēts.

Lietojums:

drone.land(wait)

Parametri	Apraksts
`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.

# Land after 1 second
drone.take_off(climb_to=500)
wait(1, SECONDS)
drone.land()

hover #

hover aptur drona kustību jebkurā virzienā un notur tā pašreizējo pozīciju gaisā.

Usage:
drone.hover()

Parametri	Apraksts
	Šai metodei nav parametru.

# Hold current position for 3 seconds after moving forward
drone.take_off(climb_to=500)
drone.move_at(direction=0, velocity=50)
wait(1, SECONDS)
drone.hover()
wait(3, SECONDS)
drone.land()

climb #

climb pārvieto dronu noteiktā vertikālā virzienā.

Usage: drone.climb(direction, velocity)

Parametri	Apraksts
`direction`	Drona lidojuma virziens: `UP` vai `DOWN`.
`velocity`	Ātrums procentos, ar kādu drons pacelsies.

# Climb upwards for 2 seconds
drone.take_off(climb_to=500)
wait(2, SECONDS)
drone.climb(direction=UP)
wait(2, SECONDS)
drone.land()

climb_for #

climb_for pārvieto dronu noteiktā vertikālā virzienā noteiktā attālumā.

Lietojums:

drone.climb_for(direction, distance, units, velocity, wait)

Parametri	Apraksts
`direction`	Drona lidojuma virziens: `UP` vai `DOWN`.
`distance`	Attālums, kādu drons veiks.
`units`	Pēc izvēles. Mērvienība, kas attēlo attālumu: `CM` – centimetri `MM` (pēc noklusējuma) – milimetri `INCHES`
`velocity`	Neobligāti. Ātrums procentos, ar kādu drons pacelsies. Ja ātrums nav norādīts, noklusējuma ātrums ir 50%.
`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.

# Lower drone before landing
drone.take_off(climb_to=700)
wait(2, SECONDS)
drone.climb_for(direction=DOWN, distance=300)
wait(2, SECONDS)
drone.land()

climb_to #

climb_to pārvieto dronu uz noteiktu z pozīciju.

Lietojums:

drone.climb_to(z, units, velocity, wait)

Parametri	Apraksts
`z`	Z pozīcija, kas norādīta kā vesels skaitlis vai decimālskaitlis, līdz kuram drons pacelsies.
`units`	Pēc izvēles. Mērvienība, kas attēlo attālumu: `CM` – centimetri `MM` (pēc noklusējuma) – milimetri `INCHES`
`velocity`	Neobligāti. Ātrums procentos, ar kādu drons pacelsies.
`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.

# Reach 500 mm after takeoff
drone.take_off(climb_to=300)
wait(1, SECONDS)
drone.climb_to(z=500)
wait(1, SECONDS)
drone.land()

move_at #

move_at pārvieto dronu noteiktā leņķī un ātrumā.

Lietojums:

drone.move_at(angle, velocity)

Parametri	Apraksts
`angle`	Leņķis (vesels skaitlis vai decimāldaļa), kādā drons pārvietojas, diapazonā no 0 līdz 359 grādiem.
`velocity`	Ātrums, ar kādu drons pārvietosies, procentos.

# Move left for 2 seconds
drone.take_off(climb_to=500)
drone.move_at(angle=270)
wait(2, SECONDS)
drone.land()

move_for #

move_for pārvieto dronu noteiktā virzienā noteiktā attālumā, izmantojot pašreizējo set_move_velocity.

Lietojums:

drone.move_for(angle, distance, units, velocity, wait)

Parametri	Apraksts
`angle`	Leņķis kā vesels skaitlis vai decimālskaitlis (float), kādā drons pārvietojas, diapazonā no 0 līdz 359 grādiem.
`distance`	Attālums, kas norādīts kā vesels skaitlis vai decimālskaitlis, kādā drons pārvietosies.
`units`	Pēc izvēles. Mērvienība, kas attēlo attālumu: `CM` – centimetri `MM` (pēc noklusējuma) – milimetri `INCHES`
`velocity`	Neobligāti. Ātrums, ar kādu drons pārvietosies, procentos.
`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.

# Move forward for 200 mm
drone.take_off(climb_to=500)
wait(1, SECONDS)
drone.move_for(direction=0, distance=200, velocity=50, units=MM)
wait(1, SECONDS)
drone.land()

move_to #

move_to pārvieto dronu uz noteiktu pozīciju gaisā, saglabājot to pašu kursu.

Lietojums:

drone.move_to(x, y, z, units, move_velocity, climb_velocity, wait)

Parametri	Apraksts
`x`	X koordināta, uz kuru drons pārvietosies.
`y`	Y koordināta, uz kuru drons pārvietosies.
`z`	Z koordināta, uz kuru drons pārvietosies.
`units`	Pēc izvēles. Mērvienība, kas attēlo attālumu: `CM` – centimetri `MM` (pēc noklusējuma) – milimetri `INCHES`
`move_velocity`	Neobligāti. Ātrums, ar kādu drons pārvietosies, procentos.
`climb_velocity`	Neobligāti. Ātrums procentos, ar kādu drons pacelsies.
`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.

# Move diagonally to (300, 300, 800)
drone.take_off(climb_to=300)
wait(2, SECONDS)
drone.move_to(x=300, y=300, z=800)
wait(2, SECONDS)
drone.land()

turn #

turn pagriež dronu noteiktā virzienā, izmantojot pašreizējo set_turn_velocity.

Lietojums:

drone.turn(direction, velocity)

Parametri	Apraksts
`direction`	Drona pagrieziena virziens: `LEFT` vai `RIGHT`.
`velocity`	Neobligāti. Ātrums, ar kādu drons pagriezīsies procentos.

# Turn to the right for 2 seconds
drone.take_off(climb_to=500)
wait(1, SECONDS)
drone.turn(RIGHT, 50)
wait(2, SECONDS)
drone.land()

turn_for #

turn_for pagriež dronu noteiktā virzienā noteiktā attālumā attiecībā pret tā pašreizējo vēršanās virzienu, izmantojot pašreizējo set_turn_velocity.

Lietojums:

drone.turn_for(direction, angle, velocity, wait)

Parametri	Apraksts
`direction`	Drona pagrieziena virziens: `LEFT` vai `RIGHT`.
`angle`	Leņķis kā vesels skaitlis vai decimālskaitlis (float), kādā drons pagriežas, diapazonā no 0 līdz 359 grādiem.
`velocity`	Neobligāti. Ātrums, ar kādu drons pagriezīsies procentos.
`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.

# Turn around, then land
drone.take_off(climb_to=500)
wait(1, SECONDS)
drone.turn_for(RIGHT, 180)
wait(1, SECONDS)
drone.land()

turn_to #

turn_to pagriež dronu noteiktā virzienā, izmantojot pašreizējo set_turn_velocity.

Lietojums:

drone.turn_to(heading, velocity, wait)

Parametri	Apraksts
`heading`	Virziens, kādā drons pagriezīsies no 0 līdz 360 grādiem.
`velocity`	Neobligāti. Ātrums, ar kādu drons pagriezīsies procentos.
`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.

# Turn to face each of the cardinal headings
drone.take_off(climb_to=500)
drone.turn_to(heading=90, velocity=50)
wait(3, SECONDS)
drone.turn_to(heading=180, velocity=50)
wait(3, SECONDS)
drone.turn_to(heading=270, velocity=50)
wait(3, SECONDS)
drone.turn_to(heading=0, velocity=50)
wait(3, SECONDS)
drone.land()

move_with_vectors #

move_with_vectors pārvieto dronu, izmantojot uz vektoriem balstītu kustību, apvienojot kustību pa x asi (horizontāli) un y asi (vertikāli), vienlaikus pagriežot dronu.

Piezīme: Šī metode iestata kustības un pagrieziena ātruma vērtības tieši, tāpēc tā neizmanto set_move_velocity vai set_turn_velocity.

Lietojums:

drone.move_with_vectors(forward, rightward, upward, rotation)

Parametri	Apraksts
`forward`	Drona ātrums pa Y asi (kustība uz priekšu un atpakaļ). Pieņem vērtību no -100 līdz 100 procentos, kur negatīvas vērtības pārvietojas atpakaļ, bet pozitīvas vērtības - uz priekšu.
`rightward`	Drona ātrums pa X asi (kustība no vienas puses uz otru). Pieņem vērtību no -100 līdz 100 procentos, kur negatīvas vērtības pārvietojas pa kreisi, bet pozitīvas vērtības pārvietojas pa labi.
`upward`	Drona ātrums pa Z asi (kustība augšup un lejup). Pieņem vērtību no -100 līdz 100 procentos, kur negatīvas vērtības pārvietojas uz leju, bet pozitīvas vērtības - uz augšu.
`rotation`	Drona rotācijas ātrums. Pieņem vērtību no -100 līdz 100 procentos, kur negatīvās vērtības griežas pretēji pulksteņrādītāja virzienam, bet pozitīvās vērtības - pulksteņrādītāja virzienā.

# Move with controller
drone.take_off(climb_to=500)
while True:
    drone.move_with_vectors(
        forward=controller.axis4.position(),
        rightward=controller.axis3.position(),
        upward=controller.axis1.position(),
        rotation=controller.axis2.position()
    )
    wait(5, MSEC)

Mutatori #

set_steering_mode #

set_steering_mode iestata skatupunktu, kas tiek izmantots, vadot dronu.

Lietojums:

drone.set_steering_mode(style)

Parametri	Apraksts
`style`	Iestata skatupunktu, kas tiek izmantots drona vadīšanai. `HEADLESS` nozīmē, ka drons pārvietojas attiecībā pret to, kur tas bija vērsts projekta sākumā. `STANDARD` tiek izmantots pēc noklusējuma, un tas liek dronam pārvietoties attiecībā pret to, kur tas ir vērsts.

# Steer based on the drone's starting orientation
# until button 7 is pressed
drone.take_off(climb_to=500)
drone.set_steering_mode(HEADLESS)
while not controller.button7.pressing():
    drone.move_with_vectors(
        forward=controller.axis4.position(),
        rightward=controller.axis3.position(),
        upward=controller.axis1.position(),
        rotation=controller.axis2.position()
    )
    wait(5, MSEC)
drone.land()

set_movement_mode #

set_movement_mode iestata drona kustības stilu.

Šis kustības stils tiek izmantots, vadot dronu ar kontrolieri.

Lietojums:

drone.set_movement_mode(style)

Parametri	Apraksts
`style`	Iestata ātrumu, kas tiek izmantots drona stūrēšanai. `BALANCED` – Drons pārvietojas ar vidēju pamata ātrumu. `PERFORMANCE` – Drons pārvietojas ar lielāku pamata ātrumu. `PRECISION` (pēc noklusējuma) – Drons pārvietojas ar lēnāku pamata ātrumu.

Parametri

Apraksts

style

Iestata ātrumu, kas tiek izmantots drona stūrēšanai.

BALANCED – Drons pārvietojas ar vidēju pamata ātrumu.
PERFORMANCE – Drons pārvietojas ar lielāku pamata ātrumu.
PRECISION (pēc noklusējuma) – Drons pārvietojas ar lēnāku pamata ātrumu.

# Control the drone with the balanced movement style
drone.take_off(climb_to=500)
drone.set_movement_mode(BALANCED)
while not controller.button5.pressing():
    drone.move_with_vectors(
        forward=controller.axis4.position(),
        rightward=controller.axis3.position(),
        upward=controller.axis1.position(),
        rotation=controller.axis2.position()
    )
    wait(5, MSEC)
drone.land()

set_climb_velocity #

set_climb_velocity iestata noklusējuma kāpšanas ātrumu procentos. Tas ietekmēs visas turpmākās ar kāpšanu saistītās metodes. Noklusējuma kāpšanas ātrums ir 50%.

Lietojums:

drone.set_climb_velocity(velocity)

Parametri	Apraksts
`velocity`	Ātrums procentos, ar kādu drons pacelsies.

# Raise the drone quickly before landing
drone.take_off(climb_to=300)
wait(1, SECONDS)
drone.set_climb_velocity(100)
drone.climb_for(direction=UP, distance=500)
wait(1, SECONDS)
drone.land()

set_move_velocity #

set_move_velocity iestata noklusējuma kustības ātrumu procentos. Tas ietekmēs visas turpmākās ar pārvietošanu saistītās metodes. Noklusējuma kustības ātrums ir 50%.

Lietojums:

drone.set_move_velocity(velocity)

Parametri	Apraksts
`velocity`	Ātrums, ar kādu drons pārvietosies, procentos.

# Move forward quickly, then reverse slowly
drone.take_off(climb_to=500)
drone.set_move_velocity(100)
drone.move_for(direction=0, distance=500)
wait(3, SECONDS)
drone.set_move_velocity(20)
drone.move_for(direction=180, distance=500)
wait(5, SECONDS)
drone.land()

set_turn_velocity #

set_turn_velocity iestata noklusējuma pagrieziena ātrumu procentos. Tas ietekmēs visas turpmākās ar pagriezienu saistītās metodes. Noklusējuma pagrieziena ātrums ir 50%.

Lietojums:

drone.set_turn_velocity(velocity)

Parametri	Apraksts
`velocity`	Ātrums, ar kādu drons pagriezīsies, procentos.

# Turn clockwise quickly, then counterclockwise slowly
drone.take_off(climb_to=500)
drone.set_turn_velocity(100)
drone.turn_for(RIGHT, 360)
wait(3, SECONDS)
drone.set_turn_velocity(20)
drone.turn_for(LEFT, 360)
wait(5, SECONDS)
drone.land()

set_max_z_height #

set_max_z_height nosaka ierobežojumu tam, cik augstu drons lidos.

Lietojums:

drone.set_max_z_height(z_height, units)

Parametri	Apraksts
`z_height`	Maksimālā z ass vērtība kā vesels skaitlis vai decimāldaļa, virs kuras drons nelidos, diapazonā no 1000 līdz 5000 mm vai no 40 līdz 196 collām.
`units`	Pēc izvēles. Attāluma mērvienības ir: `CM` – centimetri `MM` (pēc noklusējuma) – milimetri `INCHES`

Parametri

Apraksts

z_height

Maksimālā z ass vērtība kā vesels skaitlis vai decimāldaļa, virs kuras drons nelidos, diapazonā no 1000 līdz 5000 mm vai no 40 līdz 196 collām.

units

Pēc izvēles. Attāluma mērvienības ir:

CM – centimetri
MM (pēc noklusējuma) – milimetri
INCHES

# Fly with controller under 1000 mm
drone.set_max_z_height(1000, MM)
drone.take_off(climb_to=500)
while not controller.button7.pressing():
    drone.move_with_vectors(
        forward=controller.axis4.position(),
        rightward=controller.axis3.position(),
        upward=controller.axis1.position(),
        rotation=controller.axis2.position()
    )
drone.land()

set_xyz_position #

set_xyz_position iestata drona pašreizējo x, y vai z koordinātu uz norādīto vērtību.

Lietojums:

drone.set_xyz_position(x, y, z, units)

Piezīme: Visi parametri ir neobligāti, taču ir jānorāda vismaz viens (x, yvai z).

Parametri	Apraksts
`x`	Neobligāti. Drona x koordināta, kas jāiestata `units` kā decimālskaitlis (float) vai vesels skaitlis.
`y`	Neobligāti. Drona y koordināta, kas jāiestata `units` vienībās kā decimālskaitlis (float) vai vesels skaitlis.
`z`	Neobligāti. Drona z koordināta, kas jāiestata `units` kā decimālskaitlis (float) vai vesels skaitlis.
`units`	Pēc izvēles. Mērvienība, kas attēlo attālumu: `CM` – centimetri `MM` (pēc noklusējuma) – milimetri `INCHES`

# Set a new z position, then fly to z position -300
drone.take_off(climb_to=800)
drone.set_xyz_position(z=0)
wait(1, SECONDS)
drone.climb(DOWN, 50)
while not drone.get_z_position() < -300:
    wait(5, MSEC)
drone.hover()
wait(1, SECONDS)
drone.land()

Getteri #

get_max_z_height #

get_max_z_height atgriež maksimālo augstumu, ko drons var sasniegt, kā veselu skaitli.

Lietojums:

drone.get_max_z_height(units)

Parametri	Apraksts
`units`	Pēc izvēles. Mērvienība: `CM` – centimetri `MM` (pēc noklusējuma) – milimetri `INCHES`

Parametri

Apraksts

units

Pēc izvēles. Mērvienība:

CM – centimetri
MM (pēc noklusējuma) – milimetri
INCHES

# Display the new z height limit
controller.screen.print(drone.get_max_z_height(MM))
controller.screen.next_row()
drone.take_off(climb_to=500)
drone.set_max_z_height(1000)
controller.screen.print(drone.get_max_z_height(MM))
wait(1, SECONDS)
drone.land()

get_flight_state #

get_flight_state atgriež drona pašreizējo lidošanas stāvokli kā DroneFlightStateType:

MOTOR_OFF — Nav citu lidojuma stāvokļu.
CALIBRATION — Drons kalibrē savus sensorus.
MOTOR_START — Drons iedarbina motorus.
FLIGHT_READY — Drons ir gatavs lidojumam.
FLIGHT - Drons atrodas lidojumā.

Usage:
drone.get_flight_state()

Parametri	Apraksts
	Šai metodei nav parametru.

# Report the flight status as the drone takes off
controller.screen.print("Preparing for flight!")
controller.screen.next_row()
drone.take_off(climb_to=800, wait=False)
while not drone.get_flight_state() == MOTOR_START:
    wait(5, MSEC)
controller.screen.print("Motors starting...")
controller.screen.next_row()
while not drone.get_flight_state() == FLIGHT:
    wait(5, MSEC)
controller.screen.print("Take off!")

get_x_position #

get_x_position atgriež drona x koordinātu kā decimālskaitli (float).

Usage:
drone.get_x_position(units)

Parametri	Apraksts
`units`	Pēc izvēles. Vienība, kas attēlo pozīciju: `CM` – centimetri `MM` (pēc noklusējuma) – milimetri `INCHES`

Parametri

Apraksts

units

Pēc izvēles. Vienība, kas attēlo pozīciju:

CM – centimetri
MM (pēc noklusējuma) – milimetri
INCHES

# Move to (200, 0, 500)
drone.take_off(climb_to=500)
wait(1, SECONDS)
drone.move_at(direction=90, velocity=50)
while not drone.get_x_position() > 200:
    wait(5, MSEC)
drone.hover()
wait(1, SECONDS)
drone.land()

get_y_position #

get_y_position atgriež drona y koordinātu kā decimālskaitli (float).

Lietojums:

drone.get_y_position(units)

Parametri	Apraksts
`units`	Pēc izvēles. Vienība, kas attēlo pozīciju: `CM` – centimetri `MM` (pēc noklusējuma) – milimetri `INCHES`

Parametri

Apraksts

units

Pēc izvēles. Vienība, kas attēlo pozīciju:

CM – centimetri
MM (pēc noklusējuma) – milimetri
INCHES

# Move to (0, 200, 500)
drone.take_off(climb_to=500)
wait(1, SECONDS)
drone.move_at(direction=0, velocity=50)
while not drone.get_y_position() > 200:
    wait(5, MSEC)
drone.hover()
wait(1, SECONDS)
drone.land()

get_z_position #

get_y_position atgriež drona z koordinātu kā decimālskaitli (float).

Lietojums:

drone.get_z_position(units)

Parametri	Apraksts
`units`	Pēc izvēles. Vienība, kas attēlo pozīciju: `CM` – centimetri `MM` (pēc noklusējuma) – milimetri `INCHES`

Parametri

Apraksts

units

Pēc izvēles. Vienība, kas attēlo pozīciju:

CM – centimetri
MM (pēc noklusējuma) – milimetri
INCHES

# Move to (0, 0, 800)
drone.take_off(climb_to=500)
wait(1, SECONDS)
drone.climb(UP, 50)
while not drone.get_z_position() > 800:
    wait(5, MSEC)
drone.hover()
wait(1, SECONDS)
drone.land()

get_safe_mode #

get_safe_mode atgriež Boolean kas norāda, vai dronam ir iespējota propellera bloķēšana.

True – Propellera bloķēšana ir iespējota.
False – Propellera bloķēšana nav iespējota.

Lietojums:

drone.get_safe_mode()

Parametri	Apraksts
	Šai metodei nav parametru.

# Change the sound by enabling the Propeller Lock
while True:
    if drone.get_safe_mode():
        controller.sound.play(FAULT)
        while controller.sound.is_active():
            wait(50, MSEC)
    else:
        controller.sound.play(SUCCESS)
        while controller.sound.is_active():
            wait(50, MSEC)
    wait(5, MSEC)

is_climb_active #

is_climb_active atgriež Boolean , kas norāda, vai drons kāpj.

True – Drons pašlaik kāpj.
False – Drons neuzkāpj.

Lietojums:

drone.is_climb_active()

Parametri	Apraksts
	Šai metodei nav parametru.

# After the drone starts to climb, play a sound and land
drone.take_off(climb_to=500)
drone.climb(UP, 50)
wait(3, SECONDS)
if drone.is_climb_active():
    controller.sound.play(SUCCESS)
    drone.land()

is_move_active #

is_move_active atgriež Boolean , kas norāda, vai drons pašlaik izmanto pārvietošanas metodi.

True — Drons pašlaik izmanto pārvietošanas metodi.
False – Drons pašlaik neizmanto pārvietošanas metodi.

Lietojums:

drone.is_move_active()

Parametri	Apraksts
	Šai metodei nav parametru.

# After the drone starts to move, play a sound and land
drone.take_off(climb_to=500)
drone.move_at(direction=0, velocity=50)
wait(2, SECONDS)
if drone.is_move_active():
    controller.sound.play(SUCCESS)
    drone.land()

is_turn_active #

is_turn_active atgriež Boolean kas norāda, vai drons griežas.

True – Drons pašlaik griežas.
False – Drons negriežas.

Lietojums:

drone.is_turn_active()

Parametri	Apraksts
	Šai metodei nav parametru.

# After the drone starts to turn, play a sound and land
drone.take_off(climb_to=500)
drone.turn(RIGHT)
wait(2, SECONDS)
if drone.is_turn_active():
    controller.sound.play(LOOPING)
    while controller.sound.is_active():
        wait(50, MSEC)
    drone.land()

is_hovering #

is_hovering atgriež Boolean kas norāda, vai drons saglabā savu pozīciju (lido virs galvas).

True — drons pašlaik saglabā savu pozīciju (lido gaisā).
False – Drons pašlaik maina savu pozīciju.

Lietojums:

drone.is_hovering()

Parametri	Apraksts
	Šai metodei nav parametru.

# Play a sound after the drone has finished taking off
drone.take_off(climb_to=700)
while not drone.is_hovering():
    wait(5, MSEC)
controller.sound.play(PAUSE)
wait(2, SECONDS)
drone.land()

is_taking_off #

is_taking_off atgriež Boolean kas norāda, vai drons pacelšanās procesā.

True — Drons pašlaik pacelšanās procesā.
False – Drons nepaceļas.

Lietojums:

drone.is_taking_off()

Parametri	Apraksts
	Šai metodei nav parametru.

# Play sounds while the drone is taking off
drone.take_off(700, wait=False)
wait(1, SECONDS)
while drone.is_taking_off():
    controller.sound.play(LOOPING)
    wait(5, MSEC)

is_landing #

is_landing atgriež Boolean , kas norāda, vai drons veic nosēšanos.

True – Drons pašlaik veic nosēšanos.
False – Drons nenonāk nosēšanās procesā.

Lietojums:

drone.is_landing()

Parametri	Apraksts
	Šai metodei nav parametru.

# Play sounds while the drone is landing
drone.take_off(climb_to=500)
wait(1, SECONDS)
drone.land(wait=False)
wait(1, SECONDS)
while drone.is_landing():
    controller.sound.play(LOOPING)
    wait(5, MSEC)

is_landed #

is_landed atgriež Boolean , kas norāda, vai drons pašlaik ir nosēdies.

True – Drons ir nosēdies.
False – Drons nav nosēdies.

Lietojums:

drone.is_landed()

Parametri	Apraksts
	Šai metodei nav parametru.

# Celebrate a successful landing
drone.take_off(climb_to=500)
wait(1, SECONDS)
drone.land()
wait(1, SECONDS)
if drone.is_landed():
    controller.sound.play(SUCCESS)