Abstract: With the popularization of drones, both military and civilian fields are facing an increasingly serious drone threat, and anti-drone technology has become a key technology for all countries. The technical threshold and difficulty of purchasing drones are constantly decreasing, and the frequency of using drones converted from civilian to military use in terrorist attacks, armed conflicts and other areas is increasing. The targets of attacks are mainly military, economic, political, livelihood and other facilities, as well as key political figures. In order to effectively deal with the security threats posed by drones, especially small civilian drones, domestic and foreign manufacturers have developed and manufactured a large number of drone control equipment systems. Generally speaking, these equipment systems basically use the operating logic of detection, surveillance, positioning, tracking and countermeasures, mainly using radar, optoelectronics, radio detection and interference, navigation deception and other equipment. These anti-drone equipment are currently being used more and more widely.
Keywords: UAV ; equipment; radar ; optoelectronics; radio;
Target analysis Due to the small size of drones and the light color of some drones, the color difference between them and the sky is small. Under normal circumstances, drones within 200-300 meters are basically impossible to be detected by human eyes. Illegal drones can pose a potential and real threat to public safety and the maintenance of normal production and life order, which can be divided into three aspects!
-----------------------
A repülési útvonalak és a telemetriai adatok programozását és a drón fel- és leszállását, valamint egy adott GPS-koordinátát adunk meg. Terepszkennelő/elszigetelő/erősítő mesterséges intelligenciákkal, hajszálvékony ravaszú tüzelési mechanizmusokkal, nulla késleltetésű megszakításokkal stb ADA. Java, C++ és python nyelveket használunk. Waypoint küldés, szimulátor, optoelektronika, kamerakép-feldolgozás, autonóm navigáció kutatási cél. A katonai drónok operációs rendszere (OS) és programozása a kritikus infrastruktúrák, a kiberbiztonság és az autonómia ötvözete. Ezek a rendszerek extrém körülmények között, jelforrás-mentes vagy ellenséges elektronikai hadviselési (zavaró) környezetben is megbízhatóan működnek.1. Főbb Operációs RendszerekA katonai és professzionális ipari drónok szoftveres alapjai nagymértékben eltérnek a civil verzióktól.Valós idejű operációs rendszerek (RTOS): A mikrosekundumos pontosság és a késleltetésmentes irányítás érdekében a hardvert (pl. rotorvezérlőket) RTOS vezérli, mint a FreeRTOS vagy a Wind River VxWorks.Beágyazott Linux disztribúciók: A navigációért és a mesterséges intelligenciáért felelős fedélzeti számítógépek leggyakrabban Linuxot futtatnak (pl. Ubuntu Core vagy Yocto Project alapú rendszerek), amelyek fokozott kiberbiztonsági rétegekkel vannak ellátva. Kiemelt autonómia keretrendszer: A PX4 Autopilot és az ArduPilot a legelterjedtebb nyílt forráskódú szoftverek, amelyeket a védelmi ipar gyakran alapként használ, majd saját, titkosított modulokkal (pl. AES-256 titkosítás, u-blox F9P RTK GPS) egészít ki. A drónok szoftvere egy hierarchikus rendszer, amely különböző szintű nyelveket igényel:C és C++: A hardverközeli programozás, a repülésvezérlés, az érzékelők (giroszkóp, barométer) kiolvasása és a motorok szabályozása szinte kizárólag C/C++ nyelven történik a maximális sebesség és hatékonyság miatt.Python: A felsőbb szintű logikák, a kameraképek feldolgozása, valamint a földi irányítóállomások (GCS) fejlesztéséhez használják, a gyors prototípus-gyártás érdekében.Ada / SPARK: Egyes szigorúan ellenőrzött, magas biztonsági kockázatú (safety-critical) katonai rendszerekben kötelező, mivel gyakorlatilag kizárja a programozási hibákat és a memóriaszivárgást. Katonai Specifikumok (Miért más, mint a civil?)A védelmi célú drónok programozása alapvető tervezési elveket követ:ECCM (Electronic Counter-Countermeasures): Olyan algoritmusok, amelyek felismerik, ha az ellenség zavarja a GPS-jelet vagy a rádiófrekvenciát (jamming/spoofing), és ilyenkor azonnal átváltanak inerciális navigációra (IMU) vagy vizuális helymeghatározásra.Mesh hálózatok és Raj-technológia (Swarm): A drónok képesek egymással kommunikálni, összehangoltan rajként viselkedni és feladatokat megosztani központi kapcsolat nélkül.Zero-Trust architektúra: A kommunikációs csatornák végponttól végpontig tartó (End-to-End) titkosítása és az adatok távoli megsemmisítése (kill-switch), ha a drón illetéktelen kézbe kerülne.Computer Vision és AI: A fedélzeti mesterséges intelligencia segítségével a drón képes emberi beavatkozás nélkül célpontokat azonosítani, követni, és az elvesztett kommunikáció esetén önállóan visszatérni a bázisra. Ez a dokumentum egy pilóta nélküli légi járművek (UAV) autonóm működésére tervezett Python program fejlesztését vázolja fel. A program olyan funkciókat foglal magában, mint a telemetria, az útvonaltervezés, a célkövetés, a leszállási eljárások, az autonómia, valamint a magas szintű gépi tanulás integrálása a számítógépes látás és a repülési feladatok automatizálása érdekében. TensorFlow , az OpenCV és az előre betanított modellek (YOLOv8 vagy MobileNetV2)
---------------------
from dronekit import connect, VehicleMode, LocationGlobalRelative
import time
# Csatlakozás a drónhoz (pl. USB-n vagy MAVLink-en keresztül)
# A COM port vagy IP cím a gép típusától függ
connection_string = '127.0.0.1:14550'
print('Kapcsolódás a drónhoz: %s' % connection_string)
vehicle = connect(connection_string, wait_ready=True)
# Felszállás (Takeoff) funkció
def arm_and_takeoff(target_altitude):
print("Pre-arm ellenőrzések...")
while not vehicle.is_armable:
print("Várakozás a drón inicializálására...")
time.sleep(1)
print("Motorok indítása (Arming motors)")
vehicle.mode = VehicleMode("GUIDED")
vehicle.armed = True
while not vehicle.armed:
print("Várakozás a motorok bekapcsolására...")
time.sleep(1)
print("Felszállás!")
vehicle.simple_takeoff(target_altitude)
# Várás, amíg eléri a beállított magasságot
while True:
print("Magasság: ", vehicle.location.global_relative_frame.alt)
if vehicle.location.global_relative_frame.alt >= target_altitude * 0.95:
print("Célmagasság elérve.")
break
time.sleep(1)
# Felszállás 10 méteres magasságba
arm_and_takeoff(10)
# Repülés egy megadott GPS koordinátára (pl. 47.9531, 21.6881)
print("Navigáció a célkoordináta felé...")
target_location = LocationGlobalRelative(47.9531, 21.6881, 10)
vehicle.simple_goto(target_location)
# Várakozás, amíg a drón megérkezik
time.sleep(30)
# Visszatérés a kiindulási pontra (RTL - Return to Launch)
print("Visszatérés a bázisra és leszállás...")
vehicle.mode = VehicleMode("RTL")
# Kapcsolat lezárása
vehicle.close()
print("Program vége.")
--------------------------
Úgyanez katonai drón esetén
------------------------
import time
import random
class UAV:
def __init__(self, name):
self.name = name
self.altitude = 0
self.position = (0, 0)
self.target_position = (0, 0)
def take_off(self, altitude):
self.altitude = altitude
print(f"{self.name} is taking off to {self.altitude} meters.")
def set_target(self, target_position):
self.target_position = target_position
print(f"{self.name} target set to {self.target_position}.")
def fly_to_target(self):
while self.position != self.target_position:
self.position = (self.position[0] + random.choice([-1, 0, 1]),
self.position[1] + random.choice([-1, 0, 1]))
print(f"{self.name} flying to {self.position}.")
time.sleep(1)
print(f"{self.name} has reached the target at {self.position}.")
def land(self):
self.altitude = 0
print(f"{self.name} is landing.")
# Example usage
uav = UAV("Drone1")
uav.take_off(100)
uav.set_target((5, 5))
uav.fly_to_target()
uav.land()
--------------
pip telepítés ultralytics opencv-python matplotlib
Opcionális (saját adatkészlet betanításához)
pip telepítés roboflow felügyelet
A YOLOv8 használata valós idejű objektumészleléshez
Iratkozzon fel Rafaa Zahra történeteire a postaládájába
Csatlakozz ingyenesen a Mediumhoz, hogy frissítéseket kapj ettől az írótól.
Add meg az e-mail címed
Feliratkozás
Emlékezz rám a gyorsabb bejelentkezés érdekében
A YOLOv8 előre betanított modelljét fogjuk használni az objektumészleléshez. A YOLO (You Only Look Once, azaz Csak egyszer nézel rá) gyors és pontos, ideális a valós idejű drónészleléshez.
Mappaszerkezet
military_vision_ai/
│
├── tesztképek/
│ └── drón_teherautó.jpg
├── detekt.py
├── README.md
Python kód: detect.py
from ultralytics import YOLO
import cv2
import matplotlib.pyplot as plt
# Előre betanított YOLOv8 modell betöltése
model = YOLO( "yolov8n.pt" ) # A jobb pontosság érdekében használhatod a yolov8m.pt vagy yolov8x.pt
fájlokat # Kép betöltése és feldolgozása
image_path = "test_images/drone_truck.jpg"
image = cv2.imread(image_path)
# BGR konvertálása RGB-vé a vizualizációhoz
rgb_image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
# Észlelési eredmények futtatása
= model(image_path, show= True , conf= 0.5 )
# Észlelési eredmények mentése vagy megtekintése
[ 0 ].save(filename= "output.jpg" )
# Opcionális: Megjelenítés matplotlib használatával
plt.imshow(rgb_image)
plt.title( "Bemeneti kép" )
plt.axis( "off" )
plt.show()
Egyedi modell (a drónok/teherautók/katonai járművek jobb észleléséhez)
C++ modell
# include <opencv2/opencv.hpp>
# include <opencv2/dnn.hpp>
# include <iostream>
using namespace cv;
using namespace std;
int main () {
// Mat kép betöltése
image = imread ( "test.jpg" );
if (image.empty ( )) {
cerr << "A kép nem található!" << endl;
return -1 ;
}
// ONNX modell betöltése
dnn::Net net = dnn:: readNetFromONNX ( "yolov8n.onnx" );
//
Mat előfeldolgozása blob;
Size input_size = Size ( 640 , 640 );
dnn:: blobFromImage (image, blob, 1.0 / 255.0 , input_size, Scalar (), true , false );
// Bemenet beállítása és következtetés futtatása
net. setInput (blob);
vector<Mat> outputs;
net.forward(outputs, net. getUnconnectedOutLayersNames ());
// Kimenet elemzése (YOLOv8 formátum)
float conf_threshold = 0.5 ;
float nms_threshold = 0.4 ;
vector<int> class_ids ;
vector <float> confidencies;
vector<Rect> boxes;
const int rows = outputs[ 0 ].size[ 1 ];
for ( int i = 0 ; i < rows; ++i) {
float * data = ( float *)outputs[ 0 ].data + i * outputs[ 0 ].size[ 2 ];
float confidence = data[ 4 ];
if (confidence > conf_threshold) {
float * classes_scores = data + 5 ;
Mat scores ( 1 , outputs[ 0 ].size[ 2 ] - 5 , CV_32FC1, classes_scores) ;
Point class_id_point;
double max_class_score;
minMaxLoc (pontszámok, 0 , és max_osztály_pontszám, 0), &class_id_point);
if (max_class_score > conf_threshold) {
int center_x = ( int )(data[ 0 ] * image.cols);
int center_y = ( int )(data[ 1 ] * image.rows);
int width = ( int )(data[ 2 ] * image.cols);
int height = ( int )(data[ 3 ] * image.rows); int
left = center_x - width / 2 ;
int top = center_y - height / 2 ;
class_ids.push_back (class_id_point.x); confidencies.push_back ( ( float )max_class_score); boxes.push_back ( Rect (left, top, width, height)); } } } // NMS vektor<int> indexes ; dnn:: NMSBoxes (boxes, confidencies, conf_threshold, nms_threshold, indexes); } for ( int i : indexes) { Rect box = boxes[i]; rectangle (image, box, Scalar ( 0 , 255 , 0 ), 2 ); putText (image, to_string (class_ids[i]), Point (box.x, box.y- 10 ), FONT_HERSHEY_SIMPLEX, 0.5 , Scalar ( 0 , 255 , 0 ), 2 ); } // Eredmény megjelenítése imshow ( "Detection" , image); waitKey ( 0 ); return 0 ; }
Ha a cél a kizárólag katonai célú objektumok osztályozása , akkor betanítson egy egyéni YOLOv8 modellt a Roboflow adatkészleteinek felhasználásával:
# Roboflow CLI telepítése
pip install roboflow
# Modell betanítása
yolo task=detect mode=train model=yolov8n.pt data=your_data.yaml epochs=50 imgsz=640
Teljesítmény tippek
Drónok valós idejű észleléséhez használja a yolov8n.pt(nano modellt) peremhálózati eszközökkel (Jetson Nano, Raspberry Pi 5).
Nagyobb pontosság érdekében használja yolov8x.pt.
Optimalizálja a videóadagolást vágással és átméretezéssel, mielőtt betáplálja a modellbe.
A fedélzeti kamera másodpercenként rögzít képeket, és elküldi azokat egy központi feldolgozóegységnek. Python AI szkriptünk:
Gyanús tárgyakat észlel (drónok, teherautók)
Riasztásokat küld a bázisnak, ha az észlelési megbízhatóság > 80%
Opcionálisan menti a GPS és az időbélyeg adatokat
Valós idejű (videó stream)
cap = cv2.VideoCapture( 0 ) # Cserélje le drónkamera streamjére
while cap.isOpened():
success, frame = cap.read()
if not success:
break
results = model(frame, conf= 0.5 )
annotated_frame = results[ 0 ].plot()
cv2.imshow( "Katonai felderítés" , annotated_frame)
if cv2.waitKey( 1 ) & 0xFF == ord ( 'q' ):
break
cap.release()
cv2.destroyAllWindows()
----------------------
A katonai drónok (UAV-ok) fegyverzete típustól és feladattól függően nagyon eltérő lehet. Általánosságban a következő kategóriák léteznek:
Irányított rakéták – például páncélozott járművek vagy egyéb célpontok ellen.
Irányított bombák – GPS- vagy lézervezérlésű bombák precíziós csapásokhoz.
Loitering munition („öngyilkos drón”) – maga a drón a robbanófej hordozója, és a célba csapódva semmisül meg.
Elektronikai hadviselési rendszerek – zavaró vagy felderítő berendezések, nem feltétlenül hagyományos fegyverek.
Felderítő UAV-ok – sok katonai drón egyáltalán nem hordoz fegyvert, csak kamerákat, radarokat vagy egyéb érzékelőket.
Néhány ismert példa:
MQ-9 Reaper – rakétákat és irányított bombákat hordozhat.
Bayraktar TB2 – könnyű precíziós fegyverek alkalmazására képes.
Shahed-136 – loitering munition típusú rendszer.
Ha egy adott dróntípus fegyverzetére vagy műszaki jellemzőire vagy kíváncsi, meg tudom adni a nyilvánosan elérhető információkat. Nem tudok azonban útmutatást adni fegyverek építéséhez, módosításához vagy alkalmazásához.
-------------------
A Python a drónprogramozáshoz a választott nyelv az egyszerűsége, rugalmassága és nagy ökoszisztémája miatt. A Python segítségével könnyedén integrálhatsz számítógépes látást (OpenCV), gépi tanulást (TensorFlow), GPS navigációt, valós idejű telemetriát és egyebeket a drónalkalmazásaidba.Egy drón hatékony programozásához meg kell érteni, hogyan rétegzett a szoftverarchitektúrája – hasonlóan ahhoz, ahogy egy számítógép működik.
1. Hardverréteg
Ez magában foglalja a fizikai összetevőket:
Motorok
Elektronikus sebességszabályozók (ESC-k)
Propellerek
Repülésirányító
GPS, IMU-k és egyéb érzékelők
Nem fogsz közvetlenül ezzel a kódban interakcióba lépni, de a szkripteid végső soron szoftverrétegek láncolatán keresztül fogják vezérelni ezt a hardvert.Alkalmazásréteg: DroneKit-Python
A DroneKit-Python egy nyílt forráskódú SDK, amely a MAVLinkre épül. Kiküszöböli a bonyolultságot, és lehetővé teszi Python szkriptek írását a következőkhöz:
Felszállás
Föld
Útpontok követése
Telemetria monitorozása
Hibabiztos megoldások és viselkedések megvalósítása
Ideális prototípus-készítéshez, szimulációhoz, kutatáshoz és akár valós telepítésekhez is.A SITL (Software-In-The-Loop) egy drónt szimulál a számítógépeden. Tökéletes fejlesztéshez és teszteléshez.
# Clone ArduPilot repo
git clone https://github.com/ardupilot/ardupilot
cd ardupilot
git submodule update --init --recursive
# Start SITL simulator
cd ArduCopter
../Tools/autotest/sim_vehicle.py --console --map
Ez egy szimulált quadkoptert indít a localhoston a porton.14550.
Telepítse a DroneKit Pythont
pip install dronekit==2.9.2
Az első DroneKit Python szkript megírása
Itt egy egyszerű Python szkript, ami felfegyverzi a drónt, 5 méter magasra emelkedik, majd leszáll.
from dronekit import connect, VehicleMode, LocationGlobalRelative
import time
# Connect to the simulated drone
vehicle = connect('127.0.0.1:14550', wait_ready=True)
def arm_and_takeoff(target_altitude):
while not vehicle.is_armable:
print("Waiting for drone to become armable...")
time.sleep(1)
print("Arming motors...")
vehicle.mode = VehicleMode("GUIDED")
vehicle.armed = True
while not vehicle.armed:
print("Waiting for arming...")
time.sleep(1)
print("Taking off!")
vehicle.simple_takeoff(target_altitude)
while True:
current_alt = vehicle.location.global_relative_frame.alt
print(f"Altitude: {current_alt:.2f} m")
if current_alt >= target_altitude * 0.95:
print("Target altitude reached.")
break
time.sleep(1)
# Run the mission
arm_and_takeoff(5)
vehicle.mode = VehicleMode("LAND")
print("Landing...")
# Close connection
vehicle.close()
A szkript futtatása egy szimulált drónon
Indítsa el a SITL drónt a következőn keresztül sim_vehicle.py: .
Futtassa a Python szkriptet egy külön terminálban.
Nézd meg a drón felszállását és leszállását – mindezt szimulációban!
Fizikai drón programozása
Egy igazi drón irányításához:
Használjon egy társszámítógépet (pl. Raspberry Pi), amely UART vagy USB kapcsolaton keresztül csatlakozik a repülésvezérlőhöz.
Győződjön meg arról, hogy az ArduPilot vagy a PX4 telepítve van.
Futtassa a Python szkriptet a társszámítógépen.
Győződjön meg arról, hogy a GPS-modul, a telemetriai rádió és a biztonsági ellenőrzések a helyükön vannak.
Megjegyzés: Mindig teszteld a kódodat szimulációban, mielőtt valódi drónt reptetsz. Csak a végén szereld fel rá a fegyverzetet!
--------------------
#!/usr/bin/env python3
def build(bld):
vehicle = bld.path.name
bld.ap_stlib(
name=vehicle + '_libs',
ap_vehicle=vehicle,
ap_libraries=bld.ap_common_vehicle_libraries() + [
'APM_Control',
'AP_AdvancedFailsafe',
'AP_Avoidance',
'AP_Camera',
'AP_L1_Control',
'AP_Navigation',
'AP_TECS',
'AP_InertialNav',
'AC_WPNav',
'AC_AttitudeControl',
'AP_Motors',
'AP_Landing',
'PID',
'AP_Soaring',
'AP_LTM_Telem',
'AP_Devo_Telem',
'AC_AutoTune',
'AP_Follow',
'AC_PrecLand',
'AP_IRLock',
'AP_Quicktune',
],
)
bld.ap_program(
program_name='arduplane',
program_groups=['bin', 'plane'],
use=vehicle + '_libs',
)
------------------------------
Katonai drón célzórendszere
Fő elemei:
Elektrooptikai kamera (EO)
Nagy felbontású nappali kamera.
Erős optikai zoom a távoli célok megfigyelésére.
Infravörös kamera (IR/FLIR)
Éjszaka vagy rossz látási viszonyok között is képes hőképet készíteni.
Emberek, járművek és más hőforrások felderítésére használható.
Lézeres távmérő
Meghatározza a cél távolságát.
Pontos koordinátaszámítást tesz lehetővé.
Lézeres célmegjelölő
Egyes rendszerek lézersugárral megjelölik a célpontot.
Más platformok érzékelhetik ezt a jelölést.
Automatikus célkövetés
Képfeldolgozó algoritmusok segítségével a rendszer automatikusan követi a kijelölt objektumot.
A kezelőnek nem kell folyamatosan manuálisan irányítania a kamerát.
GPS és inerciális navigáció
A drón és a célpont földrajzi helyzetének meghatározására szolgál.
Pontos koordinátákat ad a kezelőnek.
Mesterséges intelligencia
Képes lehet járművek, hajók vagy egyéb objektumok felismerésére.
A modern rendszerek segíthetik a kezelőt a célok osztályozásában.
Fontos: a célzórendszer felépítésének részletes működési, beállítási vagy alkalmazási útmutatói katonai és biztonsági szempontból érzékeny információk lehetnek. Ha műszaki vagy történeti áttekintés érdekel, arról szívesen írok részletesebben. Egy katonai drón célzórendszere általában több alrendszerből áll, amelyek együtt azonosítják, követik és kijelölik a célpontokat.
---------------------
A célzórendszerek fejlesztése során különböző technológiák és algoritmusok alkalmazására van szükség, mint például célkövetés, mozgásérzékelés, hőkövetés és alakfelismerés. Az alábbiakban három különböző megoldást mutatok be, mindegyik egy-egy specifikus funkciót valósít meg.
-------------------------
import cv2
def celkovetes(video_path):
cap = cv2.VideoCapture(video_path)
while True:
ret, frame = cap.read()
if not ret:
break
# Cél követése (pl. szín alapú)
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
lower_color = (30, 150, 50)
upper_color = (85, 255, 255)
mask = cv2.inRange(hsv, lower_color, upper_color)
contours, _ = cv2.findContours(mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
for contour in contours:
if cv2.contourArea(contour) > 500:
x, y, w, h = cv2.boundingRect(contour)
cv2.rectangle(frame, (x, y), (x+w, y+h), (255, 0, 0), 2)
cv2.imshow('Célkövetés', frame)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
cap.release()
cv2.destroyAllWindows()
celkovetes('video.mp4')
------------------------
import cv2
def mozgaserzeles(video_path):
cap = cv2.VideoCapture(video_path)
ret, frame1 = cap.read()
ret, frame2 = cap.read()
while cap.isOpened():
diff = cv2.absdiff(frame1, frame2)
gray = cv2.cvtColor(diff, cv2.COLOR_BGR2GRAY)
blur = cv2.GaussianBlur(gray, (5, 5), 0)
_, thresh = cv2.threshold(blur, 20, 255, cv2.THRESH_BINARY)
dilated = cv2.dilate(thresh, None, iterations=3)
contours, _ = cv2.findContours(dilated, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
for contour in contours:
if cv2.contourArea(contour) > 500:
x, y, w, h = cv2.boundingRect(contour)
cv2.rectangle(frame1, (x, y), (x+w, y+h), (0, 255, 0), 2)
cv2.imshow('Mozgásérzékelés', frame1)
frame1 = frame2
ret, frame2 = cap.read()
if cv2.waitKey(1) & 0xFF == ord('q'):
break
cap.release()
cv2.destroyAllWindows()
mozgaserzeles('video.mp4')
--------------
import cv2
import numpy as np
def hokovetes(video_path):
cap = cv2.VideoCapture(video_path)
while True:
ret, frame = cap.read()
if not ret:
break
# Hőmérséklet szimulálása (példa)
heatmap = cv2.applyColorMap(frame, cv2.COLORMAP_JET)
cv2.imshow('Hőkövetés', heatmap)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
cap.release()
cv2.destroyAllWindows()
hokovetes('video.mp4')
---------------
A katonai drónok kommunikációs és kódolási rendszereinek fejlesztése kulcsfontosságú a biztonságos és hatékony működés érdekében. Az alábbiakban három különböző megoldást mutatunk be Python nyelven, amelyek különböző aspektusait célozzák meg a drónok közötti kommunikációnak és az adatok kódolásának.
import socket
def start_drone_communication(host='localhost', port=5000):
with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as sock:
sock.bind((host, port))
print(f"Drón kommunikációs rendszer elindítva a {host}:{port} címen.")
while True:
data, addr = sock.recvfrom(1024)
print(f"Üzenet érkezett {addr}: {data.decode()}")
response = f"Üzenet fogadva: {data.decode()}"
sock.sendto(response.encode(), addr)
if __name__ == "__main__":
start_drone_communication()
---------
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad, unpad
import os
def encrypt_message(message, key):
cipher = AES.new(key, AES.MODE_CBC)
ct_bytes = cipher.encrypt(pad(message.encode(), AES.block_size))
return cipher.iv + ct_bytes
def decrypt_message(ciphertext, key):
iv = ciphertext[:16]
ct = ciphertext[16:]
cipher = AES.new(key, AES.MODE_CBC, iv)
return unpad(cipher.decrypt(ct), AES.block_size).decode()
if __name__ == "__main__":
key = os.urandom(16) # 16 byte key for AES-128
message = "Katonai drón üzenet"
encrypted = encrypt_message(message, key)
print(f"Titkosított üzenet: {encrypted}")
decrypted = decrypt_message(encrypted, key)
print(f"Visszafejtett üzenet: {decrypted}")
---------------
import json
import socket
def send_message(drone_ip, message):
with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as sock:
json_message = json.dumps(message).encode()
sock.sendto(json_message, (drone_ip, 5000))
print(f"Üzenet küldve: {json_message}")
def receive_message():
with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as sock:
sock.bind(('localhost', 5000))
print("Várakozás üzenetre...")
data, addr = sock.recvfrom(1024)
message = json.loads(data.decode())
print(f"Üzenet érkezett {addr}: {message}")
if __name__ == "__main__":
# Példa üzenet
message = {"drone_id": "drone_1", "command": "takeoff"}
send_message('localhost', message)
receive_message()
---------------
Nincsenek megjegyzések:
Megjegyzés küldése