codrone-edu 2.9__tar.gz → 2.10__tar.gz

{codrone_edu-2.9 → codrone_edu-2.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codrone_edu
-Version: 2.9
+Version: 2.10
 Summary: Python CoDrone EDU library
 Home-page: 
 Author: 

{codrone_edu-2.9 → codrone_edu-2.10}/codrone_edu/drone.py

@@ -137,7 +137,7 @@ class Drone:
     # BaseFunctions Start
 
     def __init__(self, flagCheckBackground=True, flagShowErrorMessage=False, flagShowLogMessage=False,
-                 flagShowTransferData=False, flagShowReceiveData=False, swarm=False, color_data_dir=None):
+                 flagShowTransferData=False, flagShowReceiveData=False, swarm=False, color_data_dir=None, flagShowDepLibraryVersion=True):
 
         self._serialport = None
         if sys.platform == 'emscripten':
@@ -270,10 +270,12 @@ class Drone:
         library_name = "codrone-edu"
         library = importlib.metadata.distribution(library_name)
         if sys.platform != 'emscripten' and not self._swarm:
-            colorama.init()
-            print(Fore.GREEN + f"Running {library_name} library version {library.version}" + Style.RESET_ALL)
+            if flagShowDepLibraryVersion:
+                colorama.init()
+                print(Fore.GREEN + f"Running {library_name} library version {library.version}" + Style.RESET_ALL)
         elif sys.platform == 'emscripten':
-            print("Running {0} library version {1}".format(library_name, library.version), color="green")
+            if flagShowDepLibraryVersion:
+                print("Running {0} library version {1}".format(library_name, library.version), color="green")
         # this only works when using the release version of the library
 
     def __del__(self):
@@ -1308,6 +1310,70 @@ class Drone:
         await asyncio.sleep(0.01)
         await self._trigger_speed_callback()
 
+    def control_change(self, mode=ModeControlFlight.Position):
+        """
+        Changes the flight control mode of the drone.
+        default is set to ModeControlFlight.Position
+        :param mode: ModeControlFlight enum value (e.g. Attitude, Position)
+        :return: N/A
+        """
+        if not isinstance(mode, ModeControlFlight):
+            return None
+
+        if sys.platform != 'emscripten' and not self._swarm:
+            return self._control_change_desktop(mode)
+        if sys.platform != 'emscripten' and self._swarm:
+            return asyncio.create_task(self._control_change_swarm(mode))
+        else:
+            return asyncio.create_task(self._control_change_emscripten(mode))
+
+    def _control_change_desktop(self, mode=ModeControlFlight.Position):
+        for _ in range(2):
+            self.sendCommand(CommandType.ModeControlFlight, mode.value)
+            time.sleep(0.03)
+
+    async def _control_change_swarm(self, mode=ModeControlFlight.Position):
+        for _ in range(2):
+            await self.sendCommand(CommandType.ModeControlFlight, mode.value)
+            await asyncio.sleep(0.03)
+
+    async def _control_change_emscripten(self, mode=ModeControlFlight.Position):
+        for _ in range(2):
+            await self.sendCommand(CommandType.ModeControlFlight, mode.value)
+            await asyncio.sleep(0.03)
+
+    def headless_change(self, mode=Headless.Normal):
+        """
+        Changes the headless mode of the drone.
+        default is set to Headless.Normal
+        :param mode: Headless enum value (Headless, Normal)
+        :return: N/A
+        """
+        if not isinstance(mode, Headless):
+            return None
+
+        if sys.platform != 'emscripten' and not self._swarm:
+            return self._headless_change_desktop(mode)
+        if sys.platform != 'emscripten' and self._swarm:
+            return asyncio.create_task(self._headless_change_swarm(mode))
+        else:
+            return asyncio.create_task(self._headless_change_emscripten(mode))
+
+    def _headless_change_desktop(self, mode=Headless.Normal):
+        for _ in range(3):
+            self.sendCommand(CommandType.Headless, mode.value)
+            time.sleep(0.03)
+
+    async def _headless_change_swarm(self, mode=Headless.Normal):
+        for _ in range(3):
+            await self.sendCommand(CommandType.Headless, mode.value)
+            await asyncio.sleep(0.03)
+
+    async def _headless_change_emscripten(self, mode=Headless.Normal):
+        for _ in range(3):
+            await self.sendCommand(CommandType.Headless, mode.value)
+            await asyncio.sleep(0.03)
+
     def update_motion_data(self, drone_type):
 
         """
@@ -2221,7 +2287,11 @@ class Drone:
             # set the speed to medium level
             self.speed_change(speed_level=2)
             time.sleep(0.2)
-            
+            self.control_change(mode=ModeControlFlight.Position)
+            time.sleep(0.2)
+            self.headless_change(mode=Headless.Normal)
+            time.sleep(0.2)
+
             # disable the previous YPRT commands
             self.sendControl(0, 0, 0, 0)
             time.sleep(0.2)
@@ -2303,6 +2373,10 @@ class Drone:
             # set the speed to medium level
             await self.speed_change(speed_level=2)
             await asyncio.sleep(0.2)
+            await self.control_change(mode=ModeControlFlight.Position)
+            await asyncio.sleep(0.2)
+            await self.headless_change(mode=Headless.Normal)
+            await asyncio.sleep(0.2)
 
             # disable the previous YPRT commands
             await self.sendControl(0, 0, 0, 0)
@@ -2350,6 +2424,12 @@ class Drone:
         await self.speed_change(speed_level=2)
         await asyncio.sleep(0.2)
 
+        # put all users in the same control/headless modes
+        await self.control_change(mode=ModeControlFlight.Position)
+        await asyncio.sleep(0.2)
+        await self.headless_change(mode=Headless.Normal)
+        await asyncio.sleep(0.2)
+
         # disable the previous YPRT commands
         await self.sendControl(0, 0, 0, 0)
         await asyncio.sleep(0.2)
@@ -2543,7 +2623,7 @@ class Drone:
 
                 if monitor0.monitorDataType == MonitorDataType.F32:
 
-                    dataCount = (dataArray.len() - 1 - Monitor0.getSize()) / 4
+                    dataCount = (len(dataArray) - 1 - Monitor0.getSize()) // 4
 
                     for i in range(0, dataCount):
 
@@ -2559,7 +2639,7 @@ class Drone:
 
                     self.systemTimeMonitorData = monitor4.systemTime
 
-                    dataCount = (dataArray.len() - 1 - Monitor4.getSize()) / 4
+                    dataCount = (len(dataArray) - 1 - Monitor4.getSize()) // 4
 
                     for i in range(0, dataCount):
 
@@ -2575,7 +2655,7 @@ class Drone:
 
                     self.systemTimeMonitorData = monitor8.systemTime
 
-                    dataCount = (dataArray.len() - 1 - Monitor8.getSize()) / 4
+                    dataCount = (len(dataArray) - 1 - Monitor8.getSize()) // 4
 
                     for i in range(0, dataCount):
 
@@ -3408,7 +3488,7 @@ class Drone:
         """
         :param distance: the numerical value of the value to move
         :param units: can either be in inches, centimeters, meters, feet.
-        :param speed: default 1 meter per second. Max is 2 meters/second.
+        :param speed: default 0.5 meter per second. Max is 2 meters/second.
         :return: N/A
         """
         if sys.platform != 'emscripten' and not self._swarm:
@@ -3497,7 +3577,7 @@ class Drone:
         """
         :param distance: the numerical value of the value to move
         :param units: can either be in inches, centimeters, meters, feet.
-        :param speed: default 1 meter per second. Max is 2 meters/second.
+        :param speed: default 0.5 meter per second. Max is 2 meters/second.
         :return: N/A
         """
         if sys.platform != 'emscripten' and not self._swarm:
@@ -3586,7 +3666,7 @@ class Drone:
         """
         :param distance: the numerical value of the value to move
         :param units: can either be in inches, centimeters, meters, feet.
-        :param speed: default 1 meter per second. Max is 2 meters/second.
+        :param speed: default 0.5 meter per second. Max is 2 meters/second.
         :return: N/A
         """
         if sys.platform != 'emscripten' and not self._swarm:
@@ -3674,7 +3754,7 @@ class Drone:
         """
         :param distance: the numerical value of the value to move
         :param units: can either be in inches, centimeters, meters, feet.
-        :param speed: default 1 meter per second. Max is 2 meters/second.
+        :param speed: default 0.5 meter per second. Max is 2 meters/second.
         :return: N/A
         """
         if sys.platform != 'emscripten' and not self._swarm:
@@ -3758,6 +3838,183 @@ class Drone:
 
         await asyncio.sleep(delay + 1.0)
 
+
+    def move_upward(self, distance, units="cm", speed=0.5):
+        """
+        :param distance: the numerical value of the value to move
+        :param units: can either be in inches, centimeters, meters, feet.
+        :param speed: default 0.5 meter per second. Max is 2 meters/second.
+        :return: N/A
+        """
+        if sys.platform != 'emscripten' and not self._swarm:
+            return self._move_upward_desktop(distance, units, speed)
+        else:
+            return asyncio.create_task(self._move_upward_emscripten(distance, units, speed))
+        
+    def _move_upward_desktop(self, distance, units="cm", speed=0.5):
+        if units == "cm":
+            distance_meters = distance / 100
+        elif units == "ft":
+            distance_meters = distance / 3.28084
+        elif units == "in":
+            distance_meters = distance / 39.37
+        elif units == "m":
+            distance_meters = distance * 1
+        else:
+            print(Fore.RED + "Error: Not a valid unit." + Style.RESET_ALL)
+            return
+
+        # cap the speed
+        if speed > 2:
+            speed = 2
+        elif speed < 0:
+            speed = 0
+
+        self.sendControlPosition(positionX=0,
+                                    positionY=0,
+                                    positionZ=distance_meters,
+                                    velocity=speed,
+                                    heading=0,
+                                    rotationalVelocity=0)
+
+        delay = distance_meters / speed
+
+        time.sleep(0.1)
+
+        while self.get_movement_state() != ModeMovement.Moving:
+            self.sendControlPosition(positionX=0, positionY=0, positionZ=distance_meters, velocity=speed,
+                                        heading=0,
+                                        rotationalVelocity=0)
+            time.sleep(0.1)
+
+        time.sleep(delay + 1.0)
+
+    async def _move_upward_emscripten(self, distance, units="cm", speed=0.5):
+        if units == "cm":
+            distance_meters = distance / 100
+        elif units == "ft":
+            distance_meters = distance / 3.28084
+        elif units == "in":
+            distance_meters = distance / 39.37
+        elif units == "m":
+            distance_meters = distance * 1
+        else:
+            print("Error: Not a valid unit.", color="error")
+            return
+        
+        # cap the speed
+        if speed > 2:
+            speed = 2
+        elif speed < 0:
+            speed = 0
+
+        await self.sendControlPosition(positionX=0,
+                                    positionY=0,
+                                    positionZ=distance_meters,
+                                    velocity=speed,
+                                    heading=0,
+                                    rotationalVelocity=0)
+
+        delay = distance_meters / speed
+
+        await asyncio.sleep(0.1)
+
+        while (await self.get_movement_state()) != ModeMovement.Moving:
+            await self.sendControlPosition(positionX=0, positionY=0, positionZ=distance_meters, velocity=speed,
+                                        heading=0,
+                                        rotationalVelocity=0)
+            await asyncio.sleep(0.10)
+
+        await asyncio.sleep(delay + 1.0)
+
+    def move_downward(self, distance, units="cm", speed=0.5):
+        """
+        :param distance: the numerical value of the value to move
+        :param units: can either be in inches, centimeters, meters, feet.
+        :param speed: default 0.5 meter per second. Max is 2 meters/second.
+        :return: N/A
+        """
+        if sys.platform != 'emscripten' and not self._swarm:
+            return self._move_downward_desktop(distance, units, speed)
+        else:
+            return asyncio.create_task(self._move_downward_emscripten(distance, units, speed))
+
+    def _move_downward_desktop(self, distance, units="cm", speed=0.5):
+        if units == "cm":
+            distance_meters = distance / 100
+        elif units == "ft":
+            distance_meters = distance / 3.28084
+        elif units == "in":
+            distance_meters = distance / 39.37
+        elif units == "m":
+            distance_meters = distance * 1
+        else:
+            print(Fore.RED + "Error: Not a valid unit." + Style.RESET_ALL)
+            return
+
+        # cap the speed
+        if speed > 2:
+            speed = 2
+        elif speed < 0:
+            speed = 0
+
+        self.sendControlPosition(positionX=0,
+                                    positionY=0,
+                                    positionZ=-distance_meters,
+                                    velocity=speed,
+                                    heading=0,
+                                    rotationalVelocity=0)
+
+        delay = distance_meters / speed
+
+        time.sleep(0.1)
+
+        while self.get_movement_state() != ModeMovement.Moving:
+            self.sendControlPosition(positionX=0, positionY=0, positionZ=-distance_meters, velocity=speed,
+                                        heading=0,
+                                        rotationalVelocity=0)
+            time.sleep(0.1)
+
+        time.sleep(delay + 1.0)
+
+    async def _move_downward_emscripten(self, distance, units="cm", speed=0.5):
+        if units == "cm":
+            distance_meters = distance / 100
+        elif units == "ft":
+            distance_meters = distance / 3.28084
+        elif units == "in":
+            distance_meters = distance / 39.37
+        elif units == "m":
+            distance_meters = distance * 1
+        else:
+            print("Error: Not a valid unit.", color="error")
+            return
+        
+        # cap the speed
+        if speed > 2:
+            speed = 2
+        elif speed < 0:
+            speed = 0
+
+        await self.sendControlPosition(positionX=0,
+                                    positionY=0,
+                                    positionZ=-distance_meters,
+                                    velocity=speed,
+                                    heading=0,
+                                    rotationalVelocity=0)
+
+        delay = distance_meters / speed
+
+        await asyncio.sleep(0.1)
+
+        while (await self.get_movement_state()) != ModeMovement.Moving:
+            await self.sendControlPosition(positionX=0, positionY=0, positionZ=-distance_meters, velocity=speed,
+                                        heading=0,
+                                        rotationalVelocity=0)
+            await asyncio.sleep(0.10)
+
+        await asyncio.sleep(delay + 1.0)
+
     def send_absolute_position(self, positionX, positionY, positionZ, velocity, heading, rotationalVelocity):
         """
         drone movement command
@@ -4528,7 +4785,7 @@ class Drone:
         """
         A looped method that makes the drone fly forward until it reaches
         a desired distance. The drone will keep that distance.
-        The range of front sensor is from 0cm-100cm
+        The range of front sensor is from 0cm-150cm
 
         :param timeout: duration in seconds that function will run
         :param distance: distance in cm the drone will maintain in front of object
@@ -4580,7 +4837,7 @@ class Drone:
     def detect_wall(self, distance=50):
         """
         Returns True when a distance below the threshold is reached.
-        The range of front sensor is from 0cm-100cm
+        The range of front sensor is from 0cm-150cm
 
         :param distance: threshold in millimeters that returns True
         :return: Boolean

{codrone_edu-2.9 → codrone_edu-2.10}/codrone_edu/protocol.py

@@ -53,6 +53,7 @@ class DataType(Enum):
     Command                     = 0x11      # 명령
     Pairing                     = 0x12      # 페어링
     Rssi                        = 0x13      # RSSI
+    #ResponseRate                = 0x13      # CDEP - response rate (success rate) metric
     TimeSync                    = 0x14      # 시간 동기화
     TransmissionPower           = 0x15      # 전송 출력
     Configuration               = 0x16      # 설정
@@ -66,6 +67,12 @@ class DataType(Enum):
     LightEvent                  = 0x22      # LED 이벤트
     LightDefault                = 0x23      # LED 초기 모드
 
+    # CDEP - packet-based LED commands (sent as top-level DataType, bypass Command/LightMode/LightEvent)
+    LED_rainbow                 = 0x24      # CDEP LED rainbow effect
+    LED_flicker                 = 0x25      # CDEP LED flicker effect
+    LED_random                  = 0x26      # CDEP LED random color effect
+    LED_individual              = 0x27      # CDEP per-LED individual color control (5 LEDs)
+
     # 센서 RAW 데이터
     RawMotion                   = 0x30      # Motion 센서 데이터 RAW 값
     RawFlow                     = 0x31      # Flow 센서 데이터 RAW 값
@@ -91,6 +98,7 @@ class DataType(Enum):
     MotorSingle                 = 0x61      # 한 개의 모터 제어
     Buzzer                      = 0x62      # 부저 제어
     Vibrator                    = 0x63      # 진동 제어
+    Battery                     = 0x64      # CDEP - dedicated battery information
 
     # Input
     Button                      = 0x70      # 버튼 입력
@@ -165,6 +173,8 @@ class CommandType(Enum):
     Backlight               = 0x09      # 조종기 백라이트 설정
     ModeController          = 0x0A      # 조종기 동작 모드(0x10:조종, 0x80:링크)
     Link                    = 0x0B      # 링크 제어(0:Client Mode, 1:Server Mode, 2:Pairing Start)
+    LoadDefaultColor        = 0x0C      # CDEP - apply default LED color
+    Trim                    = 0x0D      # CDEP - absolute trim set (roll/pitch/yaw/throttle)
 
     # 관리자
     ClearCounter            = 0xA0      # 카운터 클리어(관리자 권한을 획득했을 경우에만 동작)
@@ -177,11 +187,17 @@ class CommandType(Enum):
     NavigationStop          = 0xE4      # 네비게이션 중단
     NavigationNext          = 0xE5      # 네비게이션 목표점을 다음으로 변경
     NavigationReturnToHome  = 0xE6      # 시작 위치로 귀환
-    
+
     GpsRtkBase              = 0xEA
     GpsRtkRover             = 0xEB
 
-    EndOfType               = 0xEC
+    # CDEP
+    ModeTest                = 0xF0      # test lock (unavailable until test completed / 27:enable, 11:disable)
+    ResetTimeCount          = 0xFC      # reset test time
+    RfChannel               = 0xFD      # RF channel (2400, 2440, 2483)
+    RfModulate              = 0xFE      # RF modulate (Modulate, Rx, Unmodulate)
+
+    EndOfType               = 0xFF
 
 
 # CommandType End
@@ -704,6 +720,81 @@ class Rssi(ISerializable):
 
 
 
+class PairingCDEP(ISerializable):
+    # CDEP - Protocol::Pairing. Same DataType slot as Pairing (0x12), but a completely different
+    # 14-byte layout (BLE-style device-type + 5-byte address + 8-channel list) rather than the
+    # 11-byte address0/1/2+scramble+channel0-3 shape classic CoDrone EDU sends on this slot.
+    # Kept as its own class — the existing Pairing/sendPairing() path must stay intact for
+    # non-Plus hardware.
+
+    def __init__(self):
+        self.connectorDeviceType    = DeviceType.None_
+        self.address                = bytearray(5)
+        self.channelArray           = bytearray(8)
+
+
+    @classmethod
+    def getSize(cls):
+        return 14
+
+
+    def toArray(self):
+        dataArray = bytearray()
+        dataArray.extend(pack('<B', self.connectorDeviceType.value))
+        dataArray.extend(self.address[0:5])
+        dataArray.extend(self.channelArray[0:8])
+        return dataArray
+
+
+    @classmethod
+    def parse(cls, dataArray):
+        data = PairingCDEP()
+
+        if len(dataArray) != cls.getSize():
+            return None
+
+        indexStart = 0;        indexEnd = 1;       data.connectorDeviceType,   = unpack('<B', dataArray[indexStart:indexEnd])
+        indexStart = indexEnd; indexEnd += 5;       data.address                = dataArray[indexStart:indexEnd]
+        indexStart = indexEnd; indexEnd += 8;       data.channelArray           = dataArray[indexStart:indexEnd]
+
+        data.connectorDeviceType = DeviceType(data.connectorDeviceType)
+
+        return data
+
+
+
+class ResponseRate(ISerializable):
+    # CDEP - Protocol::ResponseRate. Same DataType slot and byte size as Rssi (0x13, 1 byte),
+    # but the Plus docs type the field as an unsigned success-rate metric rather than a signed
+    # dBm value. Kept as its own class rather than changing Rssi in place, since Rssi is still
+    # the shape classic CoDrone EDU hardware sends on this slot.
+
+    def __init__(self):
+        self.responseRate  = 0
+
+
+    @classmethod
+    def getSize(cls):
+        return 1
+
+
+    def toArray(self):
+        return pack('<B', self.responseRate)
+
+
+    @classmethod
+    def parse(cls, dataArray):
+        data = ResponseRate()
+
+        if len(dataArray) != cls.getSize():
+            return None
+
+        data.responseRate, = unpack('<B', dataArray)
+
+        return data
+
+
+
 class Command(ISerializable):
 
     def __init__(self):
@@ -858,17 +949,17 @@ class MonitorHeaderType(Enum):
 
 
 class MonitorDataType(Enum):
-    
-    U8          = 0x00,
-    S8          = 0x01,
-    U16         = 0x02,
-    S16         = 0x03,
-    U32         = 0x04,
-    S32         = 0x05,
-    U64         = 0x06,
-    S64         = 0x07,
-    F32         = 0x08,
-    F64         = 0x09,
+
+    U8          = 0x00
+    S8          = 0x01
+    U16         = 0x02
+    S16         = 0x03
+    U32         = 0x04
+    S32         = 0x05
+    U64         = 0x06
+    S64         = 0x07
+    F32         = 0x08
+    F64         = 0x09
 
     EndOfType   = 0x0A
 
@@ -1646,6 +1737,156 @@ class LightEventColors(ISerializable):
         return data
 
 
+
+# CDEP LED packet commands Start
+# Sent as top-level DataType (0x24-0x27), independent of Command/LightMode/LightEvent.
+
+
+class LightRainbow(ISerializable):
+
+    def __init__(self):
+        self.color      = Color()
+        self.interval   = 0
+
+
+    @classmethod
+    def getSize(cls):
+        return Color.getSize() + 2
+
+
+    def toArray(self):
+        dataArray = bytearray()
+        dataArray.extend(self.color.toArray())
+        dataArray.extend(pack('<H', self.interval))
+        return dataArray
+
+
+    @classmethod
+    def parse(cls, dataArray):
+        data = LightRainbow()
+
+        if len(dataArray) != cls.getSize():
+            return None
+
+        indexStart = 0;        indexEnd = Color.getSize();      data.color      = Color.parse(dataArray[indexStart:indexEnd])
+        indexStart = indexEnd; indexEnd += 2;                   data.interval,  = unpack('<H', dataArray[indexStart:indexEnd])
+
+        return data
+
+
+
+class LightFlicker(ISerializable):
+
+    def __init__(self):
+        self.color      = Color()
+        self.interval   = 0
+
+
+    @classmethod
+    def getSize(cls):
+        return Color.getSize() + 2
+
+
+    def toArray(self):
+        dataArray = bytearray()
+        dataArray.extend(self.color.toArray())
+        dataArray.extend(pack('<H', self.interval))
+        return dataArray
+
+
+    @classmethod
+    def parse(cls, dataArray):
+        data = LightFlicker()
+
+        if len(dataArray) != cls.getSize():
+            return None
+
+        indexStart = 0;        indexEnd = Color.getSize();      data.color      = Color.parse(dataArray[indexStart:indexEnd])
+        indexStart = indexEnd; indexEnd += 2;                   data.interval,  = unpack('<H', dataArray[indexStart:indexEnd])
+
+        return data
+
+
+
+class LightRandom(ISerializable):
+    # Doc's template shares the same 5-byte shape as LightRainbow/LightFlicker; the drone may
+    # ignore the color/interval fields for this mode, but that is not confirmed by the docs.
+
+    def __init__(self):
+        self.color      = Color()
+        self.interval   = 0
+
+
+    @classmethod
+    def getSize(cls):
+        return Color.getSize() + 2
+
+
+    def toArray(self):
+        dataArray = bytearray()
+        dataArray.extend(self.color.toArray())
+        dataArray.extend(pack('<H', self.interval))
+        return dataArray
+
+
+    @classmethod
+    def parse(cls, dataArray):
+        data = LightRandom()
+
+        if len(dataArray) != cls.getSize():
+            return None
+
+        indexStart = 0;        indexEnd = Color.getSize();      data.color      = Color.parse(dataArray[indexStart:indexEnd])
+        indexStart = indexEnd; indexEnd += 2;                   data.interval,  = unpack('<H', dataArray[indexStart:indexEnd])
+
+        return data
+
+
+
+class LightIndividual(ISerializable):
+    # 5 independently addressable LEDs + a shared interval. Doc example: 17-byte payload
+    # (5 * 3-byte Color + 2-byte interval), matching the LED_individual header length of 0x11.
+
+    def __init__(self):
+        self.colors     = [Color(), Color(), Color(), Color(), Color()]
+        self.interval   = 0
+
+
+    @classmethod
+    def getSize(cls):
+        return (Color.getSize() * 5) + 2
+
+
+    def toArray(self):
+        dataArray = bytearray()
+        for color in self.colors:
+            dataArray.extend(color.toArray())
+        dataArray.extend(pack('<H', self.interval))
+        return dataArray
+
+
+    @classmethod
+    def parse(cls, dataArray):
+        data = LightIndividual()
+
+        if len(dataArray) != cls.getSize():
+            return None
+
+        indexStart = 0
+        for i in range(5):
+            indexEnd = indexStart + Color.getSize()
+            data.colors[i] = Color.parse(dataArray[indexStart:indexEnd])
+            indexStart = indexEnd
+
+        data.interval, = unpack('<H', dataArray[indexStart:indexStart + 2])
+
+        return data
+
+
+# CDEP LED packet commands End
+
+
+
 # Light End
 
 

{codrone_edu-2.9 → codrone_edu-2.10}/codrone_edu/storage.py

@@ -87,4 +87,10 @@ class Parser:
         self.d[DataType.InformationAssembledForController]  = InformationAssembledForController.parse
         self.d[DataType.InformationAssembledForEntry]       = InformationAssembledForEntry.parse
 
+        # CDEP LED packet commands
+        self.d[DataType.LED_rainbow]        = None
+        self.d[DataType.LED_flicker]        = None
+        self.d[DataType.LED_random]         = None
+        self.d[DataType.LED_individual]     = None
+
 

{codrone_edu-2.9 → codrone_edu-2.10}/codrone_edu/system.py

@@ -79,7 +79,8 @@ class ModelNumber(Enum):
     Drone_12_Drone_P1       = 0x000C1002  # Drone_12_Drone_P1 (CDE JROTC ed.)
     Drone_8_Drone_P3        = 0x00081003  # Drone_8_Drone_P3 CoDrone EDU (IMU)
 
-    Drone_12_Controller_P10 = 0x000C200A  # CDEP Controller
+    Drone_12_Controller_P10 = 0x000C200A  # CDEP Controller (v1.0)
+    Drone_12_Controller_P11 = 0x000C2010  # CDEP Controller (v1.1)
     Drone_12_Drone_P10      = 0x000C100A  # CDEP Drone
 
 
@@ -130,7 +131,7 @@ class ModeSystem(Enum):
 
 
 class ModeControlFlight(Enum):
-    
+
     None_               = 0x00
 
     Attitude            = 0x10      # 자세 - X,Y는 각도(deg)로 입력받음, Z,Yaw는 속도(m/s)로 입력 받음
@@ -138,8 +139,67 @@ class ModeControlFlight(Enum):
     Manual              = 0x12      # 고도를 수동으로 조종함
     Rate                = 0x13      # Rate - X,Y는 각속도(deg/s)로 입력받음, Z,Yaw는 속도(m/s)로 입력 받음
     Function            = 0x14      # 기능
-    
-    EndOfType           = 0x15
+
+    BirdWing            = 0x15      # CDEP - bird wing style aircraft
+    FixedWing           = 0x16      # CDEP - fixed wing aircraft
+
+    EndOfType           = 0x17
+
+
+
+class ModeDrone(Enum):
+    # CDEP - drone-side operating mode (Flight / Card-coding / Motion-coding / Piano / Link / Calibration)
+
+    None_               = 0x00
+
+    Flight              = 0x10
+    Card                = 0x11
+    Motion              = 0x12
+    Piano               = 0x13
+
+    Link                = 0x80
+    Calibration         = 0x81
+
+    Error               = 0xA0
+
+    EndOfType           = 0xA1
+
+
+
+class ModeController(Enum):
+    # CDEP - controller-side operating mode
+
+    None_               = 0x00
+
+    Control             = 0x10
+    Setup               = 0x11
+
+    Link                = 0x80
+
+    Error               = 0xA0
+
+    EndOfType           = 0xA1
+
+
+
+class ModeConnection(Enum):
+    # CDEP - RF link connection state
+
+    None_               = 0x00
+
+    PairingStart        = 0x01
+    PairingExchange     = 0x02
+    PairingComplete     = 0x03
+
+    Ready               = 0x04
+
+    ConnectingStart     = 0x05
+    Connecting          = 0x06
+    Connected           = 0x07
+    LostConnection      = 0x08
+    Disconnected        = 0x09
+
+    EndOfPairing        = 0x0A
 
 
 
@@ -199,26 +259,34 @@ class ErrorFlagsForSensor(Enum):
     
     RangeGround_NoAnswer                    = 0x00000100    # No response from Ground distance sensor
     RangeGround_WrongValue                  = 0x00000200    # Incorrect value from Ground distance sensor
-    
+
+    RangeFront_NoAnswer                     = 0x00000400    # CDEP - No response from front distance sensor
+    RangeFront_WrongValue                   = 0x00000800    # CDEP - Incorrect value from front distance sensor
+
     Flow_NoAnswer                           = 0x00001000    # No response from Flow sensor
     Flow_WrongValue                         = 0x00002000    # Incorrect value from Flow sensor
     Flow_CannotRecognizeGroundImage         = 0x00004000    # Cannot recognize ground image
 
+    RF_NoAnswer                             = 0x10000000    # CDEP - No response from RF module
+    RF_Paired                               = 0x20000000    # CDEP - RF paired
+    RF_Connected                            = 0x40000000    # CDEP - RF connected
+
 
 
 class ErrorFlagsForState(Enum):
 
     None_                                   = 0x00000000
-    
+
     NotRegistered                           = 0x00000001    # Device not registered
     FlashReadLock_UnLocked                  = 0x00000002    # Flash memory read lock not engaged
     BootloaderWriteLock_UnLocked            = 0x00000004    # Bootloader write lock not engaged
     LowBattery                              = 0x00000008    # Low battery
-    
+
     TakeoffFailure_CheckPropellerAndMotor   = 0x00000010    # Takeoff failure
     CheckPropellerVibration                 = 0x00000020    # Propeller vibration detected
     Attitude_NotStable                      = 0x00000040    # Attitude is too tilted or inverted
-    
+    Motors_NotGood                          = 0x00000080    # CDEP - one or more motors not functioning correctly
+
     CanNotFlip_LowBattery                   = 0x00000100    # Battery below 50%
     CanNotFlip_TooHeavy                     = 0x00000200    # Device is too heavy
 
@@ -269,7 +337,7 @@ class Direction(Enum):
 
 
 class Rotation(Enum):
-    
+
     None_               = 0x00
 
     Clockwise           = 0x01
@@ -279,6 +347,22 @@ class Rotation(Enum):
 
 
 
+class MotorPart(Enum):
+    # CDEP - Motor::Part::Type. Note: BYROBOT's own docs are internally inconsistent about whether
+    # index 0 is the front-left or front-right motor (prose says front-left, enum lists MFR first).
+    # This transcribes the literal enum order; verify against real hardware before relying on it.
+
+    MFR                 = 0      # Front Right
+    MRR                 = 1      # Rear Right
+    MRL                 = 2      # Rear Left
+    MFL                 = 3      # Front Left
+
+    EndOfPart           = 4
+
+    All                 = 5
+
+
+
 class SensorOrientation(Enum):
     
     None_               = 0x00

{codrone_edu-2.9 → codrone_edu-2.10}/codrone_edu/tools/transformer.py

@@ -29,7 +29,7 @@ awaitable_drone_methods = frozenset({
     "takeoff", "land", "emergency_stop", "hover", "reset_move",
     # Movement - basic - 14
     "go", "move", "turn", "flip", "set_waypoint", "sendLanding", "sendControlWhile",
-    "move_distance", "move_forward", "move_backward", "move_left", "move_right",
+    "move_distance", "move_forward", "move_backward", "move_left", "move_right", "move_upward", "move_downward",
     "send_absolute_position", "goto_waypoint",
     # Movement - turns - 4
     "turn_degree", "turn_direction", "turn_left", "turn_right",
@@ -49,7 +49,7 @@ awaitable_drone_methods = frozenset({
     "get_color_data", "get_position_data", "get_pos_x", "get_pos_y", "get_pos_z",
     "get_height", "get_flow_data", "get_flow_velocity_x", "get_flow_velocity_y",
     "get_state_data", "get_system_state", "get_flight_state", "get_movement_state",
-    "get_control_speed", "speed_change", "get_motion_data", "get_raw_motion_data",
+    "get_control_speed", "speed_change", "control_change", "headless_change", "get_motion_data", "get_raw_motion_data",
     "get_accel_x", "get_accel_y", "get_accel_z",
     "get_x_gyro", "get_y_gyro", "get_z_gyro",
     "get_angle_x", "get_angle_y", "get_angle_z",
@@ -110,6 +110,87 @@ class CodeAnalyzer(ast.NodeVisitor):
             self.function_aliases[local_name] = alias.name
         self.generic_visit(node)
 
+
+class DroneUsageAnalyzer(ast.NodeVisitor):
+    """
+    Standalone AST visitor backing check_drone_usage(). Kept separate from
+    CodeAnalyzer (rather than added to it) so transform_code() and
+    transform_imported_module() - which run CodeAnalyzer on every execution -
+    don't pay for traversal they don't need.
+    """
+    def __init__(self):
+        self.uses_drone = False
+        self.instantiates_drone = False
+        self.has_pair_or_connect = False
+        self.has_close_or_disconnect = False
+        self.has_drone_import = False
+
+    def visit_Assign(self, node):
+        if isinstance(node.value, ast.Call) and isinstance(node.value.func, ast.Name):
+            if node.value.func.id == 'Drone':
+                if node.targets[0].id != 'drone':
+                    raise ValueError(f"Drone instance must be named 'drone', found '{node.targets[0].id}' instead.")
+                self.instantiates_drone = True
+        self.generic_visit(node)
+
+    def visit_ImportFrom(self, node):
+        if node.module == 'codrone_edu.drone':
+            self.has_drone_import = True
+        self.generic_visit(node)
+
+    def visit_Import(self, node):
+        for alias in node.names:
+            if alias.name == 'codrone_edu.drone':
+                self.has_drone_import = True
+        self.generic_visit(node)
+
+    def visit_Attribute(self, node):
+        if isinstance(node.value, ast.Name) and node.value.id == 'drone':
+            self.uses_drone = True
+        self.generic_visit(node)
+
+    def visit_Call(self, node):
+        if isinstance(node.func, ast.Name) and node.func.id == 'Drone':
+            self.instantiates_drone = True
+        elif isinstance(node.func, ast.Attribute) and isinstance(node.func.value, ast.Name) and node.func.value.id == 'drone':
+            if node.func.attr in ('pair', 'connect'):
+                self.has_pair_or_connect = True
+            elif node.func.attr in ('close', 'disconnect'):
+                self.has_close_or_disconnect = True
+        self.generic_visit(node)
+
+    def get_warnings(self):
+        """
+        Returns a list of warning strings for the most common CoDrone EDU
+        setup mistakes: using 'drone.' without creating a Drone() instance,
+        without pairing/connecting, without closing/disconnecting, or using
+        Drone() without importing it. Returns an empty list when no issues
+        are found.
+        """
+        warnings = []
+
+        if self.uses_drone and not self.instantiates_drone:
+            warnings.append(
+                "Your code uses 'drone.' but never creates a Drone() instance. This will not run outside of Python for Robolink. " \
+                "Add 'drone = Drone()' before using 'drone'."
+            )
+        if self.uses_drone and not self.has_pair_or_connect:
+            warnings.append(
+                "Your code uses 'drone.' but never calls drone.pair() or drone.connect(). This will not run outside of Python for Robolink."
+            )
+        if self.uses_drone and not self.has_close_or_disconnect:
+            warnings.append(
+                "Your code uses 'drone.' but never calls drone.close() or drone.disconnect(). This will not run outside of Python for Robolink. " \
+                "Add drone.close() or drone.disconnect() at the end of your program to release the connection."
+            )
+        if self.instantiates_drone and not self.has_drone_import:
+            warnings.append(
+                "Your code uses 'Drone()' but never imports it. Add 'from codrone_edu.drone import *' at the top of your program."
+            )
+
+        return warnings
+
+
 class AsyncTransformer(ast.NodeTransformer):
     def __init__(self, custom_functions, drone_instance_name, function_aliases=None):
         self.custom_functions = custom_functions
@@ -590,6 +671,9 @@ class SleepTransformer(ast.NodeTransformer):
 class CheckInterruptAndGlobalTransformer(ast.NodeTransformer):
     def __init__(self, convert_global_to_nonlocal=True):
         self.convert_global_to_nonlocal = convert_global_to_nonlocal
+        self._func_depth = 0
+        # Only `while True:` loops get the injected sleep
+        self.injected_sleep = False
 
     def copy_location(self, new_node, old_node):
         ast.copy_location(new_node, old_node)
@@ -609,6 +693,33 @@ class CheckInterruptAndGlobalTransformer(ast.NodeTransformer):
             return [node, check_interrupt_call]
         return super().generic_visit(node)
 
+    def visit_FunctionDef(self, node):
+        self._func_depth += 1
+        try:
+            return self.generic_visit(node)
+        finally:
+            self._func_depth -= 1
+
+    def visit_AsyncFunctionDef(self, node):
+        self._func_depth += 1
+        try:
+            return self.generic_visit(node)
+        finally:
+            self._func_depth -= 1
+
+    def visit_While(self, node):
+        is_while_true = isinstance(node.test, ast.Constant) and node.test.value is True
+        node = self.generic_visit(node)
+        if self._func_depth > 0 and is_while_true:
+            sleep_call = ast.Expr(value=ast.Await(value=ast.Call(
+                func=ast.Attribute(value=ast.Name(id='asyncio', ctx=ast.Load()), attr='sleep', ctx=ast.Load()),
+                args=[ast.Constant(value=0.0000000001)], keywords=[]
+            )))
+            sleep_call = self.copy_location(sleep_call, node)
+            node.body.append(sleep_call)
+            self.injected_sleep = True
+        return node
+
     def visit_Global(self, node):
         # Only convert global to nonlocal if we're in a wrapper function
         if self.convert_global_to_nonlocal:
@@ -616,6 +727,31 @@ class CheckInterruptAndGlobalTransformer(ast.NodeTransformer):
             return ast.copy_location(nonlocal_node, node)
         return node
 
+def check_drone_usage(code):
+    """
+    Static, AST-based check for the most common CoDrone EDU setup mistakes:
+    using 'drone.' without creating a Drone() instance, without pairing or
+    connecting, without closing or disconnecting, or using Drone() without
+    importing it. Returns a list of warning strings (empty if no issues are
+    found). Like transform_code(), raises ValueError if a Drone() instance is
+    assigned to a variable not named 'drone'.
+    """
+    tree = ast.parse(code)
+    analyzer = DroneUsageAnalyzer()
+    analyzer.visit(tree)
+    return analyzer.get_warnings()
+
+
+def ensure_asyncio_import(tree):
+    """Insert `import asyncio` at module top level if not already present."""
+    has_asyncio = any(
+        (isinstance(n, ast.Import) and any(alias.name == 'asyncio' for alias in n.names))
+        or (isinstance(n, ast.ImportFrom) and n.module == 'asyncio')
+        for n in tree.body
+    )
+    if not has_asyncio:
+        tree.body.insert(0, ast.Import(names=[ast.alias(name='asyncio', asname=None)]))
+
 def transform_code(code):
     # Parse the code into an AST
     tree = ast.parse(code)
@@ -645,6 +781,9 @@ def transform_code(code):
             combined_transformer.visit(node)
             break
 
+    if combined_transformer.injected_sleep:
+        ensure_asyncio_import(tree)
+
     # Ensure the tree is correctly fixed
     ast.fix_missing_locations(tree)
 
@@ -682,6 +821,9 @@ def transform_imported_module(code):
     tree = sleep_transformer.visit(tree)
     tree = combined_transformer.visit(tree)
 
+    if combined_transformer.injected_sleep:
+        ensure_asyncio_import(tree)
+
     # Inject checkInterrupt import at the beginning of the module
     # This is necessary because CheckInterruptTransformer adds checkInterrupt() calls
     check_interrupt_import = ast.ImportFrom(

{codrone_edu-2.9 → codrone_edu-2.10}/codrone_edu.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codrone_edu
-Version: 2.9
+Version: 2.10
 Summary: Python CoDrone EDU library
 Home-page: 
 Author: 

{codrone_edu-2.9 → codrone_edu-2.10}/setup.py

@@ -22,7 +22,7 @@ Python package for controlling CoDrone EDU.
 
 setup(
     name='codrone_edu',
-    version='2.9',
+    version='2.10',
     description='Python CoDrone EDU library',
     url='',
     author='',