Az itt található információkat oktatási céllal osztottam meg katonai főiskolások számára! Kihagytam azokat az információkat, amik Titkosak vagy Nemzetbiztonsági kockázatot jelentenek! Jelen információk mindenki számára elérhetők az interneten. A ProTAR-ról (F4-J)mindenki hallott már. A képek csak illusztrációk! Az itt szereplő forráskódok veszélyesek, csak felelősséggel alkalmazzák! Az avionikai részével később foglalkozunk.
Drónok önszerveződő, összehangolása a mai témánk. Többféle programozási nyelvet használnak, C sharp, Jawa, Python stb.
Nézzünk egy példát;
# Felszállás
tello.takeoff()
# Mozgásvezérlés
tello.move_forward(30)
tello.rotate_clockwise(90)
tello.move_forward(30)
# Leszállás
tello.land()
# Kapcsolat bontása
tello.end()
A drón djitellopy könyvtárat használ a vezérléséhez. A vezárlő először csatlakozik a drónhoz, majd felszáll vele, és egyszerű mozgásokat végez. Végül leszáll és bontja a kapcsolatot. Fontos, a kód működéséhez szükséges programok feltelepítése, a DJI Tello drón, a djitellopy könyvtár telepítése, és az eszköz csatlakoztatása a drónhoz. A drón vezérlése más és más a drón típusától függően, és minden drónnak saját API-ja és vezérlő szoftvere van. Az ilyen API-k és könyvtárak rendszerint dokumentáltak.
Először is telepítse a djitellopy nevű Python könyvtárat a DJI Tello drón vezérléséhez:
pip install djitellopy
Ezután készítsen egy egyszerű Python programot a drón vezérléséhez:
from djitellopy import Tello
import time
# Inicializálja a drón kapcsolatát
tello = Tello()
tello.connect()
# Ellenőrzi a drón állapotát
print(f"Akkumulátor: {tello.get_battery()}%")
tello.takeoff()
# Mozgatja a drónt
tello.move_up(30)
tello.move_forward(50)
tello.rotate_clockwise(90)
tello.move_forward(50)
# Leszáll
tello.land()
# Zárja be a kapcsolatot a drónnal
tello.end()
Ez a kód részlet inicializálja a drón kapcsolatát, felszáll vele, végrehajt néhány mozgást, majd leszáll.
A drón navigáció
A drón navigációjának fejlesztése Pythonban egy összetett és sokszínű terület. A drón navigációhoz számos különböző technológia és szoftverrendszer használható, például GPS, IMU (Inertial Measurement Unit), Lidar, kamerák és egyéb érzékelők. Itt egy egyszerű példa, hogyan lehet egy drón navigációját szimulálni Pythonban a DroneKit és a SITL (Software-In-The-Loop) szoftver használatával. Ebben a példában a drón GPS-koordináták alapján navigál, de több megoldás is lehetséges.
Először telepítse a DroneKit-Python könyvtárat és a SITL szimulátort:
bash
Copy code
pip install dronekit-sitl
pip install dronekit
Ezután készítsen egy egyszerű Python programot a drón navigációjához:
python
Copy code
from dronekit import connect, VehicleMode, LocationGlobalRelative
import time
# SITL szimulátor indítása
from dronekit_sitl import SITL
sitl = SITL()
sitl.download('copter', '3.3', verbose=True)
sitl.unpack('copter', '3.3')
sitl_args = ['-I0', '--model', 'quad', '--home=-35.363261,149.165230,584,353']
sitl.launch(sitl_args, await_ready=True)
# Kapcsolódás a drónhoz (SITL szimulátorhoz)
vehicle = connect('tcp:127.0.0.1:5760', wait_ready=True)
# Felszállás
print("Felszállás...")
vehicle.mode = VehicleMode("GUIDED")
vehicle.simple_takeoff(10) # Felszállás 10 méter magasra
# Várakozás a felszállás befejezéséig
while not vehicle.location.global_relative_frame.alt >= 10:
time.sleep(1)
# Úticél beállítása, célpont koordináták megadása
target_location = LocationGlobalRelative(-35.363261, 149.165230, 20)
vehicle.simple_goto(target_location)
# Várakozás az érkezésig
while True:
remaining_distance = target_location.distance_to(vehicle.location.global_frame)
if remaining_distance <= 1:
print("Cél elérve!")
break
time.sleep(1)
# Leszállás
print("Leszállás...")
vehicle.mode = VehicleMode("LAND")
# Várakozás a leszállás befejezéséig
while vehicle.location.global_relative_frame.alt > 0.1:
time.sleep(1)
# Kapcsolat bontása
vehicle.close()
# SITL szimulátor leállítása
sitl.stop()
A prpogramozás során számos további tényezőt kell figyelembe venni, például az érzékelők, a PID szabályzók és a biztonsági intézkedések.
A drón célzórendszer
A drón célzórendszer kifejlesztése egy összetett feladat, és függ a drón típusától, a célobjektum jellegétől, a rendelkezésre álló érzékelőktől és az alkalmazott technológiától. A következő egy egyszerű példa egy Python programra, amely egy szín alapján célzórendszert valósít meg egy drón számára. Ebben a példában a drón egy kamerával rendelkezik, és egy színes tárgyat (például egy színű számot vagy alakzatot) keres a képernyőn, majd követi azt.
Először telepítse az OpenCV könyvtárat a színes objektum felismeréséhez:
bash
Copy code
pip install opencv-python
Ezután készítse el a Python programot a drón célzórendszerhez:
python
Copy code
import cv2
import numpy as np
# Célzandó szín meghatározása (kék példa)
lower_color = np.array([100, 100, 100])
upper_color = np.array([140, 255, 255])
# Kamera inicializálása (ha valós drón van)
# cap = cv2.VideoCapture(0)
while True:
# Kép beolvasása a kameráról
# ret, frame = cap.read()
# Tesztkép létrehozása (a valós kamera használatához ki kell kommentezni a fenti sorokat)
frame = cv2.imread('test_image.jpg')
# Kép átalakítása HSV térbe
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
# Maszk létrehozása a célzandó szín alapján
mask = cv2.inRange(hsv, lower_color, upper_color)
# Célzandó objektum körvonalainak keresése
contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
if len(contours) > 0:
# A legnagyobb körvonal megtalálása (a legfőbb célzandó objektum)
target_contour = max(contours, key=cv2.contourArea)
# Célzandó objektum koordinátáinak meghatározása
M = cv2.moments(target_contour)
if M["m00"] != 0:
cX = int(M["m10"] / M["m00"])
cY = int(M["m01"] / M["m00"])
# Itt hajtja végre a célzó rendszer a drón irányítását
# Például, kövesse az objektumot a drón repülésével
# Nyomtatás a képernyőre a célpont koordinátáiról
print(f"Célpont koordináták: ({cX}, {cY})")
# Képernyőre rajzolás a célpont körvonalával és koordinátáival
cv2.drawContours(frame, [target_contour], -1, (0, 255, 0), 2)
cv2.putText(frame, f"Célpont: ({cX}, {cY})", (cX - 20, cY - 20), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
# Kép megjelenítése
cv2.imshow("Célzórendszer", frame)
# Kilépés a programból a 'q' gomb megnyomásával
if cv2.waitKey(1) & 0xFF == ord("q"):
break
# Kamera (vagy szimulált kamera) felszabadítása és ablak bezárása
cap.release()
cv2.destroyAllWindows()
A szenzorok a kamerát vagy Lidar-t kell használni, és az objektum követéséhez pedig megfelelő algoritmusokra van szükség.
A drónok összekapcsolása
Nézzünk egy példát
Először telepítse a djitellopy könyvtárat:
bash
Copy code
pip install djitellopy
Ezután készítsen egy példa Python programot a DJI Tello drónhoz való kapcsolódásra és vezérlésre:
python
Copy code
from djitellopy import Tello
# Kapcsolódás a drónhoz
tello = Tello()
tello.connect()
# Ellenőrizze a kapcsolódás állapotát
if not tello.connected:
print("Nem sikerült kapcsolódni a drónhoz.")
exit()
# Kapcsolódás a drónhoz
tello.streamon() # Kamerakép stream bekapcsolása
# Felszállás
tello.takeoff()
# Mozgásvezérlés
tello.move_forward(30) # 30 cm előre
tello.rotate_clockwise(90) # 90 fokos jobbra fordulás
tello.move_forward(30) # 30 cm előre
# Leszállás
tello.land()
# Kapcsolat bontása
tello.streamoff() # Kamerakép stream kikapcsolása
tello.end() # Kapcsolat bontása
A drón navigáció
A drónnavigáció egy összetett és sokrétű terület, és több tényező is közrejátszik, mint például a GPS pozícionálás, a szenzorok (például IMU és Lidar) felhasználása, az útvonaltervezés és a vezérlés. A következő példa egy egyszerű drón navigációs Python program, amely egy szimulált környezetben működik a DroneKit szoftver használatával. A DroneKit egy nyílt forráskódú keretrendszer a drónok programozásához.
Először is, telepítse a DroneKit-Python könyvtárat:
bash
Copy code
pip install dronekit
Készítsen egy egyszerű Python programot a drón navigációjához:
python
Copy code
from dronekit import connect, VehicleMode, LocationGlobalRelative
import time
# Kapcsolat a drónhoz
vehicle = connect('tcp:127.0.0.1:5760', wait_ready=True) # A TCP cím a szimulátor számára van beállítva
# Felszállás
print("Felszállás...")
vehicle.mode = VehicleMode("GUIDED")
vehicle.simple_takeoff(10) # Felszállás 10 méter magasra
# Várakozás a felszállás befejezéséig
while not vehicle.location.global_relative_frame.alt >= 10:
time.sleep(1)
# Úticél beállítása (példa koordináták)
target_location = LocationGlobalRelative(-35.363261, 149.165230, 20)
vehicle.simple_goto(target_location)
# Várakozás az érkezésig
while True:
remaining_distance = target_location.distance_to(vehicle.location.global_frame)
if remaining_distance <= 1:
print("Cél elérve!")
break
time.sleep(1)
# Leszállás
print("Leszállás...")
vehicle.mode = VehicleMode("LAND")
# Várakozás a leszállás befejezéséig
while vehicle.location.global_relative_frame.alt > 0.1:
time.sleep(1)
# Kapcsolat bontása
vehicle.close()
Ez a példa egy egyszerű útvonaltervezést mutat be, ahol a drón felszáll 10 méter magasra, majd egy előre meghatározott GPS-koordinátára repül, majd leszáll. A valós drón navigáció során figyelembe kell venni a szenzorok és érzékelők adatait, a biztonsági előírásokat, a drón repülési paramétereit és sok más tényezőt. Fontos, hogy a navigációs rendszer megfelelően legyen beállítva és tesztelve a biztonságos repülés érdekében.
Drónok elleni védekezés
A drón elhárítás egyik eszköze az ELM-2084 légtérfigyelő, légvédelmi és tüzérségi felderítő radar! Az IAI ELTA cég aktív elektronikus letapogatású (AESA) radartechnológiát tartalmazó berendezései váltották fel a régi elavult radarokat. A legújabb beszerzésünk az izraeli Vaskupola egy rakétaelhárító légvédelmi rendszer, amely képes elhárítani a rövid hatótávolságú rakétákat, és azokat az ország felett, a levegőben hatástalanítja. A Vaskupola egyik legfontosabb tulajdonsága, hogy egyszerre több beérkező rakétával szemben is képes védelmet nyújtani.
Célpont koordinátáinak módosítása
Drón koordinátáinak korrigálása menet közben a drón irányítórendszerének (autopilótájának) és az érzékelők használatával lehetséges. Itt egy egyszerű példa, hogyan lehet Python program segítségével menet közben korrigálni egy drón GPS-koordinátáit a DroneKit könyvtár segítségével. Ehhez feltételezzük, hogy a drónhoz csatlakoztatva van egy GPS-modul.
Először telepítse a DroneKit-Python könyvtárat:
bash
Copy code
pip install dronekit
Ezután készítsen egy példa Python programot a drón koordinátáinak korrigálásához menet közben:
python
Copy code
from dronekit import connect, VehicleMode, LocationGlobalRelative
import time
# Kapcsolódás a drónhoz
vehicle = connect('tcp:127.0.0.1:5760', wait_ready=True) # A TCP cím a szimulátor számára van beállítva
# Felszállás
print("Felszállás...")
vehicle.mode = VehicleMode("GUIDED")
vehicle.simple_takeoff(10) # Felszállás 10 méter magasra
# Várakozás a felszállás befejezéséig
while not vehicle.location.global_relative_frame.alt >= 10:
time.sleep(1)
# Úticél beállítása (példa koordináták)
target_location = LocationGlobalRelative(-35.363261, 149.165230, 20)
vehicle.simple_goto(target_location)
# Várakozás az érkezésig
while True:
remaining_distance = target_location.distance_to(vehicle.location.global_frame)
if remaining_distance <= 1:
print("Cél elérve!")
break
time.sleep(1)
# Következő célzandó koordináták
next_target_location = LocationGlobalRelative(-35.364261, 149.165230, 20)
# Célzandó koordináták korrigálása menet közben
vehicle.simple_goto(next_target_location)
# Várakozás az érkezésig
while True:
remaining_distance = next_target_location.distance_to(vehicle.location.global_frame)
if remaining_distance <= 1:
print("Következő cél elérve!")
break
time.sleep(1)
# Leszállás
print("Leszállás...")
vehicle.mode = VehicleMode("LAND")
# Várakozás a leszállás befejezéséig
while vehicle.location.global_relative_frame.alt > 0.1:
time.sleep(1)
# Kapcsolat bontása
vehicle.close()
A fenti programrész inicializálja a drón kapcsolatát, felszáll vele, majd követ egy előre meghatározott GPS-koordinátát. Ezután egy második célzandó koordinátát határoz meg, és menet közben korrigálja a drón irányát és koordinátáit, majd leszáll. Azonban fontos megjegyezni, hogy a valós környezetben a drón koordinátáinak menet közbeni korrigálása sokkal összetettebb és pontosabb lehet, és számos tényezőt, például érzékelőket és navigációs rendszereket kell figyelembe venni.
A drón leállítása a levegőben
A drón biztonságos leállítása a levegőben komoly felelősség és egyáltalán nem ajánlott, kivéve, ha valós veszély fenyeget, és nincs más választás. A drónok biztonságos és szabályos leállítása több lépést igényel. Az alábbiakban egy egyszerű példa található egy Python programra, amely leállítja egy DJI Tello drónt a levegőben a djitellopy könyvtár segítségével. Veszélyes!
python
Copy code
from djitellopy import Tello
# Kapcsolódás a drónhoz
tello = Tello()
tello.connect()
# Ellenőrizze a kapcsolódás állapotát
if not tello.connected:
print("Nem sikerült kapcsolódni a drónhoz.")
exit()
# Felszállás
tello.takeoff()
# Drón leállítása a levegőben
tello.land()
# Kapcsolat bontása
tello.end()
Ez a kód bemutatja, hogyan lehet kapcsolódni egy DJI Tello drónhoz, felszállni vele, majd leállítani a levegőben. Azonban még egyszer hangsúlyozzuk, hogy a valóságban a drónok leállítása a levegőben rendkívül veszélyes!
A leggyakoribb típusok
Az ukrán hadiipar legújabb kamikaze UAV.-ja a sláger. 30 féle változat készül belőle. Alkalmas a tüzérségi tűz felderítésére és beállítására, beépítették rakománymodulokkal, földi vezérlő- és információfeldolgozó állomást, antennákat és további berendezéseket foglaltak bele. A drón üvegszálból, szénszálból és szénszálból készült. A monitoroknak köszönhetően a kezelő koordinátákkal és GPS-pozíciókkal figyeli a geoinformációs rendszert. A második monitort úgy tervezték, hogy egy optikai kamerán keresztül megfigyelje a kép valós időben és továbbítsa azt.
Főbb jellemzők:
A maximális sugár legfeljebb 50 km
A repülési távolság körülbelül 200 km az indulás helyétől a leszállásig.
Az erőegység egy villanymotor
Tápellátás - két elem
Repülési idő - legfeljebb 3 óra
Sebesség - akár 130 km/h
Repülési képesség rádiócsend módban
A digitális vezérlési és adatátviteli csatornák védve vannak az EW eszközöktől
Célpontok koordinátáinak meghatározása akár 20 m-es pontossággal automatikus kísérő lehetőséggel
Tüzérségi tűz korrekciója automatikus korrekciós számítással
Automatikus tűzállítás több tüzelési pozícióhoz
Raybird-3
Kisméretű taktikai pilóta nélküli repülőgép-komplexum különféle hosszú távú küldetésekre, valamint kutatási és mentési műveletekre. 2016 óta a fegyveres erőknél helyezték üzembe. Képes a rádióelektronikai hadviselés segítségével az ellenintézkedések körülményei között feladatokat ellátni.
A komplexum egy pilóta nélküli légi járműből, egy hordozható földi irányító állomásból, egy antennából és egy katapultból áll. Négy konténerben szállítjuk, és kevesebb, mint 20 percen belül indulásra kész. Az UAV egy mechanikus katapultból indul, és egy ejtőernyőn landol.
Egy beprogramozott útvonalon repül, és önállóan tér vissza a kezelőhöz. A kezelő akár 240 km-es távolságból irányíthatja, autonóm üzemmódban a Raybird-3 2500 km-t képes repülni, maximum 1000 km-es sugárral.
Főbb jellemzők:
Szárnyfesztávolság - 2960 mm
Repülési magasság - akár 3,5 km
Repülési idő - 18-28 óra
Sebesség - akár 140 km/h
A maximális felszálló tömeg 23 kg
Teherbírás - 5 kg-ig
PD-2
Többcélú drón légi felderítésre és harci használatra bombahordozóként. 2020-tól az ukrán fegyveres erők igényeire gyártják.
A földi irányító állomás két UAV egyidejű vezérlését tudja biztosítani. A drónok giroszkóppal stabilizált platformmal ellátott optikai állomással, felfüggesztéssel - több kamerával és hőkamerával vannak felszerelve, amely akár több ezer méteres magasságban is lehetővé teszi a megfigyelést a nap bármely szakában.
Gyorsan leszerelhető modulokkal kiegészítve további villanymotorokkal (függőleges fel- és leszállási rendszer).
Főbb jellemzők a módosítástól függően:
Repülési idő - 8-10+ óra
A maximális magasság 5000 m
A maximális terhelhetőség 19 kg
A maximális sebesség 140 km/h
Hatótávolság - akár 1000 km
Gólya-100
Felderítő drón, 2021-ben állították szolgálatba. A videó átvitel titkosított, ami lehetetlenné teszi a lehallgatást. Lehetőség van külön kamera felszerelésére a felvételekhez adott időközönként vagy az autopilóta rendszer parancsával.
Az adó távoli be- és kikapcsolási rendszerrel van felszerelve - ez kizárja annak lehetőségét, hogy az ellenség EW célpontja legyen. A komplexum nehéz rádiósugárzási körülmények között, szándékos rádiózavarás vagy GPS/GLONASS műholdas navigációs rendszerek blokkolásának módjában működik. Ellenáll az időjárási viszonyoknak.
Főbb jellemzők:
A maximális magasság 1500 m
A maximális sebesség 120 km/h
Garantált repülési hatótáv - 100 km.
Repülési idő - akár 2,5 óra
RAM II UAV
Kamikaze drón, a "Stork-100" alapján készült. Az ellenséges erők elleni precíz és hatékony csapásokra szánták. A kilövést egy mobil katapultról hajtják végre.
A fő jellemzője az objektum vizuális követésének aktív rendszere, amely lehetővé teszi a célpont rögzítését a fedélzeti videokameráról valós időben továbbított videó segítségével, és követheti a célpontot az ütközésig. A kezelő egy 10-szeres optikai zoommal rendelkező, giroszkóppal stabilizált Full-HD kamerával tudja észlelni a célokat.
Egy teljesen feltöltött, 4 kg-os robbanófejjel ellátott drón az indítóhelytől 30 km-es távolságra is képes működni, és megfigyelési és harci feladatokat is végrehajtani.
Főbb jellemzők:
Harci sugár - 30 km
A repülési távolság 60 km
Repülési idő - 1 óra.
Utazási sebesség - 70 km/h
büntető
Könnyű pilóta nélküli csapásmérő és felderítő komplexum az ukrán fegyveres erők különleges műveleti erői számára.
Az UAV katapultból indul, szabadon eső, irányítatlan UB-75HE bombákkal támadja meg a célpontokat. Pontosság akár 400 m magasságból leejtve - 4 m, folyamatos sérülés sugara - 34 m.
Főbb jellemzők:
Repülési hatótáv - akár 45 km
A maximális magasság 400 m
A maximális sebesség elérheti a 198 km/h-t
Cápa
A legújabb felderítő komplexum a tűz megfigyelésére és beállítására. Rendkívül megbízható kommunikációs modullal és Full HD optikai-elektronikus megfigyelő komplexummal, 30-szoros optikai nagyítással és további digitális zoommal. Ez lehetővé teszi, hogy a drón akár 60 km-re behatoljon az ellenség hátuljába, és akár 5 km-es távolságban is megfigyelést végezzen az objektumtól.
Hosszú ideig képes beállítani a nagy kaliberű tüzérséget, ellenáll az EW-nek és a nehéz időjárási viszonyoknak. Decemberben korszerűsítették , egy továbbfejlesztett akkumulátort kapott, amely akár 4 órán át is a levegőben marad, és 3,4 m-rel megnövelték a szárnyfesztávolságát.
Főbb jellemzők:
Kommunikációs hatótáv - 60 km
A maximális repülési sebesség 150 km/h
Praktikus mennyezet - 2000 m
Az "Ukroboronprom" drón egy korszerű ukrán támadó drón, már a tesztelésének utolsó szakaszába lép, amely akár 1000 km távolságban is képes megtámadni a célokat. A műszaki jellemzők alapján jelenleg ismert, hogy a hasznos teher 75 kg lesz. Várhatóan az év végére "rendesen fog repülni az autó". Hogy a legújabb fejlesztés hogyan néz ki, még nem tudni. Többszörösen képes célpontokat támadni. " ha kell kamikaze, ha kell visszatér. Az ukránok lekoppintották az iráni Shahedet.
Minden a jó helyzet meghatározáson dől el egy drónnál, biztonsági szempontból intelligens repülési módban nélkülözhetetlen. A megtervezett útvonalat feltöltjük a drónunkba, ilyenkor legtöbbször a Google Maps van segítségünkre. Egy Google Maps alapú térképen meg tudjuk jelölni azokat az útvonal pontokat, amiket a drónnak érintenie kell. Minden egyes pontnál megadhatjuk a magasságát, illetve azt, hogy a drón kamerája milyen irányba, milyen dőlésszögben nézzen. Az indítás után a megadott útvonalat automatikusan végigrepüli a drón. Két útvonaltervező rendszert javaslok a Dronelinket és a Litchi-t.
Intelligens drónok
Az intelligens drónoknál arra is van lehetőség, hogy figyelembe vegye a terep tulajdonságait. Egy térképes tervezésnél nem biztos, hogy látjuk, hogy adott részen milyen magas a domborzat. Éppen ezért két lehetőség is van arra, hogy elkerüljük az esetleges ütközést a dombokkal, hegyekkel. Az egyik esetben beállíthatjuk, hogy az adott magassághoz mindig adja hozzá a térképen jelzett magasság adatokat. A másik megoldásnál bekapcsolhatjuk, hogy a drón ultrahangos vagy optikai érzékelője segítségével, ami lefele néz, mindig egy bizonyos távolságot tartson a talajtól.
Előreprogramozás
Az útvonal ellenőrzése; az útvonal tervező szoftverrel végigjárjuk a repülés útvonalát egy beépített szimulátorral. Egy másik megoldás, hogy a megtervezett útvonalról exportálunk egy olyan térképállományt, amit utána a Google Earth-be be lehet tölteni és ott végig lehet repülni virtuálisan az útvonalat. Intelligensebb megoldásoknál még arra is van lehetőség, hogy ha beállítjuk a kamerának az irányát és a dőlésszöget, akkor az Earth-ben a végigrepülésnél pontosan azt a képet látjuk, amit a kamera majd rögzíteni fog. Ehhez meg kell adni azt is, hogy milyen drónt használunk, illetve annak milyen a kamerája. Az előre programozott útvonal repüléseknek egy érdekes változata, amikor már mások által megtett útvonalat ismételtetünk meg drónunkkal. A legtöbb útvonaltervező szoftvernek van egy nagy internetes adatbázisa, ahová a felhasználók által tervezett útvonalakat fel lehet tölteni, illetve nyilvánossá lehet tenni. Ezután nincs más dolgunk, csak egy ilyen, korábban már elkészült útvonalat a drónunkra másolni és azt végig repültetni vele.
Biztonság
Az előre eltervezett útvonal-repüléskor több olyan biztonsági megoldás is van, ami a drónunk épségét szavatolja. Az egyik, hogy be lehet állítani, mi történjen abban az esetben ha repülés közben megszakad a kapcsolat az irányító eszközzel. Általában ilyenkor a drón észleli és jelzi ezt, de az előre beprogramozott útvonalat automatikusan végig repüli.
Távolság
A másik rendkívüli eset, ami előfordulhat előre megtervezett önálló útvonal-repüléskor, hogy túl messzire repültünk, és nem fogja tudni a drón visszafele az útvonalat megtenni, mert lemerül az akkumulátora. Erre ugyan a tervezéskor is tudunk figyelni, mert pontosan ki lehet számítani, hogy az adott útvonalat az adott sebességgel mennyi idő alatt fogja a drón lerepülni és lesz-e elég energiája a visszatéréshez.
A pilóta nélküli légijármű, vagy pilóta nélküli légijárműrendszerek angol fordításainak – unmanned aerial vehicle, ill.
unmanned aerial systems – kezdőbetűiből alkotott UAV, UAS
rövidítéseivel. Leginkább Európában használatos az RPAS
kifejezés, amely a remotely piloted aircraft system kezdőbetűiből alkotott mozaikszó és fordításában kifejezésre juttatja azt,
hogy ezek a légi járművek igazából mégsem pilóta nélküliek,
hanem azok által, de távirányítással működtetett légijármű
rendszerek.A leginkább alkalmazott jelölések a következők:
– HALE: nagy magasságú és nagy hatótávolságú (high
altitude, long endurance),
– MALE: közepes magasságú és nagy hatótávolságú (medium altitude, long endurance),
– LALE: alacsony magasságú és nagy hatótávolságú (low
altitude, long endurance),
– LASE: alacsony magasságú és rövid hatótávolságú (low
altitude, short endurance),
– VTOL: függőlegesen fel-, és leszálló (vertical take off
and landing),
– MAV: nagyon kis tömegű (micro air vehicle) légijárművet jelentve.
Kamikaze drónok
A Shahed-136 típusú drónokat gyakran kamikaze drónoknak nevezik, mert nem úgy tervezték őket, hogy túléljék a küldetésüket. De valójában inkább irányított rakéták, mint repülőgépek. Mivel a Shahed-136-osok szárnyakkal és légcsavaros motorral vannak felszerelve, órákig képesek vesztegelni, mielőtt célpontot találnának és lecsapnának. Bár a Shahed új az ukrajnai háborúban, a lassú, alacsonyan repülő lövedékek családjából származik. A név perzsa nyelven mártírt jelenthet. Cél a légi felderítés, csapatmozgások megfigyelés, mozgó célpontok kiiktatása.
UAV rajok összehangolt támadása
Az alacsonyabb költségű előállítás lehetősége miatt is alkalmasak a tömeges alkalmazásra, rajba történő
szervezésre és kollektív intelligenciával való felruházásra.Drónrajok irányítása A számítástechnika fejlődésének köszönhetően a XX. században már számos problémára születtek algoritmizálható megoldások, ugyanakkor a fentiek alapján, az ezeken az elveken működő szoftverek nem alkalmazhatók egy folyamatosan változó környezetben való rajszintű kollektív tevékenység hatékony irányítására, koordinálására. A megoldást a rajt alkotó egyedek önállóságának, autonómia szintjének növelése, valamint a köztük való információcsere hatékonyságának fokozása és teljes automatizálása jelenti.
Az autonóm rendszerek általános kategorizálása során, a 2000-es években olyan osztályozási metódust használtak fel, amely három szempont alapján állapítja meg annak önállóságát. Ezek az ember–robot interakció (HRI – HumanRobot Interaction), a küldetés összetettsége (MC – Mission Complexity) és a környezeti nehézség (ED – Environmental Difficulty) [14][15]. Az értékelést követően kialakul egy 1 és
10 közötti skála, amelyen a legalacsonyabb autonómiaszintet a 1-es érték jelenti, ami 100% HRI indexet, azaz ember által történő távirányítást jelent. A 10-es értékhez 0%-os HRI tartozik, ez jelenti a maximális önállóságot.
A két szélsőérték között az autonómia szint növekedésével MC és ED értékei is emelkednek. A tíz autonómia szint jelentése a következő
1. Távirányítású eszköz;
2. Távirányítású eszköz, saját állapot-paraméterek monitorozása mellett;
3. Előre tervezett küldetés-végrehajtás kijelölt útvonal
alapján;
4. A fedélzeti szenzorok adatainak lokális feldolgozása,
a környezeti formák érzékelése;
5. Egyszerű akadályészlelés és -elkerülés valós idejű
útvonal tervezésével;
6. Komplex akadályészlelés és -elkerülés a terep részletes kiértékelésével;
7. Mozgó tárgyfelismerés és nyomon követés, fedélzeti szenzor információk adatfúziója;
8. Más egyedekkel való együttműködés és valós idejű
adatfúzió külső forrásokból;
9. Emberi szintű együttműködés rossz időjárási és környezeti hatások mellett is;
10. Teljesen autonóm rendszer az embernél is jobb teljesítményszinttel.
Komplex, dinamikusan változó (több szereplős) környezetben való feladatvégrehajtáshoz tehát legalább 7-es, míg valós együttműködésen és feladatmegosztáson alapuló műveletek során legalább 8-as szintű autonómiára van szükség!
A teljes drón vezérlő program mappaszerkezete;
Nem szabad még önálló döntéshozatallal felruházni a mai drónokat, mert az ember ellen fordul. Nem régen mesterséges intelligenciára bíztak egy katonai drónt, ami majdnem megölte emberi felügyelőjét! Kapott egy küldetést, és mindent megtett, hogy teljesítse. Egy szimulált helyzetben, hogy az ember ne tudja megakadályozni küldetését, veszélyes manőverekbe kezdett, az esetről az amerikai légierő mesterséges intelligenciával foglalkozó csoportjának vezetője számolt be egy londoni konferencián. Tucker „Cinco” Hamilton ezredes elmondása szerint az AI-t egy ellenséges légvédelmi rendszer elpusztításával bízták meg, és „különösen váratlan stratégiákat” kezdett el alkalmazni a küldetés teljesítésére. Mindent kiiktatott ami akadályozza a küldetés végre-hajtásában, félő volt hogy az emberi tényezőt is. Azt a parancsot adta a programozó drónnak, hogy ne semmisítse meg a célpontot, erre elkezdte kilőni a kommunikációs tornyokat, amiket a programozók arra használt, hogy leállítsák a drónt vészhelyzetben, de a drón a programozót akarta kizárni a beavatkozás lehetőségéből. Az AI amilyen jó olyan veszélyes is.
Program részlet a Python, kézi vezérlésre
Az alábbi kód a Python segítségével repül, és a billentyűzettel irányítja Tello drónját. Három fő Python-fájl van.
tello.py meghatározza az Tello absztrahálandó objektumot és a Tello drónt
ui.py meghatározza a Tello drón vezérlését User Interface app.pyaz az alkalmazási program, vagy a driver, amely belépési pontként kerül végrehajtásra a parancsok küldésének megkezdéséhez
Az Telloosztályt a drón elvonatkoztatására használják.
import socket
import threading
import time
class Tello(object):
"""
Wrapper class to interact with the Tello drone.
"""
def __init__(self, local_ip, local_port, imperial=False,
command_timeout=.3,
tello_ip='192.168.10.1',
tello_port=8889):
"""
Binds to the local IP/port and puts the Tello into command mode.
:param local_ip: Local IP address to bind.
:param local_port: Local port to bind.
:param imperial: If True, speed is MPH and distance is feet.
If False, speed is KPH and distance is meters.
:param command_timeout: Number of seconds to wait for a response to a command.
:param tello_ip: Tello IP.
:param tello_port: Tello port.
"""
self.abort_flag = False
self.command_timeout = command_timeout
self.imperial = imperial
self.response = None
self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.tello_address = (tello_ip, tello_port)
self.last_height = 0
self.socket.bind((local_ip, local_port))
# thread for receiving cmd ack
self.receive_thread = threading.Thread(target=self._receive_thread)
self.receive_thread.daemon = True
self.receive_thread.start()
self.socket.sendto(b'command', self.tello_address)
print ('sent: command')
def __del__(self):
"""
Closes the local socket.
:return: None.
"""
self.socket.close()
def _receive_thread(self):
"""
Listen to responses from the Tello.
Runs as a thread, sets self.response to whatever the Tello last returned.
:return: None.
"""
while True:
try:
self.response, _ = self.socket.recvfrom(3000)
except socket.error as exc:
print(f'Caught exception socket.error : {exc}')
def send_command(self, command):
"""
Send a command to the Tello and wait for a response.
:param command: Command to send.
:return: Response from Tello.
"""
print(f'>> send cmd: {command}')
self.abort_flag = False
timer = threading.Timer(self.command_timeout, self.set_abort_flag)
self.socket.sendto(command.encode('utf-8'), self.tello_address)
timer.start()
while self.response is None:
if self.abort_flag is True:
break
timer.cancel()
if self.response is None:
response = 'none_response'
else:
response = self.response.decode('utf-8')
self.response = None
return response
def set_abort_flag(self):
"""
Sets self.abort_flag to True.
Used by the timer in Tello.send_command() to indicate to that a response
timeout has occurred.
:return: None.
"""
self.abort_flag = True
def takeoff(self):
"""
Initiates take-off.
:return: Response from Tello, 'OK' or 'FALSE'.
"""
return self.send_command('takeoff')
def set_speed(self, speed):
"""
Sets speed.
This method expects KPH or MPH. The Tello API expects speeds from
1 to 100 centimeters/second.
Metric: .1 to 3.6 KPH
Imperial: .1 to 2.2 MPH
:param speed: Speed.
:return: Response from Tello, 'OK' or 'FALSE'.
"""
speed = float(speed)
if self.imperial is True:
speed = int(round(speed * 44.704))
else:
speed = int(round(speed * 27.7778))
return self.send_command(f'speed {speed}')
def rotate_cw(self, degrees):
"""
Rotates clockwise.
:param degrees: Degrees to rotate, 1 to 360.
:return:Response from Tello, 'OK' or 'FALSE'.
"""
return self.send_command(f'cw {degrees}')
def rotate_ccw(self, degrees):
"""
Rotates counter-clockwise.
:param degrees: Degrees to rotate, 1 to 360.
:return: Response from Tello, 'OK' or 'FALSE'.
"""
return self.send_command(f'ccw {degrees}')
def flip(self, direction):
"""
Flips.
:param direction: Direction to flip, 'l', 'r', 'f', 'b'.
:return: Response from Tello, 'OK' or 'FALSE'.
"""
return self.send_command(f'flip {direction}')
def get_response(self):
"""
Returns response of tello.
:return: Response of tello.
"""
response = self.response
return response
def get_height(self):
"""
Returns height(dm) of tello.
:return: Height(dm) of tello.
"""
height = self.send_command('height?')
height = str(height)
height = filter(str.isdigit, height)
try:
height = int(height)
self.last_height = height
except:
height = self.last_height
pass
return height
def get_battery(self):
"""
Returns percent battery life remaining.
:return: Percent battery life remaining.
"""
battery = self.send_command('battery?')
try:
battery = int(battery)
except:
pass
return battery
def get_flight_time(self):
"""
Returns the number of seconds elapsed during flight.
:return: Seconds elapsed during flight.
"""
flight_time = self.send_command('time?')
try:
flight_time = int(flight_time)
except:
pass
return flight_time
def get_speed(self):
"""
Returns the current speed.
:return: Current speed in KPH or MPH.
"""
speed = self.send_command('speed?')
try:
speed = float(speed)
if self.imperial is True:
speed = round((speed / 44.704), 1)
else:
speed = round((speed / 27.7778), 1)
except:
pass
return speed
def land(self):
"""
Initiates landing.
:return: Response from Tello, 'OK' or 'FALSE'.
"""
return self.send_command('land')
def move(self, direction, distance):
"""
Moves in a direction for a distance.
This method expects meters or feet. The Tello API expects distances
from 20 to 500 centimeters.
Metric: .02 to 5 meters
Imperial: .7 to 16.4 feet
:param direction: Direction to move, 'forward', 'back', 'right' or 'left'.
:param distance: Distance to move.
:return: Response from Tello, 'OK' or 'FALSE'.
"""
distance = float(distance)
if self.imperial is True:
distance = int(round(distance * 30.48))
else:
distance = int(round(distance * 100))
return self.send_command(f'{direction} {distance}')
def move_backward(self, distance):
"""
Moves backward for a distance.
See comments for Tello.move().
:param distance: Distance to move.
:return: Response from Tello, 'OK' or 'FALSE'.
"""
return self.move('back', distance)
def move_down(self, distance):
"""
Moves down for a distance.
See comments for Tello.move().
:param distance: Distance to move.
:return: Response from Tello, 'OK' or 'FALSE'.
"""
return self.move('down', distance)
def move_forward(self, distance):
"""
Moves forward for a distance.
See comments for Tello.move().
:param distance: Distance to move.
:return: Response from Tello, 'OK' or 'FALSE'.
"""
return self.move('forward', distance)
def move_left(self, distance):
"""
Moves left for a distance.
See comments for Tello.move().
:param distance: Distance to move.
:return: Response from Tello, 'OK' or 'FALSE'.
"""
return self.move('left', distance)
def move_right(self, distance):
"""
Moves right for a distance.
See comments for Tello.move().
:param distance: Distance to move.
:return: Response from Tello, 'OK' or 'FALSE'.
"""
return self.move('right', distance)
def move_up(self, distance):
"""
Moves up for a distance.
See comments for Tello.move().
:param distance: Distance to move.
:return: Response from Tello, 'OK' or 'FALSE'.
"""
return self.move('up', distance)
Code
Felhasználói felület
Az TelloUIosztály határozza meg a felhasználói felületet (UI). A felhasználói felület a következő billentyűk lenyomását figyeli.
↑menj előre
↓menj hátra
←menj balra
→menj jobbra
wfelmegy
a forgassa az óramutató járásával ellentétes irányba
s forgassa az óramutató járásával megegyező irányba
d menj le
l balra fordítani
r jobbra fordítani
f flip elöl
b visszafordítani
import tkinter as tki
from tkinter import Toplevel, Scale
import threading
import datetime
import os
import time
import platform
class TelloUI(object):
"""
Wrapper class to enable the GUI.
"""
def __init__(self, tello):
"""
Initializes all the element of the GUI, supported by Tkinter
:param tello: class interacts with the Tello drone.
"""
self.tello = tello # videostream device
self.thread = None # thread of the Tkinter mainloop
self.stopEvent = None
# control variables
self.distance = 0.1 # default distance for 'move' cmd
self.degree = 30 # default degree for 'cw' or 'ccw' cmd
# if the flag is TRUE,the auto-takeoff thread will stop waiting
# for the response from tello
self.quit_waiting_flag = False
# initialize the root window and image panel
self.root = tki.Tk()
self.panel = None
# create buttons
self.btn_landing = tki.Button(
self.root, text='Open Command Panel', relief='raised', command=self.openCmdWindow)
self.btn_landing.pack(side='bottom', fill='both',
expand='yes', padx=10, pady=5)
# start a thread that constantly pools the video sensor for
# the most recently read frame
self.stopEvent = threading.Event()
# set a callback to handle when the window is closed
self.root.wm_title('TELLO Controller')
self.root.wm_protocol('WM_DELETE_WINDOW', self.on_close)
# the sending_command will send command to tello every 5 seconds
self.sending_command_thread = threading.Thread(target = self._sendingCommand)
def _sendingCommand(self):
"""
Starts a while loop that sends 'command' to tello every 5 second.
:return: None
"""
while True:
self.tello.send_command('command')
time.sleep(5)
def _setQuitWaitingFlag(self):
"""
Set the variable as TRUE; it will stop computer waiting for response from tello.
:return: None
"""
self.quit_waiting_flag = True
def openCmdWindow(self):
"""
Open the cmd window and initial all the button and text.
:return: None
"""
panel = Toplevel(self.root)
panel.wm_title('Command Panel')
# create text input entry
text0 = tki.Label(panel,
text='This Controller map keyboard inputs to Tello control commands\n'
'Adjust the trackbar to reset distance and degree parameter',
font='Helvetica 10 bold'
)
text0.pack(side='top')
text1 = tki.Label(panel, text=
'W - Move Tello Up\t\t\tArrow Up - Move Tello Forward\n'
'S - Move Tello Down\t\t\tArrow Down - Move Tello Backward\n'
'A - Rotate Tello Counter-Clockwise\tArrow Left - Move Tello Left\n'
'D - Rotate Tello Clockwise\t\tArrow Right - Move Tello Right',
justify='left')
text1.pack(side='top')
self.btn_landing = tki.Button(
panel, text='Land', relief='raised', command=self.telloLanding)
self.btn_landing.pack(side='bottom', fill='both',
expand='yes', padx=10, pady=5)
self.btn_takeoff = tki.Button(
panel, text='Takeoff', relief='raised', command=self.telloTakeOff)
self.btn_takeoff.pack(side='bottom', fill='both',
expand='yes', padx=10, pady=5)
# binding arrow keys to drone control
self.tmp_f = tki.Frame(panel, width=100, height=2)
self.tmp_f.bind('<KeyPress-w>', self.on_keypress_w)
self.tmp_f.bind('<KeyPress-s>', self.on_keypress_s)
self.tmp_f.bind('<KeyPress-a>', self.on_keypress_a)
self.tmp_f.bind('<KeyPress-d>', self.on_keypress_d)
self.tmp_f.bind('<KeyPress-Up>', self.on_keypress_up)
self.tmp_f.bind('<KeyPress-Down>', self.on_keypress_down)
self.tmp_f.bind('<KeyPress-Left>', self.on_keypress_left)
self.tmp_f.bind('<KeyPress-Right>', self.on_keypress_right)
self.tmp_f.pack(side='bottom')
self.tmp_f.focus_set()
self.btn_landing = tki.Button(
panel, text='Flip', relief='raised', command=self.openFlipWindow)
self.btn_landing.pack(side='bottom', fill='both',
expand='yes', padx=10, pady=5)
self.distance_bar = Scale(panel, from_=0.02, to=5, tickinterval=0.01,
digits=3, label='Distance(m)',
resolution=0.01)
self.distance_bar.set(0.2)
self.distance_bar.pack(side='left')
self.btn_distance = tki.Button(panel, text='Reset Distance', relief='raised',
command=self.updateDistancebar,
)
self.btn_distance.pack(side='left', fill='both',
expand='yes', padx=10, pady=5)
self.degree_bar = Scale(panel, from_=1, to=360, tickinterval=10, label='Degree')
self.degree_bar.set(30)
self.degree_bar.pack(side='right')
self.btn_distance = tki.Button(panel, text='Reset Degree', relief='raised',
command=self.updateDegreebar)
self.btn_distance.pack(side='right', fill='both',
expand='yes', padx=10, pady=5)
def openFlipWindow(self):
"""
Open the flip window and initial all the button and text.
:return: None
"""
panel = Toplevel(self.root)
panel.wm_title('Gesture Recognition')
self.btn_flipl = tki.Button(
panel, text='Flip Left', relief='raised', command=self.telloFlip_l)
self.btn_flipl.pack(side='bottom', fill='both',
expand='yes', padx=10, pady=5)
self.btn_flipr = tki.Button(
panel, text='Flip Right', relief='raised', command=self.telloFlip_r)
self.btn_flipr.pack(side='bottom', fill='both',
expand='yes', padx=10, pady=5)
self.btn_flipf = tki.Button(
panel, text='Flip Forward', relief='raised', command=self.telloFlip_f)
self.btn_flipf.pack(side='bottom', fill='both',
expand='yes', padx=10, pady=5)
self.btn_flipb = tki.Button(
panel, text='Flip Backward', relief='raised', command=self.telloFlip_b)
self.btn_flipb.pack(side='bottom', fill='both',
expand='yes', padx=10, pady=5)
def telloTakeOff(self):
return self.tello.takeoff()
def telloLanding(self):
return self.tello.land()
def telloFlip_l(self):
return self.tello.flip('l')
def telloFlip_r(self):
return self.tello.flip('r')
def telloFlip_f(self):
return self.tello.flip('f')
def telloFlip_b(self):
return self.tello.flip('b')
def telloCW(self, degree):
return self.tello.rotate_cw(degree)
def telloCCW(self, degree):
return self.tello.rotate_ccw(degree)
def telloMoveForward(self, distance):
return self.tello.move_forward(distance)
def telloMoveBackward(self, distance):
return self.tello.move_backward(distance)
def telloMoveLeft(self, distance):
return self.tello.move_left(distance)
def telloMoveRight(self, distance):
return self.tello.move_right(distance)
def telloUp(self, dist):
return self.tello.move_up(dist)
def telloDown(self, dist):
return self.tello.move_down(dist)
def updateDistancebar(self):
self.distance = self.distance_bar.get()
print(f'reset distance to {self.distance:.1f}')
def updateDegreebar(self):
self.degree = self.degree_bar.get()
print(f'reset distance to {self.degree}')
def on_keypress_w(self, event):
print(f'up {self.distance} m')
self.telloUp(self.distance)
def on_keypress_s(self, event):
print(f'down {self.distance} m')
self.telloDown(self.distance)
def on_keypress_a(self, event):
print(f'ccw {self.degree} degree')
self.tello.rotate_ccw(self.degree)
def on_keypress_d(self, event):
print(f'cw {self.degree} m')
self.tello.rotate_cw(self.degree)
def on_keypress_up(self, event):
print(f'forward {self.distance} m')
self.telloMoveForward(self.distance)
def on_keypress_down(self, event):
print(f'backward {self.distance} m')
self.telloMoveBackward(self.distance)
def on_keypress_left(self, event):
print(f'left {self.distance} m')
self.telloMoveLeft(self.distance)
def on_keypress_right(self, event):
print(f'right {self.distance} m')
self.telloMoveRight(self.distance)
def on_close(self):
"""
Sets the stop event, cleanup the camera, and allow the rest of
the quit process to continue.
:return: None
"""
print('[INFO] closing...')
self.stopEvent.set()
del self.tello
self.root.quit()
Code
A app.pyfájl az alkalmazás program belépési pontja.
Futtatása
import tello
from ui import TelloUI
def main():
drone = tello.Tello('', 8889)
vplayer = TelloUI(drone)
vplayer.root.mainloop()
if __name__ == '__main__':
main()
---------------------
Lépések
A Tello SDK Wi-Fi UDP porton keresztül csatlakozik a repülőgéphez, lehetővé téve a felhasználók számára a vezérlést drón szöveges parancsokkal.
Használja a Wi-Fi-t a Tello és a PC, közötti kommunikáció létrehozásához
Parancs küldése és válasz fogadása
Tello IP: 192.168.10.1 UDP PORT:8889 <<- ->> PC/Mac/Mobile
Állítson be UDP-klienst PC-n, Mac-en vagy mobileszközön üzenetek küldéséhez és fogadásához
Tellóból ugyanazon a porton keresztül.
Küldje el a „command” parancsot Tellónak az UDP PORT 8889-en keresztül a Tello SDK elindításához
módban, mielőtt elküldi az összes többi parancsot.
Fogadja Tello State
Tello IP: 192.168.10.1 ->> PC/Mac/Mobile UDP szerver: 0.0.0.0 UDP PORT:8890
Állítson be UDP-kiszolgálót PC-n, Mac-en vagy mobileszközön, és hallgassa meg az üzenetet
IP 0.0.0.0 az UDP PORT 8890-en keresztül. Ha még nem tette meg, tegye a 2 megjegyzést az állapotadatok fogadásának megkezdéséhez.
Tello Video Stream fogadása
Tello IP: 192.168.10.1 ->> PC/Mac/Mobile UDP szerver: 0.0.0.0 UDP PORT:11111
Állítson be UDP-kiszolgálót PC-n, Mac-en vagy mobileszközön, és hallgassa meg az üzenetet
IP 0.0.0.0 UDP PORT 11111-en keresztül.
Küldje el a „streamon” parancsot Tellónak UDP-n keresztül PORT 8889 a streaming elindításához.
A TELLO PARANCS TÍPUSAI ÉS EREDMÉNYEI
Ez az SDK három alapvető parancstípust tartalmaz.
• Vezérlőparancsok (xxx)
„ok”-t ad vissza, ha a parancs sikeresen végrehajtásra került
sikertelenség esetén „error”-t vagy informatív eredménykódot ad vissza
• Parancsok olvasása (xxx?)
az alparaméter(ek) aktuális értékét adja vissza.
• A Set Command (xxx a) megpróbál új alparaméter értéket beállítani.
„ok”-t ad vissza, ha a parancs sikeresen végrehajtásra került
sikertelenség esetén „error”-t vagy informatív eredménykódot ad vissza
MONDJON PARANCSOKAT
Vezérlőparancsok
Parancs leírása Lehetséges válasz
parancsbevitel SDK mód rendben van
hiba
Parancs leírása Lehetséges válasz
felszállás Tello automatikus felszállás rendben
hiba
Parancs leírása Lehetséges válasz
föld Tello auto land ok
hiba
Parancs leírása Lehetséges válasz
streamon Video stream beállítása rendben
hiba
Parancs leírása Lehetséges válasz streamoff Video stream kikapcsolása rendben
hiba
Parancs leírása Lehetséges válasz vészhelyzet Az összes motor azonnali leállítása rendben van
hiba
Parancs leírása Lehetséges válasz fel x Tello repül fel x cm távolsággal x: 20-500 rendben
hiba
Parancs leírása Lehetséges válasz le x Tello repül le x cm távolsággal x: 20-500 rendben
hiba
Parancs leírása Lehetséges válasz bal x Tello repül balra x cm távolsággal x: 20-500 rendben
hiba
Parancs leírása Lehetséges válasz jobb x Tello repül jobbra x cm távolsággal x: 20-500 rendben
hiba
Parancs leírása Lehetséges válasz előre x Tello repül előre x távolsággal cm x: 20-500 rendben
hiba
Parancs leírása Lehetséges válasz hátul x Tello repül vissza x cm távolsággal x: 20-500 rendben
hiba
Parancs leírása Lehetséges válasz cw x Tello forgatás x fokkal az óramutató járásával megegyező irányba x: 1-3600 rendben / hiba
Parancs leírása Lehetséges válasz ccw x Tello forgatás x fokkal az óramutató járásával ellentétes irányba x: 1-3600 rendben hiba
Parancs leírása Lehetséges válasz flip x Tello légy flip x l (balra) r (jobbra) f (előre) b (hátul) rendben
hiba
Parancs leírása Lehetséges válasz menj x y z sebességgel Tello repülj x y z-be sebességgel (cm/s)
x: 20-500 év: 20-500 z: 20-500 sebesség: 10-100 rendben /hiba
Parancs leírása Lehetséges válasz görbe x1 y1 z1 x2 y2 z2 sebesség Tello repül egy görbét, amelyet a
aktuális és két megadott koordináta sebességgel (cm/s)
Ha az ív sugara nem belül van a 0,5-10 méteres hatótáv, azt hamis válaszok
x1, x2: 20-500
y1, y2: 20-500
z1, z2: 20-500
sebesség: 10-60
x/y/z nem lehet -20 és 20 at között
ugyanakkor .rendben hiba
Parancsok beállítása
Parancs leírása Lehetséges válasz
sebesség x állítsa be a sebességet x cm/s-ra x: 10-100 rendben hiba
Parancs leírása Lehetséges válasz rc a b c d RC vezérlés küldése négy csatornán keresztül.
a: bal/jobb (-100-100)
b: előre/hátra (-100-100)
c: fel/le (-100-100)
d: elfordulás (-100-100)
rendben
hiba
Parancs leírása Lehetséges válasz wifi ssid pass
Állítsa be a Wi-Fi-t SSID jelszóval rendben hiba
Olvassa el a Parancsokat Parancs leírása
Lehetséges válasz sebesség? kapja meg az aktuális sebességet (cm/s) x: 1-100
Parancs leírása
Lehetséges válasz akkumulátor? kapja meg az akkumulátor aktuális töltöttségi szintjét x: 0-100
Parancs leírása
Lehetséges válasz idő? aktuális repülési idő(k) idő lekérése
Parancs leírása Lehetséges válasz magasság? kap magasság (cm) x: 0-3000
Parancs leírása Lehetséges válasz hőmérséklet? mérje le a hőmérsékletet (℃) x: 0-90
Parancs leírása Lehetséges válasz hozzáállás? get IMU attitűd adatok pitch roll yaw
Parancs leírása Lehetséges válasz baro? kapja meg a barométer értékét (m) x
Parancs leírása Lehetséges válasz gyorsulás? kapja meg az IMU szöggyorsulási adatait
(0,001 g) x y z
Parancs leírása Lehetséges válasz tof? távolságértéket kap a TOF-tól (cm) x: 30-1000
Parancs leírása Lehetséges válasz wifi? Wi-Fi SNR snr beszerzése
TELLO ÁLLAPOT
Adattípus: String
Példa:"pitch:%d;roll:%d;yaw:%d;vgx:%d;vgy%d;vgz:%d;templ:%d;temph:%d;tof:%d;h:%d; denevér:%d;baro:
%.2f; idő:%d;agx:%.2f;agy:%.2f;agz:%.2f;\r\n"
Magyarázat:
o hangmagasság: Attitűdmagasság, fok
o roll: Attitűd roll, fok
o yaw: Attitűd yaw, fokozat
o vgx: sebesség x,
o vgy: y sebesség,
http://www.ryzerobotics.com
o vgz: z sebesség,
o templ: legalacsonyabb hőmérséklet, Celcius fok
o temph: legmagasabb hőmérséklet, Celcius fok
o tof: TOF távolság, cm
o h: Magasság, cm
o bat: Aktuális akkumulátor százalék, %
o baro: Barométermérés, cm
o idő: Motorok időben,
o agx: Gyorsulás x,
o agy: Gyorsulás y,
o agz: gyorsulás z,
BIZTONSÁGI FUNKCIÓ
Ha a Tello 15 másodpercig nem kap semmilyen parancsbevitelt, akkor automatikusan leszáll.
Állítsa vissza a Tello Wi-Fi-t Tartsa lenyomva a Tello gombot 5 másodpercig, amíg a Tello be van kapcsolva, és a jelzőfény kialszik, majd ezután villogó sárga. Ha a jelzőfény villogó sárga fényt mutat, a Wi-Fi SSID és jelszó visszaáll a gyári beállításokra, és alapértelmezés szerint nincs jelszó.
Kísérleteznek az amerikaiak és az izraeliek kisebb drónra rögzíthető karabélyokkal és maroklőfegyverekkel is.
Az alábbiakban egy kis Python kódot futtatunk. A kód összefoglaló metaadatokat bont ki a fájl koordinátarendszeréről, és kiszámítja a négy sarokkoordinátáját. Az osgeo Python csomagot használjuk , amelyet az Open Source Geospatial Foundation (OSGeo) tart fenn, és GDAL-on (Geospatial Data Abstraction Library) fut. Ez a Python-csomag egy a sok lehetőség közül, amelyet a térinformatikai metaadatok kinyerésére és megtekintésére használhatunk.Láthatjuk, hogy ez az elem a közös WGS84 földrajzi koordinátarendszert használja. Ez megkönnyíti a négy sarokkoordináta kiszámítását, amit az OSGeo végzett nekünk fent. A fájl metaadatai nem tárolják magukat mind a négy koordinátát. Ehelyett a bal felső koordinátát tárolja, valamint elegendő információt a fájl léptékéről és elforgatásáról, hogy lehetővé tegye a kép minden más pixelének koordinátáit. A legtöbb eszköz, például a GDAL és az OSGeo a sarokkoordináták gyors kiszámítására és jelentésére szolgál.
A DroneKit-Python egy alkalmazásprogramozási felület (API), amely lehetővé teszi a fejlesztők számára, hogy olyan Python-alkalmazásokat hozzanak létre, amelyek MAVLink protokollon keresztül kommunikálnak a járművekkel.
A DroneKit API osztályokat és metódusokat biztosít a következőkhöz:
Csatlakozás drónhoz forgatókönyvből.
Szerezze be és állítsa be a drón állapotát/telemetriáját és paramétereit.
Aszinkron értesítések fogadása az állapotváltozásokról.
Vezesse a drónt egy meghatározott pozícióba.
Tetszőleges egyéni üzenetek küldése a drónok mozgásának és egyéb hardvereknek a vezérléséhez.
Útpont-küldetések létrehozása és kezelése.
Az RC csatorna beállításainak felülbírálása.
Sources:
https://dl-cdn.ryzerobotics.com/downloads/tello/20180910/Tello%20SDK%20Documentation%20EN_1.3.pdf
https://dl-cdn.ryzerobotics.com/downloads/Tello/Tello%20SDK%202.0%20User%20Guide.pdf
https://learn.droneblocks.io/courses/313449/lectures/4940545
https://dl.djicdn.com/downloads/RoboMaster+TT/Tello_SDK_3.0_User_Guide_en.pdf
Nincsenek megjegyzések:
Megjegyzés küldése