A katonai drónok irányítása komoly programozási ismereteket feltételez. Az éles használatot mindig sok szimuláció előzi meg. Ez a példa a dronekit-sitl segítségével elindít egy szimulált drónt a SITL szimulátorban, majd a drónt felszálltatja 10 méter magasságba, leszáll, és lezárja a kapcsolatot. Drón szimulációs alkalmazások készítéséhez a dronekit-sitl (Software In The Loop) és más, rónszimulációhoz tervezett eszközöket használhatod a Pythonban. Ezen eszközök segítségével virtuális környezetben tesztelheted a drón vezérlőprogramját, anélkül, hogy egy valós drónt kellene használnod.
Pygame modul oktatófelületet használhatunk.
Az alábbiakban egy egyszerű példa a dronekit-sitl használatával egy szimulált drón irányítására. Először telepítsd a szükséges könyvtárakat:
pip install dronekit-sitl
Szimulátor indítása
from dronekit_sitl import SITL
from dronekit import connect, VehicleMode
import time
# SITL (Software In The Loop) szimulátor indítása
sitl = SITL()
sitl.download('copter', '3.3', verbose=True)
sitl_args = ['-I0', '--model', 'quad', '--home=47.641468,-122.140165,0,0']
sitl.launch(sitl_args, await_ready=True)
# Csatlakozás a drónhoz
vehicle = connect('tcp:127.0.0.1:5760', wait_ready=True)
# Felszállás
def arm_and_takeoff(altitude):
print("Várakozás a drón készenlételére...")
while not vehicle.is_armable:
time.sleep(1)
print("Felszállás engedélyezése...")
vehicle.mode = VehicleMode("GUIDED")
vehicle.armed = True
while not vehicle.armed:
time.sleep(1)
print("Felszállás megkezdése...")
vehicle.simple_takeoff(altitude)
while True:
print("Aktuális magasság: %f m" % vehicle.location.global_relative_frame.alt)
if vehicle.location.global_relative_frame.alt >= altitude * 0.95:
print("Elértük a kívánt magasságot.")
break
time.sleep(1)
# Felszállás 10 méter magasságba
arm_and_takeoff(10)
# Leszállás
print("Leszállás...")
vehicle.mode = VehicleMode("LAND")
# Várakozás a leszállás befejezéséig
while not vehicle.armed:
time.sleep(1)
# Szimulátor és kapcsolat lezárása
sitl.stop()
vehicle.close()
--------------------------
Az alábbiakban egy egyszerű példa található egy Python programra, amely egy szimulált drónt irányít. Ebben a példában a Pygame modult használjuk egy egyszerű grafikus felülethez, ahol a drónt a nyilakkal lehet irányítani.Ez a kód egy egyszerű drón irányítást valósít meg a Pygame segítségével. Ennek csak a tanulási és demonstrációs célokra szolgáló példakód, valós alkalmazás esetén speciális drónvezérlő könyvtárakat kell alkalmazni.
---------------implementáció------------------
import pygame
import time
# Inicializáljuk a Pygame modult
pygame.init()
# A drón kezdeti pozíciója
drone_x = 100
drone_y = 100
# A drón sebessége
drone_speed = 5
# A képernyő mérete
screen_width = 800
screen_height = 600
# Inicializáljuk a képernyőt
screen = pygame.display.set_mode((screen_width, screen_height))
pygame.display.set_caption("Drone Control")
# A játék ciklus
running = True
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
# Irányítás
keys = pygame.key.get_pressed()
if keys[pygame.K_LEFT]:
drone_x -= drone_speed
if keys[pygame.K_RIGHT]:
drone_x += drone_speed
if keys[pygame.K_UP]:
drone_y -= drone_speed
if keys[pygame.K_DOWN]:
drone_y += drone_speed
# Korlátozzuk a drón mozgását a képernyőn belül
drone_x = max(0, min(drone_x, screen_width - 20))
drone_y = max(0, min(drone_y, screen_height - 20))
# Törlés és újra rajzolás
screen.fill((255, 255, 255)) # Tiszta háttér
pygame.draw.rect(screen, (0, 128, 255), (drone_x, drone_y, 20, 20)) # Drón kirajzolása
# Frissítjük a képernyőt
pygame.display.flip()
# Késleltetés
time.sleep(0.02)
# Pygame bezárása
pygame.quit()
másik példa
import pygame
import sys
# Initialize Pygame
pygame.init()
# Set up display
width, height = 800, 600
screen = pygame.display.set_mode((width, height))
pygame.display.set_caption("Drone Simulation")
# Set up drone
drone_width, drone_height = 50, 50
drone_x, drone_y = width // 2 - drone_width // 2, height // 2 - drone_height // 2
drone_speed = 5
# Main game loop
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
keys = pygame.key.get_pressed()
if keys[pygame.K_LEFT] and drone_x > 0:
drone_x -= drone_speed
if keys[pygame.K_RIGHT] and drone_x < width - drone_width:
drone_x += drone_speed
if keys[pygame.K_UP] and drone_y > 0:
drone_y -= drone_speed
if keys[pygame.K_DOWN] and drone_y < height - drone_height:
drone_y += drone_speed
# Update display
screen.fill((255, 255, 255)) # White background
pygame.draw.rect(screen, (0, 0, 255), (drone_x, drone_y, drone_width, drone_height)) # Blue drone
pygame.display.flip()
pygame.time.Clock().tick(30) # 30 frames per second
------------------------ eddig játék, de innen már nem---------------------------
Lássuk élesben a vezérlést fel és leszállás. Ez a példa egy egyszerű UDP socketet használ, hogy parancsokat küldjön a drónnak. A valódi drónok irányítása többek között kriptográfiai biztonsági intézkedéseket, hitelesítést és más speciális protokollokat igényel.
import socket
# A drón IP címe és portja
drone_ip = "192.168.1.1" # példa cím, cseréld ki a valós IP címre
drone_port = 5555
# Inicializáljuk a socketet
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
# A drón vezérlése
def control_drone(command):
sock.sendto(command.encode(), (drone_ip, drone_port))
# Példa parancsok
takeoff_command = "takeoff"
land_command = "land"
forward_command = "forward 50" # Példa: előre mozgás 50 egységnyi távolságban
# Tesztelés: Drón felszállása, előre mozgás, és leszállás
control_drone(takeoff_command)
control_drone(forward_command)
control_drone(land_command)
# Socket lezárása
sock.close()
-----------------
A drónok helyzetmeghatározása többféleképpen történhet, de a legtöbb modern drón a GPS (Global Positioning System) rendszert használja a globális pozíciók meghatározásához. Ezenkívül más szenzorok is alkalmazhatók, például giroszkópok, gyorsulásmérők és magasságérzékelők a pontosabb helyzetmeghatározás érdekében. A következőkben egy egyszerű példát találsz egy Python programra, amely a dronekit könyvtárat használja, hogy elérje egy szimulált drón helyzetét.
Először is, telepítsd a dronekit és a sphinx-simulator könyvtárakat a szimulált drón használatához. A dronekit a drónok irányítására, míg a sphinx-simulator a szimulációhoz szükséges.
bash szimulátor
pip install dronekit-sitl
pip install dronekit
pip install pymavlink
Ez a példa egy szimulált drón helyzetét olvassa le és kiírja a konzolra.
Azonban érdemes megjegyezni, hogy a valódi drónok irányításához és helyzetmeghatározásához a GPS-t, giroszkópokat, gyorsulásmérőket és más érzékelőket egy komplex rendszer részeként kell használni.
Ez egy python szkrip a drón helyzetének lekérdezéséhez:
from dronekit import connect, VehicleMode
# SITL (Software In The Loop) szimulátor indítása
from dronekit_sitl import SITL
sitl = SITL()
sitl.download('copter', '3.3', verbose=True)
sitl_args = ['-I0', '--model', 'quad', '--home=47.641468,-122.140165,0,0']
sitl.launch(sitl_args, await_ready=True)
# Csatlakozás a drónhoz
vehicle = connect('tcp:127.0.0.1:5760', wait_ready=True)
# Helyzetleolvasás
def get_drone_position():
return vehicle.location.global_frame
try:
while True:
# Helyzet lekérdezése és kiíratása
current_position = get_drone_position()
print(f'Drón helyzete: Lat={current_position.lat}, Lon={current_position.lon}, Alt={current_position.alt}')
except KeyboardInterrupt:
print("Program leállítva.")
finally:
# Szimulátor és kapcsolat lezárása
sitl.stop()
vehicle.close()
----------------
Ez a példa egy szimulált drón vezérlését valósítja meg, beleértve a felszállást, az előre mozgást, és a leszállást. A dronekit könyvtár lehetővé teszi a MAVLink protokollon keresztüli drón irányítást, és a dronekit-sitl egy szimulált környezetet biztosít a teszteléshez.
from dronekit import connect, VehicleMode, LocationGlobalRelative
import time
# SITL (Software In The Loop) szimulátor indítása
from dronekit_sitl import SITL
sitl = SITL()
sitl.download('copter', '3.3', verbose=True)
sitl_args = ['-I0', '--model', 'quad', '--home=47.641468,-122.140165,0,0']
sitl.launch(sitl_args, await_ready=True)
# Csatlakozás a drónhoz azonosítás
vehicle = connect('tcp:127.0.0.1:5760', wait_ready=True)
# Felszállás
def arm_and_takeoff(altitude):
print("Várakozás a drón készenlételére...")
while not vehicle.is_armable:
time.sleep(1)
print("Felszállás engedélyezése...")
vehicle.mode = VehicleMode("GUIDED")
vehicle.armed = True
while not vehicle.armed:
time.sleep(1)
print("Felszállás megkezdése...")
vehicle.simple_takeoff(altitude)
while True: #szelekció feltétel
print("Aktuális magasság: %f m" % vehicle.location.global_relative_frame.alt)
if vehicle.location.global_relative_frame.alt >= altitude * 0.95:
print("Elértük a kívánt magasságot.")
break
time.sleep(1)
# Felszállás 10 méter magasságba
arm_and_takeoff(10)
# Mozgás előre 50 méterrel
print("Előre mozgás 50 méterrel...")
new_location = LocationGlobalRelative(47.641468, -122.140165, 10) # cél helyzete
vehicle.simple_goto(new_location)
# Várakozás a cél eléréséig
while True:
remaining_distance = new_location.distance_to(vehicle.location.global_frame)
print("Távolság a céltól: %f m" % remaining_distance)
if remaining_distance <= 1:
print("A 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 not vehicle.armed:
time.sleep(1)
# Szimulátor és kapcsolat lezárása
sitl.stop()
vehicle.close()
-------------------------
Drón célzásának GPS-koordináták alapján történő megvalósításához a dronekit könyvtárat használhatod. Az alábbi példa egy egyszerű Python programot mutat be, amely a drónt előre mozgatja egy adott célkoordináta felé.
Telepítsd a szükséges könyvtárakat:
pip install dronekit dronekit-sitl
Ebben a példában a simple_goto metódus segítségével beállítjuk a drón célszámú koordinátáit, majd a drón automatikusan elkezdi a cél felé való mozgást.
from dronekit import connect, VehicleMode, LocationGlobalRelative
import time
# SITL (Software In The Loop) szimulátor indítása
from dronekit_sitl import SITL
sitl = SITL()
sitl.download('copter', '3.3', verbose=True)
sitl_args = ['-I0', '--model', 'quad', '--home=47.641468,-122.140165,0,0']
sitl.launch(sitl_args, await_ready=True)
# Csatlakozás a drónhoz
vehicle = connect('tcp:127.0.0.1:5760', wait_ready=True)
# Felszállás
def arm_and_takeoff(altitude):
print("Várakozás a drón készenlételére...")
while not vehicle.is_armable:
time.sleep(1)
print("Felszállás engedélyezése...")
vehicle.mode = VehicleMode("GUIDED")
vehicle.armed = True
while not vehicle.armed:
time.sleep(1)
print("Felszállás megkezdése...")
vehicle.simple_takeoff(altitude)
while True:
print("Aktuális magasság: %f m" % vehicle.location.global_relative_frame.alt)
if vehicle.location.global_relative_frame.alt >= altitude * 0.95:
print("Elértük a kívánt magasságot.")
break
time.sleep(1)
# Felszállás 10 méter magasságba
arm_and_takeoff(10)
# Célkoordináták beállítása
target_latitude = 47.642268
target_longitude = -122.141964
target_altitude = 10
# Célhoz mozgás
target_location = LocationGlobalRelative(target_latitude, target_longitude, target_altitude)
print(f"Célkoordináták: Lat={target_latitude}, Lon={target_longitude}, Alt={target_altitude}")
print("Mozgás a cél felé...")
vehicle.simple_goto(target_location)
# Várakozás a cél eléréséig
while True:
remaining_distance = target_location.distance_to(vehicle.location.global_frame)
print("Távolság a célhoz: %f m" % remaining_distance)
if remaining_distance <= 1:
print("A 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 not vehicle.armed:
time.sleep(1)
# Szimulátor és kapcsolat lezárása
sitl.stop()
vehicle.close()
---------------------
Ebben a példában a simple_goto metódus segítségével beállítjuk a drón célszámú koordinátáit, majd a drón automatikusan elkezdi a cél felé való mozgást.
A drón sebességének beállításához a dronekit könyvtárat használhatod. Az alábbi példa egy egyszerű Python programot mutat be, amely a drón sebességét állítja be előre és oldalra a simple_goto metódus segítségével.
from dronekit import connect, VehicleMode, LocationGlobalRelative
import time
# SITL (Software In The Loop) szimulátor indítása
from dronekit_sitl import SITL
sitl = SITL()
sitl.download('copter', '3.3', verbose=True)
sitl_args = ['-I0', '--model', 'quad', '--home=47.641468,-122.140165,0,0']
sitl.launch(sitl_args, await_ready=True)
# Csatlakozás a drónhoz
vehicle = connect('tcp:127.0.0.1:5760', wait_ready=True)
# Felszállás
def arm_and_takeoff(altitude):
print("Várakozás a drón készenlételére...")
while not vehicle.is_armable:
time.sleep(1)
print("Felszállás engedélyezése...")
vehicle.mode = VehicleMode("GUIDED")
vehicle.armed = True
while not vehicle.armed:
time.sleep(1)
print("Felszállás megkezdése...")
vehicle.simple_takeoff(altitude)
while True:
print("Aktuális magasság: %f m" % vehicle.location.global_relative_frame.alt)
if vehicle.location.global_relative_frame.alt >= altitude * 0.95:
print("Elértük a kívánt magasságot.")
break
time.sleep(1)
# Felszállás 10 méter magasságba
arm_and_takeoff(10)
# Beállítjuk a sebességeket (előre és oldalra)
forward_speed = 5 # m/s
right_speed = 2 # m/s
print("Előre mozgás...")
vehicle.simple_goto(LocationGlobalRelative(vehicle.location.global_frame.lat + forward_speed,
vehicle.location.global_frame.lon,
vehicle.location.global_frame.alt))
time.sleep(5) # Várunk 5 másodpercet az előre mozgás befejezéséig
print("Oldalra mozgás...")
vehicle.simple_goto(LocationGlobalRelative(vehicle.location.global_frame.lat,
vehicle.location.global_frame.lon + right_speed,
vehicle.location.global_frame.alt))
time.sleep(5) # Várunk 5 másodpercet az oldalra mozgás befejezéséig
# Leszállás
print("Leszállás...")
vehicle.mode = VehicleMode("LAND")
# Várakozás a leszállás befejezéséig
while not vehicle.armed:
time.sleep(1)
# Szimulátor és kapcsolat lezárása
sitl.stop()
vehicle.close()
------------------------------------
Ebben a példában a simple_goto metódus segítségével a drón sebességét állítjuk be, előre és oldalra mozgáshoz.
Az előre és oldalra mozgás során a LocationGlobalRelative objektum segítségével megadhatod a célkoordinátákat a drón aktuális pozíciójától való elmozdulás helyett.
from dronekit import connect, VehicleMode, LocationGlobalRelative
import time
# SITL (Software In The Loop) szimulátor indítása
from dronekit_sitl import SITL
sitl = SITL()
sitl.download('copter', '3.3', verbose=True)
sitl_args = ['-I0', '--model', 'quad', '--home=47.641468,-122.140165,0,0']
sitl.launch(sitl_args, await_ready=True)
# Csatlakozás a drónhoz
vehicle = connect('tcp:127.0.0.1:5760', wait_ready=True)
# Felszállás
def arm_and_takeoff(altitude):
print("Várakozás a drón készenlételére...")
while not vehicle.is_armable:
time.sleep(1)
print("Felszállás engedélyezése...")
vehicle.mode = VehicleMode("GUIDED")
vehicle.armed = True
while not vehicle.armed:
time.sleep(1)
print("Felszállás megkezdése...")
vehicle.simple_takeoff(altitude)
while True:
print("Aktuális magasság: %f m" % vehicle.location.global_relative_frame.alt)
if vehicle.location.global_relative_frame.alt >= altitude * 0.95:
print("Elértük a kívánt magasságot.")
break
time.sleep(1)
# Felszállás 10 méter magasságba
arm_and_takeoff(10)
# Beállítjuk a sebességeket (előre és oldalra)
forward_speed = 5 # m/s
right_speed = 2 # m/s
print("Előre mozgás...")
vehicle.simple_goto(LocationGlobalRelative(vehicle.location.global_frame.lat + forward_speed,
vehicle.location.global_frame.lon,
vehicle.location.global_frame.alt))
time.sleep(5) # Várunk 5 másodpercet az előre mozgás befejezéséig
print("Oldalra mozgás...")
vehicle.simple_goto(LocationGlobalRelative(vehicle.location.global_frame.lat,
vehicle.location.global_frame.lon + right_speed,
vehicle.location.global_frame.alt))
time.sleep(5) # Várunk 5 másodpercet az oldalra mozgás befejezéséig
# Leszállás
print("Leszállás...")
vehicle.mode = VehicleMode("LAND")
# Várakozás a leszállás befejezéséig
while not vehicle.armed:
time.sleep(1)
# Szimulátor és kapcsolat lezárása
sitl.stop()
vehicle.close()
--------------------
példa látható a mavproxy használatára, ami a dronekit alapján működik. Ebben a példában a drón célzása egy adott GPS-koordinátára történik.
könyvtár telepitése
pip install dronekit-sitl mavproxy
Ebben a példában a mavproxy segítségével a drónhoz kapcsolódunk, majd a simple_goto metódus segítségével beállítjuk a drón célkoordinátáit. Ne feledd, hogy ez csak egy példa, és a valóságban a drón célzásának implementálása sokkal bonyolultabb lehet a valós rendszerek specifikációitól függően.
Python szkriptet a drón célzásához
from dronekit import connect, LocationGlobalRelative
import time
# SITL (Software In The Loop) szimulátor indítása
from dronekit_sitl import SITL
sitl = SITL()
sitl.download('copter', '3.3', verbose=True)
sitl_args = ['-I0', '--model', 'quad', '--home=47.641468,-122.140165,0,0']
sitl.launch(sitl_args, await_ready=True)
# MAVProxy indítása
# -j a jármű alapján teszi elérhetővé a bejövő adatokat és a célzást
# --console azért szükséges, hogy a terminál ablakban megjelenjenek az információk
cmd = 'mavproxy.py --master tcp:127.0.0.1:5760 --out udp:127.0.0.1:14550 --out udp:127.0.0.1:14551 --console'
sitl.launch(sitl_args, await_ready=True, verbose=True)
# Csatlakozás a drónhoz
vehicle = connect('tcp:127.0.0.1:5760', wait_ready=True)
# Célkoordináták beállítása adatbevitel vagy módosítás
target_latitude = 47.642268
target_longitude = -122.141964
target_altitude = 10
# Célhoz mozgás
target_location = LocationGlobalRelative(target_latitude, target_longitude, target_altitude)
print(f"Célkoordináták: Lat={target_latitude}, Lon={target_longitude}, Alt={target_altitude}")
# Vezérlés
vehicle.simple_goto(target_location)
# Várakozás a cél eléréséig iterációval
while True:
remaining_distance = target_location.distance_to(vehicle.location.global_frame)
print("Távolság a célhoz: %f m" % remaining_distance)
if remaining_distance <= 1:
print("A cél elérve.")
break
time.sleep(1)
# Szimulátor és kapcsolat lezárása
sitl.stop()
vehicle.close()
----------
drón vezérlését és a célpontok módosítása a dronekit könyvtár segítségével történhet.
from dronekit import connect, LocationGlobalRelative
import time
# SITL (Software In The Loop) szimulátor indítása
from dronekit_sitl import SITL
sitl = SITL()
sitl.download('copter', '3.3', verbose=True)
sitl_args = ['-I0', '--model', 'quad', '--home=47.641468,-122.140165,0,0']
sitl.launch(sitl_args, await_ready=True)
# Csatlakozás a drónhoz
vehicle = connect('tcp:127.0.0.1:5760', wait_ready=True)
# Felszállás
def arm_and_takeoff(altitude):
print("Várakozás a drón készenlételére...")
while not vehicle.is_armable:
time.sleep(1)
print("Felszállás engedélyezése...")
vehicle.mode = VehicleMode("GUIDED")
vehicle.armed = True
while not vehicle.armed:
time.sleep(1)
print("Felszállás megkezdése...")
vehicle.simple_takeoff(altitude)
while True:
print("Aktuális magasság: %f m" % vehicle.location.global_relative_frame.alt)
if vehicle.location.global_relative_frame.alt >= altitude * 0.95:
print("Elértük a kívánt magasságot.")
break
time.sleep(1)
# Felszállás 10 méter magasságba
arm_and_takeoff(10)
# Célkoordináták beállítása
target_latitude = 47.642268
target_longitude = -122.141964
target_altitude = 10
# Célhoz mozgás
target_location = LocationGlobalRelative(target_latitude, target_longitude, target_altitude)
print(f"Célkoordináták: Lat={target_latitude}, Lon={target_longitude}, Alt={target_altitude}")
# Vezérlés: Mozgás a célpont felé
vehicle.simple_goto(target_location)
# Várakozás a cél eléréséig feltételes iterációval
while True:
remaining_distance = target_location.distance_to(vehicle.location.global_frame)
print("Távolság a célhoz: %f m" % remaining_distance)
if remaining_distance <= 1:
print("A cél elérve.")
break
time.sleep(1)
# Új célpont koordináták beállítása
new_target_latitude = 47.643268
new_target_longitude = -122.142964
new_target_altitude = 15
new_target_location = LocationGlobalRelative(new_target_latitude, new_target_longitude, new_target_altitude)
print(f"Új célpont koordináták: Lat={new_target_latitude}, Lon={new_target_longitude}, Alt={new_target_altitude}")
# Vezérlés: Mozgás az új célpont felé
vehicle.simple_goto(new_target_location)
# Várakozás az új cél eléréséig iterációval
while True:
remaining_distance = new_target_location.distance_to(vehicle.location.global_frame)
print("Távolság az új célhoz: %f m" % remaining_distance)
if remaining_distance <= 1:
print("Az új 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 iterációval
while not vehicle.armed:
time.sleep(1)
# Szimulátor és kapcsolat lezárása
sitl.stop()
vehicle.close()
---------------
Titkosítási algoritmus
A drón programok titkosítása és biztonságosabbá tétele során fontos szempont a titkosítás és a biztonságos kommunikáció alkalmazása. Az egyik módszer a TLS (Transport Layer Security) vagy az SSL (Secure Sockets Layer) protokoll használata a kommunikáció biztosításához. Ezenkívül más biztonsági intézkedések, például az aláírások és az azonosítások, is hozzáadhatók a drón programokhoz.
Az alábbiakban egy egyszerű példa található a TLS-titkosított kommunikációra, amely a ssl modult használja a Pythonban.
Ez a példa feltételezi, hogy a drón rendelkezik egy SSL/TLS-képes szolgáltatással, és a hozzá tartozó tanúsítványokkal. A tanúsítványok létrehozásához és a továbbiakban használathoz a openssl eszközt vagy más SSL/TLS tanúsítványokat készítő eszközöket kell alkalmazni.
import socket
import ssl
# Drón IP-címe és portja
drone_ip = "192.168.1.1" # Cseréld le a valós IP-címre
drone_port = 5555
# SSL/TLS beállítások
ssl_context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
ssl_context.load_cert_chain(certfile="server.crt", keyfile="server.key") # Helyettesítsd a valós tanúsítvány és kulcs fájljaiddal
# Inicializáljuk a socketet és SSL/TLS kapcsolatot
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
ssl_sock = ssl_context.wrap_socket(sock, server_side=False, server_hostname=drone_ip)
# Kapcsolódás a drónhoz
ssl_sock.connect((drone_ip, drone_port))
# Titkosított üzenet küldése
message = "Ez egy titkosított üzenet a drónnak!"
ssl_sock.send(message.encode())
# Kapcsolat lezárása
ssl_sock.close()
----------------
A műholdas navigáció kockázatos. A drónok tájékozódása GPS nélkül kihívást jelent, mivel a GPS az egyik legelterjedtebb és legpontosabb pozícionálási mód a repülő tárgyak számára. Azonban léteznek más módszerek is a tájékozódásra, például szenzorok és egyéb adatforrások felhasználásával. Az alábbiakban néhány olyan módszer és szenzor van felsorolva, amelyeket egy drón tájékozódásához lehet használni GPS nélkül:
Inerciális mérőeszközök (IMU): Az IMU szenzorok gyorsulásmérést és szögmérést használnak a drón mozgásának követésére. Az IMU adhat információkat a drón elmozdulásáról és irányáról, de hosszú távú használat során a hibák felduzzadhatnak.
Barométer: A barométer a légnyomás változását méri, és ezáltal magasságbecslést tesz lehetővé. Hasznos lehet a drón magasságának meghatározásához, bár érzékeny lehet időjárási változásokra.
Kamera és képfeldolgozás: Egy drón kamerájának használata a környezetének felvétele és a képfeldolgozás segítségével a tájékozódásra. Ez a módszer különféle algoritmusok és technikák alkalmazását igényli, például a látási odometriát vagy a struktúrális helymeghatározást.
Ultrahang és infravörös szenzorok: Az ultrahang és infravörös szenzorokat gyakran használják a talajtól való távolság meghatározására. Ezek a szenzorok a drón magasságának pontosabb meghatározásához járulhatnak hozzá.
Mágneses szenzorok: A mágneses szenzorok segíthetnek a drón irányának meghatározásában, de érzékenyek lehetnek külső mágneses interferenciákra.
Fontos megjegyezni, hogy ezek a módszerek és szenzorok összeadódnak és kombinálódnak (például a szenzor összefűzés vagy a tájékozódás-összetétel módszereivel), hogy javítsák a drón pozícióinak és irányának pontosságát.
-------------------
Ebben a példában a drón felszáll, visszahívódik a kiindulópontjára (RTL mód), majd a célpontokat törli.
A drónok visszahívása és célpontjainak törlése programozási nyelven, például Pythonban, a drón típusától és az alkalmazott vezérlőkönyvtártól függ. Az alábbiakban egy egyszerű példa található a dronekit könyvtárra épülő kódra, amely bemutatja, hogyan lehet egy drónt visszahívni és törlési utasításokat küldeni. A példa a SITL szimulátorral működik, de a valóságban egy valódi drónhoz hasonlóan módosítani kell a kapcsolódási paramétereket.
from dronekit import connect, VehicleMode
import time
# SITL (Software In The Loop) szimulátor indítása
from dronekit_sitl import SITL
sitl = SITL()
sitl.download('copter', '3.3', verbose=True)
sitl_args = ['-I0', '--model', 'quad', '--home=47.641468,-122.140165,0,0']
sitl.launch(sitl_args, await_ready=True)
# Csatlakozás a drónhoz
vehicle = connect('tcp:127.0.0.1:5760', wait_ready=True)
# Felszállás
def arm_and_takeoff(altitude):
print("Várakozás a drón készenlételére...")
while not vehicle.is_armable:
time.sleep(1)
print("Felszállás engedélyezése...")
vehicle.mode = VehicleMode("GUIDED")
vehicle.armed = True
while not vehicle.armed:
time.sleep(1)
print("Felszállás megkezdése...")
vehicle.simple_takeoff(altitude)
while True:
print("Aktuális magasság: %f m" % vehicle.location.global_relative_frame.alt)
if vehicle.location.global_relative_frame.alt >= altitude * 0.95:
print("Elértük a kívánt magasságot.")
break
time.sleep(1)
# Felszállás 10 méter magasságba
arm_and_takeoff(10)
# Visszahívás
print("Visszahívás a kezdeti helyre...")
vehicle.mode = VehicleMode("RTL")
# Várakozás a visszahívás befejezéséig
while True:
print("Drón állapota: %s" % vehicle.mode.name)
if vehicle.mode.name == "RTL" and not vehicle.armed:
print("Visszahívás befejeződött.")
break
time.sleep(1)
# Célpontok törlése
print("Célpontok törlése...")
vehicle.commands.clear()
vehicle.commands.upload()
# Várakozás a törlés befejezéséig
while vehicle.commands:
print("Fennmaradó parancsok száma: %d" % len(vehicle.commands))
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 not vehicle.armed:
time.sleep(1)
# Szimulátor és kapcsolat lezárása
sitl.stop()
vehicle.close()
--------------
Parancs törlése drón visszahívása
A drónok visszahívását (Return To Launch - RTL) általában a dronekit vagy más drón vezérlőkönyvtárak segítségével lehet megvalósítani Python nyelven. Az alábbiakban egy egyszerű példa található, amely bemutatja a drón visszahívását a dronekit könyvtárral.
from dronekit import connect, VehicleMode
import time
# Csatlakozás a drónhoz
vehicle = connect('tcp:127.0.0.1:5760', wait_ready=True)
# Felszállás
def arm_and_takeoff(altitude):
print("Várakozás a drón készenlételére...")
while not vehicle.is_armable:
time.sleep(1)
print("Felszállás engedélyezése...")
vehicle.mode = VehicleMode("GUIDED")
vehicle.armed = True
while not vehicle.armed:
time.sleep(1)
print("Felszállás megkezdése...")
vehicle.simple_takeoff(altitude)
while True:
print("Aktuális magasság: %f m" % vehicle.location.global_relative_frame.alt)
if vehicle.location.global_relative_frame.alt >= altitude * 0.95:
print("Elértük a kívánt magasságot.")
break
time.sleep(1)
# Felszállás 10 méter magasságba
arm_and_takeoff(10)
# Visszahívás
print("Visszahívás a kezdeti helyre...")
vehicle.mode = VehicleMode("RTL")
# Várakozás a visszahívás befejezéséig
while True:
print("Drón állapota: %s" % vehicle.mode.name)
if vehicle.mode.name == "RTL" and not vehicle.armed:
print("Visszahívás befejeződött.")
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 not vehicle.armed:
time.sleep(1)
# Kapcsolat lezárása
vehicle.close()
--------------------
A get_drone_position függvény segítségével kiolvassuk a drón aktuális globális pozícióját (szélesség, hosszúság, magasság) és kiíratjuk ezeket az értékeket. Fontos megjegyezni, hogy a drónnak el kell érnie a GPS-jelet a pontos pozíció meghatározásához.
A drón pozíciójának meghatározása számos módon történhet a Python nyelvben, attól függően, hogy milyen szenzorokat használ a drón, és milyen típusú adatokat szeretnél elérni. Egy gyakran használt mód a GPS használata, de más szenzorok, például IMU, barométer, ultrahang szenzorok stb. is felhasználhatók a pozíció meghatározásához.
Az alábbiakban egy példa található, amely a dronekit könyvtárat használja a drón pozíciójának lekérdezéséhez. Ez a példa egy szimulált drónra vonatkozik, amelyet a dronekit-sitl szimulátorral hozunk létre
from dronekit import connect, VehicleMode
# Csatlakozás a drónhoz
vehicle = connect('tcp:127.0.0.1:5760', wait_ready=True)
# Funkció a drón pozíciójának lekérdezéséhez
def get_drone_position():
lat = vehicle.location.global_frame.lat
lon = vehicle.location.global_frame.lon
alt = vehicle.location.global_frame.alt
print(f"Latitude: {lat}, Longitude: {lon}, Altitude: {alt} meters")
# Lekérdezés és kiíratás
get_drone_position()
# Kapcsolat lezárása
vehicle.close()
----------------------
from dronekit import connect, VehicleMode
import time
# Csatlakozás a drónhoz
vehicle = connect('tcp:127.0.0.1:5760', wait_ready=True)
# Funkció a drón pozíciójának lekérdezéséhez
def get_drone_position():
# Várjuk meg, amíg a drón készen áll
while not vehicle.is_armable:
print("Várakozás a drón készenlételére...")
time.sleep(1)
# Felszállás engedélyezése
print("Felszállás engedélyezése...")
vehicle.mode = VehicleMode("GUIDED")
vehicle.armed = True
# Várakozás a felszállás befejezéséig
while not vehicle.armed or not vehicle.mode.name == "GUIDED":
print("Várakozás a felszállásra...")
time.sleep(1)
# Felszállás 10 méter magasságba
print("Felszállás megkezdése...")
vehicle.simple_takeoff(10)
while True:
# Lekérjük és kiírjuk a drón pozícióját
print("Drón pozíciója: %s" % vehicle.location.global_relative_frame)
time.sleep(1)
# Funkció hívása
get_drone_position()
# Kapcsolat lezárása
vehicle.close()
vagy a
from dronekit import connect, VehicleMode
import time
# Csatlakozás a drónhoz
vehicle = connect('tcp:127.0.0.1:5760', wait_ready=True)
# Funkció a drón pozíciójának lekérdezéséhez
def get_drone_position():
# Várjuk meg, amíg a drón készen áll
while not vehicle.is_armable:
print("Várakozás a drón készenlételére...")
time.sleep(1)
# Felszállás engedélyezése
print("Felszállás engedélyezése...")
vehicle.mode = VehicleMode("GUIDED")
vehicle.armed = True
# Várakozás a felszállás befejezéséig
while not vehicle.armed or not vehicle.mode.name == "GUIDED":
print("Várakozás a felszállásra...")
time.sleep(1)
# Felszállás 10 méter magasságba
print("Felszállás megkezdése...")
vehicle.simple_takeoff(10)
while True:
# Lekérjük és kiírjuk a drón pozícióját
print("Drón pozíciója: %s" % vehicle.location.global_relative_frame)
time.sleep(1)
# Funkció hívása
get_drone_position()
# Kapcsolat lezárása
vehicle.close()
........-----------------
Tehát a get_drone_position számára dronekit és dronekit-sitl ad lehetőséget.
---------------
Hova tart az idegen drón?
a példában a get_drone_heading függvényben a drón felszáll 10 méter magasságba, majd folyamatosan kiírja az aktuális irányát.
from dronekit import connect, VehicleMode
import time
# Csatlakozás a drónhoz
vehicle = connect('tcp:127.0.0.1:5760', wait_ready=True)
# Funkció a drón irányának lekérdezéséhez
def get_drone_heading():
# Várjuk meg, amíg a drón készen áll
while not vehicle.is_armable:
print("Várakozás a drón készenlételére...")
time.sleep(1)
# Felszállás engedélyezése
print("Felszállás engedélyezése...")
vehicle.mode = VehicleMode("GUIDED")
vehicle.armed = True
# Várakozás a felszállás befejezéséig
while not vehicle.armed or not vehicle.mode.name == "GUIDED":
print("Várakozás a felszállásra...")
time.sleep(1)
# Felszállás 10 méter magasságba
print("Felszállás megkezdése...")
vehicle.simple_takeoff(10)
while True:
# Lekérjük és kiírjuk a drón irányát
print("Drón iránya: %f°" % vehicle.heading)
time.sleep(1)
# Funkció hívása
get_drone_heading()
# Kapcsolat lezárása
vehicle.close()
A drónok irányának meghatározása a Pythonban általában az inerciális mérőeszközök (IMU) adatainak feldolgozásával történik. Az IMU szenzorok mérési adatokat szolgáltatnak a drón gyorsulásáról, szögeiről és szögsebességéről, amelyekből a drón iránya és orientációja kiszámítható.
Az alábbi példa bemutatja, hogyan használhatod a dronekit könyvtárat a drón irányának meghatározására egy szimulált környezetben.
Azonosítás
A drón azonosítása Pythonban általában a dronekitvagy másdronekit segítségével lehetséges
from dronekit import connect, VehicleMode
# Csatlakozás a drónhoz
vehicle = connect('tcp:127.0.0.1:5760', wait_ready=True)
# Drón adatainak kiíratása
print("Drón azonosítása:")
print("Üzemállapot: %s" % vehicle.mode.name)
print("Pozíció: %s" % vehicle.location.global_frame)
print("Sebesség: %s" % vehicle.velocity)
print("Akkumulátor állapota: %s" % vehicle.battery)
print("GPS fix: %s" % vehicle.gps_0.fix_type)
# Kapcsolat lezárása
vehicle.close()
--------------------
Drón visszahívása
from dronekit import connect, VehicleMode
import time
# Csatlakozás a drónhoz
vehicle = connect('tcp:127.0.0.1:5760', wait_ready=True)
# Felszállás
def arm_and_takeoff(altitude):
print("Várakozás a drón készenlételére...")
while not vehicle.is_armable:
time.sleep(1)
print("Felszállás engedélyezése...")
vehicle.mode = VehicleMode("GUIDED")
vehicle.armed = True
while not vehicle.armed:
time.sleep(1)
print("Felszállás megkezdése...")
vehicle.simple_takeoff(altitude)
while True:
print("Aktuális magasság: %f m" % vehicle.location.global_relative_frame.alt)
if vehicle.location.global_relative_frame.alt >= altitude * 0.95:
print("Elértük a kívánt magasságot.")
break
time.sleep(1)
# Felszállás 10 méter magasságba
arm_and_takeoff(10)
# Visszahívás
print("Visszahívás a kezdeti helyre...")
vehicle.mode = VehicleMode("RTL")
# Várakozás a visszahívás befejezéséig
while True:
print("Drón állapota: %s" % vehicle.mode.name)
if vehicle.mode.name == "RTL" and not vehicle.armed:
print("Visszahívás befejeződött.")
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 not vehicle.armed:
time.sleep(1)
# Kapcsolat lezárása
vehicle.close()
-----------------
A célpont földrajzi pozíciójának meghatároza
from dronekit import connect, VehicleMode, LocationGlobalRelative
# Csatlakozás a drónhoz
vehicle = connect('tcp:127.0.0.1:5760', wait_ready=True)
# Földrajzi pozíció beállítása (példa koordináták)
target_latitude = 37.7749 # Példa: San Francisco, CA
target_longitude = -122.4194
# Célpont földrajzi pozíció beállítása
target_location = LocationGlobalRelative(target_latitude, target_longitude, 10) # Harmadik paraméter a magasság
# Célpont beállítása
vehicle.simple_goto(target_location)
# Várakozás, amíg eléri a célpontot
while True:
current_location = vehicle.location.global_relative_frame
distance_to_target = current_location.distance_to(target_location)
print(f"Távolság a céltól: {distance_to_target} méter")
if distance_to_target < 1: # Példa: A cél közelében
print("A drón elérte a célpontot.")
break
# Kapcsolat lezárása
vehicle.close()
------------
Global Navigation Satellite System
from dronekit import connect, VehicleMode
# Csatlakozás a drónhoz
vehicle = connect('tcp:127.0.0.1:5760', wait_ready=True)
# Ellenőrzés, hogy rendelkezik-e a drón GPS jelességgel
if vehicle.gps_0.fix_type > 1:
print("A drón rendelkezik GPS jellességgel.")
# GPS pozíció lekérdezése
latitude = vehicle.location.global_frame.lat
longitude = vehicle.location.global_frame.lon
altitude = vehicle.location.global_frame.alt
print(f"Földrajzi pozíció: Latitude: {latitude}, Longitude: {longitude}, Altitude: {altitude} méter")
else:
print("A drón nem rendelkezik elegendő GPS jellességgel.")
# Kapcsolat lezárása
vehicle.close()
---------------
Drónok távolságának és sebességének mérésére radar széles körben használt eszköz lehet, különféle szenzorokat használva. A radarok működése alapvetően az objektumokra visszaverődő rádióhullámok észlelésén alapul.
from dronekit import connect
# Csatlakozás a drónhoz
vehicle = connect('tcp:127.0.0.1:5760', wait_ready=True)
# Ellenőrzés, hogy rendelkezik-e a drón GPS jellességgel
if vehicle.gps_0.fix_type > 1:
print("A drón rendelkezik GPS jellességgel.")
# GPS pozíció lekérdezése
latitude = vehicle.location.global_frame.lat
longitude = vehicle.location.global_frame.lon
altitude = vehicle.location.global_frame.alt
print(f"Földrajzi pozíció: Latitude: {latitude}, Longitude: {longitude}, Altitude: {altitude} méter")
# Itt folytathatod a radarhoz szükséges kód írását
# ...
else:
print("A drón nem rendelkezik elegendő GPS jellességgel.")
# Kapcsolat lezárása
vehicle.close()
---------------
A drónok ultrahang- és Lidar-szenzorokat használhatnak a távolság mérésére, akadályok érzékelésére és navigációjuk javítására.
from dronekit import connect
import time
# Csatlakozás a drónhoz
vehicle = connect('tcp:127.0.0.1:5760', wait_ready=True)
# Ellenőrzés, hogy rendelkezik-e a drón szenzorokkal
if vehicle.rangefinder.distance:
print("A drón rendelkezik ultrahang-szenzorral.")
# Ultrahang távolság lekérdezése
ultrasonic_distance = vehicle.rangefinder.distance
print(f"Ultrahang távolság: {ultrasonic_distance} méter")
else:
print("A drón nem rendelkezik ultrahang-szenzorral.")
# Ellenőrzés, hogy rendelkezik-e a drón Lidar-szenzorral (példa)
if hasattr(vehicle, 'rangefinder_lidar') and vehicle.rangefinder_lidar.distance:
print("A drón rendelkezik Lidar-szenzorral.")
# Lidar távolság lekérdezése
lidar_distance = vehicle.rangefinder_lidar.distance
print(f"Lidar távolság: {lidar_distance} méter")
else:
print("A drón nem rendelkezik Lidar-szenzorral.")
# Várakozás néhány másodpercig
time.sleep(5)
# Kapcsolat lezárása
vehicle.close()
-------------------
Kamera bekapcsolása DJI SDK-t kell felhasználni, hogy hozzáférjünk a kamera- vagy videóérzékelő adataihoz.
from djitellopy import Tello
import cv2
# Csatlakozás a drónhoz
drone = Tello()
drone.connect()
# Kamera bekapcsolása
drone.streamon()
# Kép elkészítése
frame = drone.get_frame_read().frame
# Kép megjelenítése (OpenCV használatával)
cv2.imshow("Drone Camera", frame)
cv2.waitKey(0)
# Kapcsolat lezárása
drone.streamoff()
drone.disconnect()
--------------
DJI Thermal Analysis ToolKit-t (Thermal-ATK) használhatod az infravörös hőképek feldolgozásához. Infravörös (IR) szenzorokat gyakran használnak drónokban különböző alkalmazásokhoz, beleértve a hőképek készítését, éjszakai látást és a hőforrások detektálását
from djitellopy import Tello
from djitellopy.utils import load_joystick
import cv2
# Csatlakozás a drónhoz
drone = Tello()
drone.connect()
# IR kamera bekapcsolása
drone.enable_ir_video()
# Hőkép feldolgozása
frame = drone.get_ir_video_frame()
# Hőkép megjelenítése (OpenCV használatával)
cv2.imshow("IR Camera", frame)
cv2.waitKey(0)
# Kapcsolat lezárása
drone.disconnect()
----------------
Az Inertial Measurement Unit (IMU) szenzorok olyan eszközök, amelyek gyorsulásmérőt, giroszkópot és néha magnetométert kombinálnak a test mozgásának és orientációjának követésére. Az IMU szenzorok adatainak lekérdezése Pythonban különböző módon történhet, attól függően, hogy milyen típusú IMU-t használsz és milyen kommunikációs protokollt alkalmazol (pl. I2C, SPI).
Itt egy példa egy egyszerű Python programra, amely lekérdezi egy I2C-s IMU (például MPU6050) adatait. Ehhez a smbus modult fogjuk használni, amely az I2C kommunikáció kezelésére szolgál.
Ez a kód egy végtelen ciklusban periodikusan lekérdezi az IMU szenzor adatait, majd kiírja azokat a konzolra. Ne felejtsd el az IMU címét (IMU_ADDRESS), az I2C busz számát (I2C_BUS) és a regiszterek címét (ACCEL_XOUT_H, GYRO_XOUT_H) az adott IMU specifikációja alapján beállítani.
import smbus
import time
# Az I2C cím, ahol az IMU található
IMU_ADDRESS = 0x68
# Az I2C busz számának meghatározása
I2C_BUS = 1
# A gyorsulásmérő és giroszkóp regiszterek címzése
ACCEL_XOUT_H = 0x3B
GYRO_XOUT_H = 0x43
# Az I2C busz inicializálása
bus = smbus.SMBus(I2C_BUS)
def read_word_2c(reg):
# Két bájtos érték olvasása és 16 bites számmá alakítása
high = bus.read_byte_data(IMU_ADDRESS, reg)
low = bus.read_byte_data(IMU_ADDRESS, reg + 1)
val = (high << 8) + low
if val >= 0x8000:
return -((65535 - val) + 1)
else:
return val
def read_imu_data():
# Gyorsulásmérő és giroszkóp adatok olvasása
accel_xout = read_word_2c(ACCEL_XOUT_H)
gyro_xout = read_word_2c(GYRO_XOUT_H)
return accel_xout, gyro_xout
def main():
try:
while True:
# Gyorsulásmérő és giroszkóp adatok lekérése
accel_data, gyro_data = read_imu_data()
# Eredmények kiírása
print(f"Gyorsulásmérő adatok: {accel_data}, Giroszkóp adatok: {gyro_data}")
# Várakozás egy másodpercig
time.sleep(1)
except KeyboardInterrupt:
# Program leállítása, ha a felhasználó megszakítja a futást (Ctrl+C)
pass
finally:
# I2C busz lezárása
bus.close()
if __name__ == "__main__":
main()
---------------------------
Ez a példa egy egyszerű DroneUser osztályt és egy DroneSystem osztályt használ a felhasználók tárolására és beléptetésére. Azonban a valóságban használj mindig biztonságosabb és összetettebb hitelesítési rendszereket, például OAuth, JWT, vagy más megbízható rendszereket a felhasználókezeléshez. Az ilyen rendszerek komolyan veszik a biztonságot és az adatvédelmet.
Belépési rendszer
class DroneUser:
def __init__(self, username, password):
self.username = username
self.password = password
class DroneSystem:
def __init__(self):
# A felhasználók tárolására egy szótárat használunk
self.users = {}
def add_user(self, user):
# Felhasználó hozzáadása a rendszerhez
self.users[user.username] = user
def login(self, username, password):
# Felhasználó hitelesítése
if username in self.users and self.users[username].password == password:
print(f"Belépés engedélyezve: {username}")
else:
print("Hibás felhasználónév vagy jelszó")
def main():
# Példa felhasználók létrehozása
user1 = DroneUser("user1", "password1")
user2 = DroneUser("user2", "password2")
# Példa drón rendszer létrehozása
drone_system = DroneSystem()
# Felhasználók hozzáadása a rendszerhez
drone_system.add_user(user1)
drone_system.add_user(user2)
# Felhasználók beléptetése
drone_system.login("user1", "password1")
drone_system.login("user2", "wrong_password")
drone_system.login("user3", "password3")
if __name__ == "__main__":
main()
--------------------------------
Minden drónnak van egy azonosítója és státusza, és a rendszer lehetőséget biztosít a drónok hozzáadására, eltávolítására és státuszának kiíratására
Ebben a példában az osztály tartalmaz egy listát (drones), ami a drónokat tárolja. Minden drónnak van egy egyedi azonosítója (id) és egy státusza (status), például "Active" vagy "Inactive".
class Drone:
def __init__(self, drone_id, status):
self.id = drone_id
self.status = status
class DroneSystem:
def __init__(self):
# A drónok tárolására egy listát használunk
self.drones = []
def add_drone(self, drone):
# Drón hozzáadása a rendszerhez
self.drones.append(drone)
print(f"Drón hozzáadva a rendszerhez: {drone.id}")
def remove_drone(self, drone_id):
# Drón eltávolítása a rendszerből az azonosító alapján
for drone in self.drones:
if drone.id == drone_id:
self.drones.remove(drone)
print(f"Drón eltávolítva a rendszerből: {drone.id}")
return
print(f"Nem található drón az azonosítóval: {drone_id}")
def print_drone_status(self):
# Drónok státuszának kiíratása
for drone in self.drones:
print(f"Drón azonosítója: {drone.id}, Státusza: {drone.status}")
def main():
# Példa drón rendszer létrehozása
drone_system = DroneSystem()
# Példa drónok hozzáadása a rendszerhez
drone1 = Drone(drone_id=1, status="Active")
drone2 = Drone(drone_id=2, status="Inactive")
drone_system.add_drone(drone1)
drone_system.add_drone(drone2)
# Példa drónok státuszának kiíratása
drone_system.print_drone_status()
# Példa drón eltávolítása a rendszerből
drone_system.remove_drone(drone_id=1)
# Példa drónok státuszának újbóli kiíratása
drone_system.print_drone_status()
if __name__ == "__main__":
main()
----------------
Ebben a példában a Drone osztály tárolja a drón azonosítóját és a hozzátartozó jelszót. A DroneSystem osztály felelős a drónok tárolásáért, hozzáadásáért, és a hitelesítésért. A authenticate metódus ellenőrzi, hogy a megadott drón azonosító és jelszó egyezik-e a tároltakkal
class Drone:
def __init__(self, drone_id, password):
self.id = drone_id
self.password = password
class DroneSystem:
def __init__(self):
# A drónok tárolására egy szótárat használunk
self.drones = {}
def add_drone(self, drone_id, password):
# Drón hozzáadása a rendszerhez
drone = Drone(drone_id, password)
self.drones[drone_id] = drone
print(f"Drón hozzáadva a rendszerhez: {drone.id}")
def authenticate(self, drone_id, entered_password):
# Drón hitelesítése
if drone_id in self.drones:
drone = self.drones[drone_id]
if entered_password == drone.password:
print(f"Belépés engedélyezve a drónhoz: {drone.id}")
else:
print("Hibás jelszó")
else:
print(f"Nem található drón az azonosítóval: {drone_id}")
def main():
# Példa drón rendszer létrehozása
drone_system = DroneSystem()
# Példa drónok hozzáadása a rendszerhez
drone_system.add_drone(drone_id=1, password="secure_password")
drone_system.add_drone(drone_id=2, password="another_password")
# Példa drónok hitelesítése
drone_system.authenticate(drone_id=1, entered_password="wrong_password")
drone_system.authenticate(drone_id=1, entered_password="secure_password")
drone_system.authenticate(drone_id=3, entered_password="some_password")
if __name__ == "__main__":
main()
Az egyszerűség kedvéért ebben a példában csak egy jelszót tárolunk el a drónhoz, és a felhasználótól bekért jelszót hasonlítjuk össze a tárolttal.
-----------
Csomag meghívása
pip install pyserial
Aktív portok lezárása
Ebben a példában a serial.Serial objektum inicializálásakor megadod a használni kívánt soros port nevét ("/dev/ttyUSB0"), a sebességet (baudrate), és az időtúllépési időt (timeout). A write metódussal küldhetsz adatokat a drónnak, és a readline metódussal olvashatod a választ. A close metódus segítségével lezárhatod a portot.
port lezárása
a drónod a /dev/ttyUSB0 porton kommunikál
import serial
# Port inicializálása
serial_port = serial.Serial("/dev/ttyUSB0", baudrate=9600, timeout=1)
try:
# Drón vezérlése, kommunikáció a porton keresztül
# Példa: Küldj egy parancsot a drónnak
command = "TAKEOFF\r\n"
serial_port.write(command.encode())
# Várakozás a válaszra
response = serial_port.readline().decode()
print(f"Drón válasza: {response}")
# Példa: Lezárás (csak akkor, ha már nincs további kommunikáció)
serial_port.close()
except Exception as e:
print(f"Hiba történt: {e}")
finally:
# Biztosítsd, hogy a port mindig lezáródik, még hiba esetén is
if serial_port.is_open:
serial_port.close()
---------------------------------------
A katonai drónok szenzorokkal rendelkeznek, amelyek segítik az irányításukat, navigációjukat, környezeti érzékelésüket és feladatvégzésüket. A drónok szenzorai különböző típusok lehetnek, a következők közé tartozhatnak:
1. **GPS (Global Positioning System):** A GPS szenzorok lehetővé teszik a drónoknak, hogy meghatározzák a földrajzi pozíciójukat a világban.
2. **IMU (Inertial Measurement Unit):** Az IMU szenzorok méri a drón gyorsulását, szögelfordulását és szögsebességét, amelyek fontosak a stabil repüléshez és navigációhoz.
3. **Barométer:** A barométerek a légnyomást mérve segítenek a drónnak az aktuális magasságának meghatározásában.
4. **Kamera és Videóérzékelők:** A drónok gyakran felszereltek kamerákkal vagy más videóérzékelőkkel a környezetük vizuális megfigyeléséhez.
5. **Ultrahang- és Lidar-szenzorok:** Ezek a szenzorok segíthetnek a drónoknak az akadályok elkerülésében és a pontos távolságmérésben.
6. **IR (Infravörös) szenzorok:** Az IR szenzorok észlelhetik a hőt és segíthetnek a drónnak a célpontok felismerésében.
7. **Radar:** A radarok lehetővé teszik a drónok számára a távolság és a sebesség mérést, és hasznosak lehetnek az időjárási viszonyok figyelésében.
8. **GNSS (Global Navigation Satellite System):** Ezen rendszerek, mint például a GPS, más műholdak segítségével is meghatározhatják a drón pontos pozícióját.
