pyaidrone 2.3__tar.gz → 2.5__tar.gz

{pyaidrone-2.3 → pyaidrone-2.5}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.1
 Name: pyaidrone
-Version: 2.3
+Version: 2.5
 Summary: Library for AIDrone Products
 Home-page: http://www.ir-brain.com
 Author: IR-Brain
@@ -10,17 +10,6 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.6
 Description-Content-Type: text/markdown
-Requires-Dist: pyserial>=3.4
-Requires-Dist: pynput>=1.7.3
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
 
 ## install pyaidrone
 

pyaidrone-2.5/pyaidrone/aiDrone.py

@@ -0,0 +1,282 @@
+import serial
+from time import sleep
+from threading import Thread
+from serial.tools.list_ports import comports
+from pyaidrone.parse import *
+from pyaidrone.packet import *
+from pyaidrone.deflib import *
+
+
+class AIDrone(Parse,  Packet):
+    def __init__(self, receiveCallback = None):
+        self.serial = None
+        self.isThreadRun = False
+        self.parse = Parse(AIDRONE)
+        self.makepkt = Packet(AIDRONE)
+        self.receiveCallback = receiveCallback
+        self.makepkt.clearPacket()
+        self.posX = 0
+        self.posY = 0
+        self.rot = 0        
+        # --- 영상 스트리밍 관련 기본값 ---
+        self.stream_host = "192.168.4.1"
+        self.stream_port = 80
+        self.stream_path = "/?action=stream"
+        self._cap = None
+
+    def receiveHandler(self):
+        while self.isThreadRun:
+            try:
+                readData = self.serial.read(self.serial.in_waiting or 1)
+                # [수정] 문자열 "None" 비교 → None 객체 비교
+                packet = self.parse.packetArrange(readData)
+                if packet is not None:
+                    if self.receiveCallback is not None:
+                        self.receiveCallback(packet)
+                self.serial.write(self.makepkt.getPacket())
+            except serial.SerialException as e:
+                # [수정] 시리얼 오류는 치명적 → 스레드 정상 종료
+                print(f"[receiveHandler] 시리얼 오류: {e}")
+                self.isThreadRun = False
+                break
+            except Exception as e:
+                # [수정] 일시적 오류는 스레드 유지 (break 제거)
+                print(f"[receiveHandler] 일시 오류 (계속 실행): {e}")
+
+        
+    def Open(self, portName = None):
+        if portName is None:
+            nodes = comports()
+            for node in nodes:
+                if "CH340" in node.description:
+                    portName = node.device
+
+            if portName is None:
+                print("Can't find Serial Port")
+                raise ConnectionError("CH340 시리얼 포트를 찾을 수 없습니다.")
+        try:
+            self.serial = serial.Serial(port=portName, baudrate=19200, timeout=1)
+            if self.serial.isOpen():
+                self.isThreadRun = True
+                self.thread = Thread(target=self.receiveHandler, args=(), daemon=True)
+                self.thread.start()
+                print("Connected to", portName)
+                return True
+            else:
+                print("Can't open " + portName)
+                raise ConnectionError(f"포트를 열 수 없습니다: {portName}")
+        except serial.SerialException as e:
+            # [수정] 구체적 예외 처리
+            print(f"시리얼 포트 오류: {e}")
+            raise
+        except ConnectionError:
+            raise
+        except Exception as e:
+            print(f"Can't open {portName}: {e}")
+            raise ConnectionError(f"포트 연결 실패: {portName}") from e
+			
+
+    def Close(self):
+        self.isThreadRun = False
+        sleep(0.2)
+        try:
+            # [수정] serial.write 예외처리 추가 (포트 닫힌 상태 보호)
+            pkt = self.makepkt.getPacket()
+            if (pkt[15] & 0x80) == 0x80:
+                self.makepkt.clearPacket()
+                self.setOption(0x8000)
+                self.serial.write(self.makepkt.getPacket())
+                sleep(0.2)
+            self.serial.write(self.makepkt.clearPacket())
+            sleep(0.2)
+        except Exception:
+            pass
+        finally:
+            if self.serial is not None and self.serial.isOpen():
+                self.serial.close()
+
+    def setOption(self, option):
+        data = option.to_bytes(2, byteorder="little", signed=False)
+        self.makepkt.makePacket(14, data)
+
+
+    def takeoff(self):
+        alt = 70
+        data = alt.to_bytes(2, byteorder="little", signed=False)
+        self.makepkt.makePacket(12, data)
+        self.setOption(0x2F)
+
+
+    def landing(self):
+        alt = 0
+        data = alt.to_bytes(2, byteorder="little", signed=False)
+        self.makepkt.makePacket(12, data)
+
+
+    def altitude(self, alt):
+        data = alt.to_bytes(2, byteorder="little", signed=False)
+        self.makepkt.makePacket(12, data)
+
+
+    def velocity(self, dir=0, vel=100):
+        if dir > 3:
+            return
+        if dir==1 or dir==3:
+            vel *= -1; 
+        data = vel.to_bytes(2, byteorder="little", signed=True)
+        if dir==0 or dir==1:
+            self.makepkt.makePacket(8, data)
+        else:
+            self.makepkt.makePacket(6, data)
+        self.setOption(0x0F)
+
+
+    def move(self, dir=0, dist=100):
+        if dir > 3:
+            return
+        if dir==1 or dir==3:
+            dist *= -1; 
+        if dir==0 or dir==1:
+            self.posX += dist
+            data = self.posX.to_bytes(2, byteorder="little", signed=True)
+            self.makepkt.makePacket(8, data)
+        else:
+            self.posY += dist
+            data = self.posY.to_bytes(2, byteorder="little", signed=True)
+            self.makepkt.makePacket(6, data)
+        self.setOption(0x2F)
+    
+	
+    def rotation(self, rot=90):
+        self.rot += rot
+        # 프로토콜: YAW는 절대 회전각 -180 ~ 180 degree
+        if self.rot > 180:
+            self.rot -= 360
+        elif self.rot < -180:
+            self.rot += 360
+        data = self.rot.to_bytes(2, byteorder="little", signed=True)
+        self.makepkt.makePacket(10, data)
+
+
+
+    def motor(self, what, speed):
+        speed = DefLib.constrain(speed, 100, 0)
+        data = speed.to_bytes(2, byteorder="little", signed=True)
+        self.makepkt.makePacket(what*2+6, data)
+        self.setOption(0x8000)
+
+
+    def emergency(self):
+        self.setOption(0x00)
+        self.serial.write(self.makepkt.getPacket())
+
+    def requestSensorData(self, data_type: int, sig_mode: int = None) -> None:
+        """
+        드론에 센서 데이터 출력을 요청합니다.
+
+        data_type 9  : 비행정보 요청 (roll / pitch / height / pos_x / pos_y)
+                       sig_mode — 기본값 1 (출력 시작)
+        data_type 10 : 센서·제어 신호 요청
+                       sig_mode — SIG 값 (POS_SIGNAL=0x06, 기타 0x01~0x05)
+                                  기본값 0x06 (flow_x, flow_y, tof 포함)
+
+        프로토콜 참고 (AIDrone Protocol.pdf):
+          TYPE(9)  — Command Packet B2: 26 A8 14 B2 08 CS 09 MODE
+          TYPE(10) — Command Packet B1: 26 A8 14 B1 08 CS 0A SIG
+        """
+        if self.serial is None or not self.serial.isOpen():
+            return
+        if data_type == 9:
+            mode = 1 if sig_mode is None else (sig_mode & 0xFF)
+            pkt = bytearray([0x26, 0xA8, 0x14, 0xB2, 0x08, 0x00, 0x09, mode])
+            pkt[5] = sum(pkt[4:]) & 0xFF
+            self.serial.write(pkt)
+        elif data_type == 10:
+            sig = 0x06 if sig_mode is None else (sig_mode & 0xFF)
+            pkt = bytearray([0x26, 0xA8, 0x14, 0xB1, 0x08, 0x00, 0x0A, sig])
+            pkt[5] = sum(pkt[4:]) & 0xFF
+            self.serial.write(pkt)
+
+    def stopSensorData(self, data_type: int) -> None:
+        """
+        드론에 센서 데이터 출력 중지를 요청합니다.
+
+        data_type 9  : 비행정보 출력 중지 (MODE=0)
+        data_type 10 : 센서·제어 신호 출력 중지 (STOP_SIGNAL=0x00)
+        """
+        if self.serial is None or not self.serial.isOpen():
+            return
+        if data_type == 9:
+            pkt = bytearray([0x26, 0xA8, 0x14, 0xB2, 0x08, 0x00, 0x09, 0x00])
+            pkt[5] = sum(pkt[4:]) & 0xFF
+            self.serial.write(pkt)
+        elif data_type == 10:
+            pkt = bytearray([0x26, 0xA8, 0x14, 0xB1, 0x08, 0x00, 0x0A, 0x00])
+            pkt[5] = sum(pkt[4:]) & 0xFF
+            self.serial.write(pkt)
+        
+    # aiDrone.py — AIDrone 클래스 안에 아래 3개 메서드 추가
+    def setStreamAddress(self, host: str, port: int = 80, path: str = "/?action=stream"):
+        """MJPG-Streamer 주소 구성 요소를 저장합니다."""
+        if not isinstance(host, str) or len(host.strip()) == 0:
+            raise ValueError("host가 올바르지 않습니다.")
+        self.stream_host = host.strip()
+        self.stream_port = int(port)
+        if not path.startswith("/"):
+            path = "/" + path
+        self.stream_path = path
+        return self._build_stream_url()
+
+    def _build_stream_url(self):
+        """내부 사용: 저장된 host/port/path로 URL 생성."""
+        if self.stream_port in (80, None):
+            return f"http://{self.stream_host}{self.stream_path}"
+        return f"http://{self.stream_host}:{self.stream_port}{self.stream_path}"
+
+    def streamon(self, host: str = None, port: int = None, path: str = None, return_url: bool = False):
+        """
+        MJPG-Streamer 스트림을 엽니다.
+        - 인자를 주면 해당 값으로 주소를 덮어쓰고, 안 주면 저장된 값 사용.
+        - return_url=True 이면 URL 문자열만 반환(캡처는 열지 않음).
+        - 기본 URL 예: http://192.168.4.1/?action=stream
+        """
+        if host is not None or port is not None or path is not None:
+            self.setStreamAddress(host or self.stream_host,
+                                  self.stream_port if port is None else port,
+                                  self.stream_path if path is None else path)
+
+        url = self._build_stream_url()
+        if return_url:
+            return url
+
+        # OpenCV는 여기서만 임포트(필요할 때만)
+        try:
+            import cv2 as cv
+        except Exception as e:
+            raise RuntimeError(f"OpenCV(cv2) 임포트 실패: {e}")
+
+        # 이전 cap이 열려 있으면 정리
+        self.streamoff()
+
+        self._cap = cv.VideoCapture(url)
+        if not self._cap.isOpened():
+            self._cap.release()
+            self._cap = None
+            raise RuntimeError(f"스트림 열기 실패: {url}")
+        return self._cap
+
+    def streamoff(self):
+        """열려 있는 스트림을 닫습니다."""
+        if self._cap is not None:
+            try:
+                self._cap.release()
+            except Exception:
+                pass
+            self._cap = None
+
+
+        
+    
+
+
+

pyaidrone-2.5/pyaidrone/deflib.py

@@ -0,0 +1,41 @@
+AIDRONE = 1
+
+
+FRONT = 0
+BACK = 1
+RIGHT = 2
+LEFT = 3
+
+class DefLib:
+
+    @classmethod
+    def checksum(cls, packet):
+        length = packet[4]
+        total = 0
+        for n in range(6, length):
+            total += packet[n]
+        return total & 0xFF
+
+
+    @classmethod
+    def _print(cls, data):
+        for n in range(0, len(data)):
+            h = hex(data[n])
+#            print(h, end=" ")
+#        print("")
+
+
+    @classmethod
+    def constrain(cls, val, val_max, val_min):
+        if val > val_max:
+            val = val_max
+        if val < val_min:
+            val = val_min
+        return val
+
+
+    @classmethod
+    def comp(cls, data):
+        # &0xFF 결과는 항상 0~255이므로 부호 분기 불필요
+        return data & 0xFF
+

{pyaidrone-2.3 → pyaidrone-2.5}/pyaidrone/ikeyevent.py

@@ -83,8 +83,8 @@ class IKeyEvent:
         self.keyTracking = False
         self.keyEsc = False
 
-        listener = keyboard.Listener(on_press=self.on_press, on_release=self.on_release)
-        listener.start()
+        self.listener = keyboard.Listener(on_press=self.on_press, on_release=self.on_release)
+        self.listener.start()
 
     def isKeyEnterPressed(self):
         return self.keyEnter

{pyaidrone-2.3 → pyaidrone-2.5}/pyaidrone/packet.py

@@ -12,8 +12,11 @@ class Packet:
 
 
     def makePacket(self, start, data):
-        for n in range(start, start+len(data)):
-            self.packet[n] = data[n-start]
+        end = start + len(data)
+        if end > len(self.packet):
+            raise ValueError(f"makePacket: 범위 초과 (start={start}, len={len(data)}, packet={len(self.packet)})")
+        for n in range(start, end):
+            self.packet[n] = data[n - start]
         self.packet[5] = DefLib.checksum(self.packet)
 #        DefLib._print(self.packet)
         return self.packet

pyaidrone-2.5/pyaidrone/sensor.py

@@ -0,0 +1,69 @@
+#AIDrone sensor 라이브러리 (26.01.15)
+import struct
+from pyaidrone.deflib import DefLib
+
+class AIDroneSensor:
+    def __init__(self):
+        # 센서 데이터 및 비행 상태 통합 저장소
+        self.state = {
+            'battery': 0,      # 배터리 잔량 (%) 
+            'tof': 0,          # VL53L01X 고도 센서 값 (mm) 
+            'flow_x': 0,       # PMW3901 광학 흐름 센서 X축 변화량 
+            'flow_y': 0,       # PMW3901 광학 흐름 센서 Y축 변화량 
+            'pos_x': 0,        # 이륙 지점 기준 X 좌표 (cm) 
+            'pos_y': 0,        # 이륙 지점 기준 Y 좌표 (cm) 
+            'height': 0,       # 드론이 계산한 현재 높이 (cm) 
+            'roll': 0,         # 현재 좌우 기울기 
+            'pitch': 0,        # 현재 앞뒤 기울기 
+            'ready': False,    # 비행 준비 상태 
+            'emergency': False # 응급 정지 상태 여부 
+        }
+
+    def parse(self, packet):
+        """
+        pyaidrone의 parse.py에서 수신된 패킷을 분석하여 상태를 업데이트합니다.
+
+        Output Packet 구조 (parse.py가 헤더 4바이트를 저장하지 않으므로 offset 주의):
+          packet[4]  = LEN
+          packet[5]  = CS
+          packet[6]  = 0x01 (고정값)
+          packet[7]  = OPT1
+          packet[8]  = OPT2
+          packet[9]  = BAT (배터리 %)
+          packet[10] = INFO[0] (TYPE 바이트)
+          packet[11+]= INFO 데이터
+        """
+        if packet is None:
+            return None
+
+        # parse.py에서 체크섬 검증 후 전달된 패킷이므로 헤더 재확인 불필요.
+        # OPT1: packet[7], BAT: packet[9], INFO: packet[10+]
+        opt1 = packet[7]
+        self.state['battery'] = packet[9]
+        self.state['emergency'] = bool(opt1 & 0x01)
+        self.state['ready'] = bool(opt1 & 0x02)
+
+        # INFO 데이터 구간 (packet[10]부터 시작, info[0]이 TYPE 바이트)
+        info = packet[10:]
+
+        # 2. 센서 신호 파싱 (OPT1 BIT2 활성화 시 - POS_SIGNAL 0x06)
+        if opt1 & 0x04:
+            data_type = info[0]
+            if data_type == 0x06:
+                # D1~D4 슬롯에서 Flow 및 ToF 데이터 추출 (Little Endian short)
+                self.state['flow_x'] = struct.unpack('<h', info[1:3])[0]
+                self.state['flow_y'] = struct.unpack('<h', info[3:5])[0]
+                self.state['tof'] = struct.unpack('<h', info[5:7])[0]
+
+        # 3. 비행 정보 파싱 (OPT1 BIT5 활성화 시 - 비행 정보 응답, TYPE=9)
+        if opt1 & 0x20:
+            # 기울기, 높이, 절대 위치(pos_x, pos_y) 추출
+            # info[0]=TYPE(9), info[1:3]=A1(roll), info[3:5]=A2(pitch),
+            # info[5:7]=H(height), info[7:9]=POS1(x), info[9:11]=POS2(y)
+            self.state['roll'] = struct.unpack('<h', info[1:3])[0]
+            self.state['pitch'] = struct.unpack('<h', info[3:5])[0]
+            self.state['height'] = struct.unpack('<h', info[5:7])[0]
+            self.state['pos_x'] = struct.unpack('<h', info[7:9])[0]
+            self.state['pos_y'] = struct.unpack('<h', info[9:11])[0]
+
+        return self.state

{pyaidrone-2.3 → pyaidrone-2.5}/pyaidrone/vision_ai.py

@@ -78,7 +78,13 @@ def yolo_decode(outputs, img_shape, input_shape, r, pad, threshold=0.4):
 
 class TFLiteDetector:
     def __init__(self, model_path: str):
+        # 초기화 실패 시 infer()에서 명확한 오류를 내기 위해 미리 None 설정
+        self.interpreter = None
+        self.input_details = None
+        self.output_details = None
+
         # 윈도우 환경(TensorFlow)과 라즈베리파이(tflite-runtime) 자동 선택
+        tflite = None
         try:
             import tensorflow.lite as tflite
         except ImportError:
@@ -87,14 +93,16 @@ class TFLiteDetector:
             except ImportError:
                 print("❌ TFLite를 실행할 라이브러리가 없습니다.")
                 return
-            
+
         self.interpreter = tflite.Interpreter(model_path=model_path)
         self.interpreter.allocate_tensors()
         self.input_details = self.interpreter.get_input_details()
         self.output_details = self.interpreter.get_output_details()
-        
+
     def infer(self, frame, decode_func, threshold=0.4):
         """edu.py에서 사용하는 명칭인 'infer'로 유지"""
+        if self.interpreter is None:
+            raise RuntimeError("TFLiteDetector: TFLite 라이브러리가 없어 초기화되지 않았습니다.")
         ih, iw = self.input_details[0]['shape'][1:3]
         img, r, pad = letterbox(frame, (ih, iw))
         

{pyaidrone-2.3 → pyaidrone-2.5}/pyaidrone.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.1
 Name: pyaidrone
-Version: 2.3
+Version: 2.5
 Summary: Library for AIDrone Products
 Home-page: http://www.ir-brain.com
 Author: IR-Brain
@@ -10,17 +10,6 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.6
 Description-Content-Type: text/markdown
-Requires-Dist: pyserial>=3.4
-Requires-Dist: pynput>=1.7.3
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
 
 ## install pyaidrone
 

{pyaidrone-2.3 → pyaidrone-2.5}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="pyaidrone",
-    version="2.3",
+    version="2.5",
     description="Library for AIDrone Products",
     long_description=open("README.md").read(),  # README.md 내용을 long_description으로 사용
     long_description_content_type="text/markdown",  # README 파일이 markdown 형식임을 지정

pyaidrone-2.3/pyaidrone/aiDrone.py

@@ -1,352 +0,0 @@
-import serial
-import binascii
-import math
-from time import sleep
-import random
-import platform
-import subprocess
-from operator import eq
-from threading import Thread
-from serial.tools.list_ports import comports
-from pyaidrone.parse import *
-from pyaidrone.packet import *
-from pyaidrone.deflib import *
-
-
-class AIDrone(Parse, Packet):
-    def __init__(self, receiveCallback=None, index=0):
-        self.serial = None
-        self.isThreadRun = False
-        self.parse = Parse(AIDRONE)
-        self.makepkt = Packet(AIDRONE)
-        self.receiveCallback = receiveCallback
-        self.makepkt.clearPacket()
-        self.posX = 0
-        self.posY = 0
-        self.rot = 0
-        self.portIndex = index          # 멀티 연결 시 드론 번호 식별용
-        # --- 영상 스트리밍 관련 기본값 ---
-        self.stream_host = "192.168.4.1"
-        self.stream_port = 80
-        self.stream_path = "/?action=stream"
-        self._cap = None
-
-    def receiveHandler(self):
-        while self.isThreadRun:
-            readData = self.serial.read(self.serial.in_waiting or 1)
-            packet = self.parse.packetArrange(readData)
-            if packet is not None:
-                if self.receiveCallback is not None:
-                    self.receiveCallback(packet)
-            self.serial.write(self.makepkt.getPacket())
-
-    def Open(self, portName="None"):
-        if eq(portName, "None"):
-            nodes = comports()
-            for node in nodes:
-                if "CH340" in node.description:
-                    portName = node.device
-
-            if eq(portName, "None"):
-                print("Can't find Serial Port")
-                exit()
-                return False
-        try:
-            self.serial = serial.Serial(port=portName, baudrate=19200, timeout=1)
-            if self.serial.isOpen():
-                self.isThreadRun = True
-                self.thread = Thread(target=self.receiveHandler, args=(), daemon=True)
-                self.thread.start()
-                print(f"[Drone #{self.portIndex}] Connected to {portName}")
-                return True
-            else:
-                print("Can't open " + portName)
-                exit()
-                return False
-        except Exception:
-            print("Can't open " + portName)
-            exit()
-            return False
-
-    def Close(self):
-        self.isThreadRun = False
-        sleep(0.2)
-        pkt = self.makepkt.getPacket()
-        if (pkt[15] & 0x80) == 0x80:
-            self.makepkt.clearPacket()
-            self.setOption(0x8000)
-            self.serial.write(self.makepkt.getPacket())
-            sleep(0.2)
-        self.serial.write(self.makepkt.clearPacket())
-        sleep(0.2)
-        if self.serial is not None:
-            if self.serial.isOpen():
-                self.serial.close()
-
-    def setOption(self, option):
-        data = option.to_bytes(2, byteorder="little", signed=False)
-        self.makepkt.makePacket(14, data)
-
-    def takeoff(self):
-        alt = 70
-        data = alt.to_bytes(2, byteorder="little", signed=False)
-        self.makepkt.makePacket(12, data)
-        self.setOption(0x2F)
-
-    def landing(self):
-        alt = 0
-        data = alt.to_bytes(2, byteorder="little", signed=False)
-        self.makepkt.makePacket(12, data)
-
-    def altitude(self, alt):
-        data = alt.to_bytes(2, byteorder="little", signed=False)
-        self.makepkt.makePacket(12, data)
-
-    def velocity(self, dir=0, vel=100):
-        if dir > 3:
-            return
-        if dir == 1 or dir == 3:
-            vel *= -1
-        data = vel.to_bytes(2, byteorder="little", signed=True)
-        if dir == 0 or dir == 1:
-            self.makepkt.makePacket(8, data)
-        else:
-            self.makepkt.makePacket(6, data)
-        self.setOption(0x0F)
-
-    def move(self, dir=0, dist=100):
-        if dir > 3:
-            return
-        if dir == 1 or dir == 3:
-            dist *= -1
-        if dir == 0 or dir == 1:
-            self.posX += dist
-            data = self.posX.to_bytes(2, byteorder="little", signed=True)
-            self.makepkt.makePacket(8, data)
-        else:
-            self.posY += dist
-            data = self.posY.to_bytes(2, byteorder="little", signed=True)
-            self.makepkt.makePacket(6, data)
-        self.setOption(0x2F)
-
-    def rotation(self, rot=90):
-        self.rot += rot
-        data = self.rot.to_bytes(2, byteorder="little", signed=True)
-        self.makepkt.makePacket(10, data)
-
-    def motor(self, what, speed):
-        speed = DefLib.constrain(speed, 100, 0)
-        data = speed.to_bytes(2, byteorder="little", signed=True)
-        self.makepkt.makePacket(what * 2 + 6, data)
-        self.setOption(0x8000)
-
-    def emergency(self):
-        self.setOption(0x00)
-        self.serial.write(self.makepkt.getPacket())
-
-    # ── 스트리밍 관련 ──────────────────────────────────────────────────────────
-    def setStreamAddress(self, host: str, port: int = 80, path: str = "/?action=stream"):
-        """MJPG-Streamer 주소 구성 요소를 저장합니다."""
-        if not isinstance(host, str) or len(host.strip()) == 0:
-            raise ValueError("host가 올바르지 않습니다.")
-        self.stream_host = host.strip()
-        self.stream_port = int(port)
-        if not path.startswith("/"):
-            path = "/" + path
-        self.stream_path = path
-        return self._build_stream_url()
-
-    def _build_stream_url(self):
-        """내부 사용: 저장된 host/port/path로 URL 생성."""
-        if self.stream_port in (80, None):
-            return f"http://{self.stream_host}{self.stream_path}"
-        return f"http://{self.stream_host}:{self.stream_port}{self.stream_path}"
-
-    def streamon(self, host: str = None, port: int = None, path: str = None, return_url: bool = False):
-        """
-        MJPG-Streamer 스트림을 엽니다.
-        - 인자를 주면 해당 값으로 주소를 덮어쓰고, 안 주면 저장된 값 사용.
-        - return_url=True 이면 URL 문자열만 반환(캡처는 열지 않음).
-        """
-        if host is not None or port is not None or path is not None:
-            self.setStreamAddress(
-                host or self.stream_host,
-                self.stream_port if port is None else port,
-                self.stream_path if path is None else path,
-            )
-        url = self._build_stream_url()
-        if return_url:
-            return url
-        try:
-            import cv2 as cv
-        except Exception as e:
-            raise RuntimeError(f"OpenCV(cv2) 임포트 실패: {e}")
-        self.streamoff()
-        self._cap = cv.VideoCapture(url)
-        if not self._cap.isOpened():
-            self._cap.release()
-            self._cap = None
-            raise RuntimeError(f"스트림 열기 실패: {url}")
-        return self._cap
-
-    def streamoff(self):
-        """열려 있는 스트림을 닫습니다."""
-        if self._cap is not None:
-            try:
-                self._cap.release()
-            except Exception:
-                pass
-            self._cap = None
-
-    # ── 센서 데이터 요청 ────────────────────────────────────────────────────────
-    def requestSensorData(self, type_num, mode=1):
-        """
-        드론에게 센서 및 비행 정보 출력을 요청합니다.
-        type_num: 9 (비행 정보), 10 (센서 신호)
-        mode: 1 (출력 시작), 0 (출력 중지)
-        """
-        if type_num == 9:
-            data = mode.to_bytes(1, byteorder="little")
-            self.makepkt.packet[3] = 0xB2
-            self.makepkt.makePacket(7, data)
-        elif type_num == 10:
-            data = mode.to_bytes(1, byteorder="little")
-            self.makepkt.packet[3] = 0xB1
-            self.makepkt.makePacket(7, data)
-
-
-# ══════════════════════════════════════════════════════════════════════════════
-# 멀티 드론 헬퍼 함수
-# ══════════════════════════════════════════════════════════════════════════════
-
-def getWindowsPortList():
-    """Windows에서 CH340 포트 목록 반환."""
-    nodes = comports()
-    portList = [node.device for node in nodes if "CH340" in node.description]
-    if not portList:
-        print("Can't find Serial Port (CH340)")
-        return None
-    print(f"발견된 포트: {portList}")
-    return portList
-
-
-def getLinuxPortList():
-    """Linux에서 /dev/ttyUSB* 포트 목록 반환."""
-    try:
-        output = subprocess.check_output("ls /dev/ttyUSB*", shell=True)
-        return tuple(output.decode().strip().split())
-    except subprocess.CalledProcessError:
-        print("Can't find Serial Port (/dev/ttyUSB*)")
-        return None
-
-
-def AIDroneMultiOpen(nameList=None, receiveCallback=None):
-    """
-    여러 대의 AIDrone을 동시에 연결합니다.
-
-    Parameters
-    ----------
-    nameList : list[str] | None
-        포트 이름 목록. None이면 OS에 맞게 자동 탐색.
-    receiveCallback : callable | None
-        수신 콜백. 호출 시 첫 번째 인자로 AIDrone 인스턴스가 전달됩니다.
-
-    Returns
-    -------
-    list[AIDrone] | None
-        연결된 드론 객체 목록.
-
-    Example
-    -------
-    >>> drones = AIDroneMultiOpen()
-    >>> multi_takeoff(drones)
-    >>> sleep(3)
-    >>> multi_landing(drones)
-    >>> AIDroneMultiClose(drones)
-    """
-    if nameList is None:
-        if platform.system() == "Linux":
-            nameList = getLinuxPortList()
-        else:
-            nameList = getWindowsPortList()
-
-    if not nameList:
-        return None
-
-    howMany = min(len(nameList), 10)  # 최대 10대 제한
-    drones = []
-
-    for n in range(howMany):
-        drone = AIDrone(receiveCallback, n)
-        if drone.Open(nameList[n]):
-            drones.append(drone)
-        else:
-            print(f"[Drone #{n}] 연결 실패 → 전체 연결 중단")
-            AIDroneMultiClose(drones)
-            return None
-
-    print(f"총 {len(drones)}대 드론 연결 완료.")
-    return drones
-
-
-def AIDroneMultiClose(drones):
-    """연결된 모든 드론을 안전하게 닫습니다."""
-    if not drones:
-        return
-    # 착륙 명령 먼저 전송
-    for drone in drones:
-        drone.landing()
-    sleep(0.5)
-    for drone in drones:
-        drone.Close()
-    print("모든 드론 연결 종료.")
-
-
-# ── 멀티 제어 함수 ─────────────────────────────────────────────────────────────
-
-def multi_takeoff(drones):
-    """모든 드론 이륙."""
-    for drone in drones:
-        drone.takeoff()
-
-
-def multi_landing(drones):
-    """모든 드론 착륙."""
-    for drone in drones:
-        drone.landing()
-
-
-def multi_altitude(drones, alt):
-    """모든 드론 고도 설정."""
-    for drone in drones:
-        drone.altitude(alt)
-
-
-def multi_move(drones, dir=0, dist=100):
-    """모든 드론 이동."""
-    for drone in drones:
-        drone.move(dir, dist)
-
-
-def multi_velocity(drones, dir=0, vel=100):
-    """모든 드론 속도 제어."""
-    for drone in drones:
-        drone.velocity(dir, vel)
-
-
-def multi_rotation(drones, rot=90):
-    """모든 드론 회전."""
-    for drone in drones:
-        drone.rotation(rot)
-
-
-def multi_motor(drones, what, speed):
-    """모든 드론 모터 제어."""
-    for drone in drones:
-        drone.motor(what, speed)
-
-
-def multi_emergency(drones):
-    """모든 드론 긴급 정지."""
-    for drone in drones:
-        drone.emergency()

pyaidrone-2.3/pyaidrone/deflib.py

@@ -1,44 +0,0 @@
-AIDRONE = 1
-
-
-FRONT = 0
-BACK = 1
-RIGHT = 2
-LEFT = 3
-
-class DefLib:
-
-    @classmethod
-    def checksum(cls, packet):
-        len = packet[4]
-        sum = 0
-        for n in range(6, len):
-            sum += packet[n]
-        return sum & 0xFF
-
-
-    @classmethod
-    def _print(cls, data):
-        for n in range(0, len(data)):
-            h = hex(data[n])
-#            print(h, end=" ")
-        print("")
-
-
-    @classmethod
-    def constrain(cls, val , max, min):
-        if val > max:
-            val = max
-        if val < min:
-            val = min
-        return val
-
-
-    @classmethod
-    def comp(cls, data):
-        data = data&0xFF
-        if data < 0:
-            return 256 + data
-        else:
-            return data
-

pyaidrone-2.3/pyaidrone/sensor.py

@@ -1,58 +0,0 @@
-#AIDrone sensor 라이브러리 (26.01.15)
-import struct
-from pyaidrone.deflib import DefLib
-
-class AIDroneSensor:
-    def __init__(self):
-        # 센서 데이터 및 비행 상태 통합 저장소
-        self.state = {
-            'battery': 0,      # 배터리 잔량 (%) 
-            'tof': 0,          # VL53L01X 고도 센서 값 (mm) 
-            'flow_x': 0,       # PMW3901 광학 흐름 센서 X축 변화량 
-            'flow_y': 0,       # PMW3901 광학 흐름 센서 Y축 변화량 
-            'pos_x': 0,        # 이륙 지점 기준 X 좌표 (cm) 
-            'pos_y': 0,        # 이륙 지점 기준 Y 좌표 (cm) 
-            'height': 0,       # 드론이 계산한 현재 높이 (cm) 
-            'roll': 0,         # 현재 좌우 기울기 
-            'pitch': 0,        # 현재 앞뒤 기울기 
-            'ready': False,    # 비행 준비 상태 
-            'emergency': False # 응급 정지 상태 여부 
-        }
-
-    def parse(self, packet):
-        """
-        pyaidrone의 parse.py에서 수신된 패킷을 분석하여 상태를 업데이트합니다.
-        """
-        if packet is None or packet == "None":
-            return None
-
-        # 패킷 헤더 및 타입 확인 (0xA2: Output Packet) 
-        if (packet[3] & 0xF0) == 0xA0:
-            # 1. 기본 상태 정보 추출 (배터리 및 옵션 비트) 
-            opt1 = packet[6]
-            self.state['battery'] = packet[8]
-            self.state['emergency'] = bool(opt1 & 0x01)
-            self.state['ready'] = bool(opt1 & 0x02)
-            
-            # INFO 데이터 구간 (packet[9]부터 시작) 
-            info = packet[9:]
-            
-            # 2. 센서 신호 파싱 (OPT1 BIT2 활성화 시 - POS_SIGNAL 0x06) 
-            if opt1 & 0x04:
-                data_type = info[0]
-                if data_type == 0x06:
-                    # D1~D4 슬롯에서 Flow 및 ToF 데이터 추출 (Little Endian short) 
-                    self.state['flow_x'] = struct.unpack('<h', info[1:3])[0]
-                    self.state['flow_y'] = struct.unpack('<h', info[3:5])[0]
-                    self.state['tof'] = struct.unpack('<h', info[5:7])[0]
-
-            # 3. 비행 정보 파싱 (OPT1 BIT5 활성화 시 - 비행 정보 응답) 
-            if opt1 & 0x20:
-                # 기울기, 높이, 그리고 요청하신 절대 위치(pos_x, pos_y) 추출 
-                self.state['roll'] = struct.unpack('<h', info[1:3])[0]
-                self.state['pitch'] = struct.unpack('<h', info[3:5])[0]
-                self.state['height'] = struct.unpack('<h', info[5:7])[0]
-                self.state['pos_x'] = struct.unpack('<h', info[7:9])[0]
-                self.state['pos_y'] = struct.unpack('<h', info[9:11])[0]
-
-        return self.state