ardrone_sdk 0.4.0__tar.gz

ardrone_sdk-0.4.0/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2011 Bastian Venthur
+Copyright (c) 2015-2021, Lily Foster <lily@lily.flowers>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

ardrone_sdk-0.4.0/PKG-INFO

@@ -0,0 +1,54 @@
+Metadata-Version: 2.4
+Name: ardrone_sdk
+Version: 0.4.0
+Summary: A Python library for controlling the Parrot AR.Drone 2.0 over a network
+Author-email: Lily Foster <lily@lily.flowers>
+License-Expression: MIT
+Project-URL: Source, https://github.com/lilyinstarlight/python-ardrone
+Project-URL: Tracker, https://github.com/lilyinstarlight/python-ardrone/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: C
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: System :: Hardware :: Hardware Drivers
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Pillow
+Dynamic: license-file
+
+python-ardrone
+==============
+
+_**Note: This library is looking for testers and/or maintainers! I have not had access myself to an AR.Drone 2.0 for a while, but there are several important unreleased changes that need testing on actual hardware as well as [stuff that still needs to be done](TODO.md) to make the library more robust. Open a new issue on this repository if you are interested!**_
+
+A Python library for controlling the Parrot AR.Drone 2.0 over a network.
+
+Usage
+-----
+
+```python
+import ardrone
+
+drone = ardrone.ARDrone()
+
+drone.takeoff()
+drone.land()
+
+print(drone.navdata['demo']['battery'])
+
+drone.image.show()
+
+drone.halt()
+```
+
+Thanks
+------
+
+Thanks to Bastian Venthur for making the beginnings on which this library was based at https://github.com/venthur/python-ardrone!

ardrone_sdk-0.4.0/README.md

@@ -0,0 +1,29 @@
+python-ardrone
+==============
+
+_**Note: This library is looking for testers and/or maintainers! I have not had access myself to an AR.Drone 2.0 for a while, but there are several important unreleased changes that need testing on actual hardware as well as [stuff that still needs to be done](TODO.md) to make the library more robust. Open a new issue on this repository if you are interested!**_
+
+A Python library for controlling the Parrot AR.Drone 2.0 over a network.
+
+Usage
+-----
+
+```python
+import ardrone
+
+drone = ardrone.ARDrone()
+
+drone.takeoff()
+drone.land()
+
+print(drone.navdata['demo']['battery'])
+
+drone.image.show()
+
+drone.halt()
+```
+
+Thanks
+------
+
+Thanks to Bastian Venthur for making the beginnings on which this library was based at https://github.com/venthur/python-ardrone!

ardrone_sdk-0.4.0/ardrone/__init__.py

@@ -0,0 +1,3 @@
+from ardrone.drone import ARDrone
+
+__all__ = ['ARDrone']

ardrone_sdk-0.4.0/ardrone/at.py

@@ -0,0 +1,169 @@
+import socket
+import struct
+import threading
+
+import ardrone.constant
+
+
+def f2i(f):
+    """Interpret IEEE-754 floating-point value as signed integer.
+
+    Arguments:
+    f -- floating point value
+    """
+    return struct.unpack('i', struct.pack('f', f))[0]
+
+
+class ATCommand(object):
+    def __init__(self, host):
+        """
+        Open a new AT command socket
+
+        Parameters:
+        host -- destination address
+        """
+        self.host = host
+        self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+
+        self.seq = 1
+        self.interval = 0.2
+
+        self.lock = threading.Lock()
+        self.comwdg_timer = threading.Timer(self.interval, self.comwdg)
+
+    def halt(self):
+        """
+        Halts communication with the drone
+        """
+        with self.lock:
+            self.comwdg_timer.cancel()
+
+    def ref(self, takeoff, emergency=False):
+        """
+        Basic behaviour of the drone: take-off/landing, emergency stop/reset)
+
+        Parameters:
+        takeoff -- True: Takeoff / False: Land
+        emergency -- True: Turn off the engines
+        """
+        p = 0b10001010101000000000000000000
+        if takeoff:
+            p |= 0b1000000000
+        if emergency:
+            p |= 0b100000000
+        self.at('REF', [p])
+
+    def pcmd(self, progressive, lr, fb, vv, va):
+        """
+        Makes the drone move (translate/rotate).
+
+        Parameters:
+        progressive -- True: enable progressive commands, False: disable (i.e.
+            enable hovering mode)
+        lr -- left-right tilt: float [-1..1] negative: left, positive: right
+        rb -- front-back tilt: float [-1..1] negative: forwards, positive:
+            backwards
+        vv -- vertical speed: float [-1..1] negative: go down, positive: rise
+        va -- angular speed: float [-1..1] negative: spin left, positive: spin
+            right
+
+        The above float values are a percentage of the maximum speed.
+        """
+        p = 1 if progressive else 0
+        self.at('PCMD', [p, float(lr), float(fb), float(vv), float(va)])
+
+    def ftrim(self):
+        """
+        Tell the drone it's lying horizontally.
+        """
+        self.at('FTRIM')
+
+    def zap(self, stream):
+        """
+        Selects which video stream to send on the video UDP port.
+
+        Parameters:
+        stream -- Integer: video stream to broadcast
+        """
+        # FIXME: improve parameters to select the modes directly
+        self.at('ZAP', [stream])
+
+    def config(self, option, value):
+        """Set configuration parameters of the drone."""
+        self.at('CONFIG', [str(option), str(value)])
+
+    def comwdg(self):
+        """
+        Reset communication watchdog.
+        """
+        self.at('COMWDG')
+
+    def aflight(self, flag):
+        """
+        Makes the drone fly autonomously.
+
+        Parameters:
+        flag -- Integer: 1: start flight, 0: stop flight
+        """
+        self.at('AFLIGHT', [flag])
+
+    def pwm(self, m1, m2, m3, m4):
+        """
+        Sends control values directly to the engines, overriding control loops.
+
+        Parameters:
+        m1 -- Integer: front left command
+        m2 -- Integer: front right command
+        m3 -- Integer: back right command
+        m4 -- Integer: back left command
+        """
+        self.at('PWM', [m1, m2, m3, m4])
+
+    def led(self, anim, f, d):
+        """
+        Control the drones LED.
+
+        Parameters:
+        anim -- Integer: animation to play
+        f -- Float: frequency in HZ of the animation
+        d -- Integer: total duration in seconds of the animation
+        """
+        self.at('LED', [anim, float(f), d])
+
+    def anim(self, anim, d):
+        """
+        Makes the drone execute a predefined movement (animation).
+
+        Parameters:
+        anim -- Integer: animation to play
+        d -- Integer: total duration in seconds of the animation
+        """
+        self.at('ANIM', [anim, d])
+
+    def at(self, command, params=[]):
+        """
+        Encodes and sends AT command
+
+        Parameters:
+        command -- the command
+        params -- a list of elements which can be either int, float or string
+        """
+        params_str = []
+        for p in params:
+            if type(p) == int:
+                params_str.append('{:d}'.format(p))
+            elif type(p) == float:
+                params_str.append('{:d}'.format(f2i(p)))
+            elif type(p) == str:
+                params_str.append('"{:s}"'.format(p))
+
+        with self.lock:
+            self.comwdg_timer.cancel()
+
+            msg = 'AT*{:s}={:d}{:s}\r'.format(command, self.seq, ''.join(',' + param for param in params_str))
+            self.sock.sendto(msg.encode(), (self.host, ardrone.constant.COMMAND_PORT))
+
+            self.seq += 1
+
+            self.comwdg_timer = threading.Timer(self.interval, self.comwdg)
+            self.comwdg_timer.start()

ardrone_sdk-0.4.0/ardrone/client.py

@@ -0,0 +1,73 @@
+import fcntl
+import sys
+import termios
+import os
+
+import ardrone
+
+
+def main():
+    if len(sys.argv) != 1 and len(sys.argv) != 2:
+        print('usage: ' + sys.argv[0] + ' [host]')
+        sys.exit(1)
+
+    fd = sys.stdin.fileno()
+
+    oldterm = termios.tcgetattr(fd)
+    newattr = termios.tcgetattr(fd)
+    newattr[3] = newattr[3] & ~termios.ICANON & ~termios.ECHO
+    termios.tcsetattr(fd, termios.TCSANOW, newattr)
+
+    oldflags = fcntl.fcntl(fd, fcntl.F_GETFL)
+    fcntl.fcntl(fd, fcntl.F_SETFL, oldflags | os.O_NONBLOCK)
+
+    if len(sys.argv) >= 2:
+        drone = ardrone.ARDrone(sys.argv[1])
+    else:
+        drone = ardrone.ARDrone()
+
+    try:
+        while 1:
+            try:
+                c = sys.stdin.read(1).lower()
+
+                if c == 'p':
+                    break
+                elif c == 'a':
+                    drone.move_left()
+                elif c == 'd':
+                    drone.move_right()
+                elif c == 'w':
+                    drone.move_forward()
+                elif c == 's':
+                    drone.move_backward()
+                elif c == ' ':
+                    drone.land()
+                elif c == '\n':
+                    drone.takeoff()
+                elif c == 'q':
+                    drone.turn_left()
+                elif c == 'e':
+                    drone.turn_right()
+                elif c == '1':
+                    drone.move_up()
+                elif c == '2':
+                    drone.hover()
+                elif c == '3':
+                    drone.move_down()
+                elif c == 't':
+                    drone.reset()
+                elif c == 'x':
+                    drone.hover()
+                elif c == 'y':
+                    drone.trim()
+            except IOError:
+                pass
+    finally:
+        termios.tcsetattr(fd, termios.TCSAFLUSH, oldterm)
+        fcntl.fcntl(fd, fcntl.F_SETFL, oldflags)
+        drone.halt()
+
+
+if __name__ == '__main__':
+    main()

ardrone_sdk-0.4.0/ardrone/constant.py

@@ -0,0 +1,3 @@
+NAVDATA_PORT = 5554
+VIDEO_PORT = 5555
+COMMAND_PORT = 5556

ardrone_sdk-0.4.0/ardrone/drone.py

@@ -0,0 +1,134 @@
+"""
+Python library for the AR.Drone.
+"""
+
+import time
+import multiprocessing
+
+import PIL.Image
+
+import ardrone.at
+import ardrone.network
+
+
+class ARDrone(object):
+    """ARDrone Class.
+
+    Instantiate this class to control your drone and receive decoded video and
+    navdata.
+    """
+
+    def __init__(self, host='192.168.1.1'):
+        self.host = host
+
+        self.speed = 0.2
+
+        self.atcmd = ardrone.at.ATCommand(self.host)
+        self.atcmd.config('general:navdata_demo', 'TRUE')
+        self.atcmd.config('control:altitude_max', '20000')
+        self.video_pipe, video_pipe_other = multiprocessing.Pipe()
+        self.nav_pipe, nav_pipe_other = multiprocessing.Pipe()
+        self.com_pipe, com_pipe_other = multiprocessing.Pipe()
+        self.network_process = ardrone.network.ARDroneNetworkProcess(self.host, nav_pipe_other, video_pipe_other, com_pipe_other)
+        self.network_process.start()
+        self.ipc_thread = ardrone.network.IPCThread(self)
+        self.ipc_thread.start()
+
+        self.image = PIL.Image.new('RGB', (640, 360))
+        self.navdata = dict()
+
+        self.time = 0
+
+    def takeoff(self):
+        """Make the drone takeoff."""
+        self.atcmd.ref(True)
+
+    def land(self):
+        """Make the drone land."""
+        self.atcmd.ref(False)
+
+    def hover(self):
+        """Make the drone hover."""
+        self.atcmd.pcmd(False, 0, 0, 0, 0)
+
+    def move_left(self):
+        """Make the drone move left."""
+        self.atcmd.pcmd(True, -self.speed, 0, 0, 0)
+
+    def move_right(self):
+        """Make the drone move right."""
+        self.atcmd.pcmd(True, self.speed, 0, 0, 0)
+
+    def move_up(self):
+        """Make the drone rise upwards."""
+        self.atcmd.pcmd(True, 0, 0, self.speed, 0)
+
+    def move_down(self):
+        """Make the drone decent downwards."""
+        self.atcmd.pcmd(True, 0, 0, -self.speed, 0)
+
+    def move_forward(self):
+        """Make the drone move forward."""
+        self.atcmd.pcmd(True, 0, -self.speed, 0, 0)
+
+    def move_backward(self):
+        """Make the drone move backwards."""
+        self.atcmd.pcmd(True, 0, self.speed, 0, 0)
+
+    def turn_left(self):
+        """Make the drone rotate left."""
+        self.atcmd.pcmd(True, 0, 0, 0, -self.speed)
+
+    def turn_right(self):
+        """Make the drone rotate right."""
+        self.atcmd.pcmd(True, 0, 0, 0, self.speed)
+
+    def reset(self):
+        """Toggle the drone's emergency state."""
+        self.atcmd.ref(False, True)
+        time.sleep(0.1)
+        self.atcmd.ref(False, False)
+
+    def trim(self):
+        """Flat trim the drone."""
+        self.atcmd.ftrim
+
+    def set_cam(self, cam):
+        """Set active camera.
+
+        Valid values are 0 for the front camera and 1 for the bottom camera
+        """
+        self.atcmd.config('video:video_channel', cam)
+
+    def set_speed(self, speed):
+        """Set the drone's speed.
+
+        Valid values are floats from [0..1]
+        """
+        self.speed = speed
+
+    def halt(self):
+        """Shutdown the drone.
+
+        This method does not land or halt the actual drone, but the
+        communication with the drone. You should call it at the end of your
+        application to close all sockets, pipes, processes and threads related
+        with this object.
+        """
+        self.atcmd.halt()
+        self.ipc_thread.stop()
+        self.ipc_thread.join()
+        self.network_process.terminate()
+        self.network_process.join()
+
+    def move(self, lr, fb, vv, va):
+        """Makes the drone move (translate/rotate).
+
+        Parameters:
+        lr -- left-right tilt: float [-1..1] negative: left, positive: right
+        fb -- front-back tilt: float [-1..1] negative: forwards, positive:
+            backwards
+        vv -- vertical speed: float [-1..1] negative: go down, positive: rise
+        va -- angular speed: float [-1..1] negative: spin left, positive: spin
+            right"""
+        self.atcmd.pcmd(True, lr, fb, vv, va)

ardrone_sdk-0.4.0/ardrone/navdata.py

@@ -0,0 +1,82 @@
+import struct
+
+
+def decode(packet):
+    """Decode a navdata packet."""
+    offset = 0
+
+    _ = struct.unpack_from('IIII', packet, offset)
+    s = _[1]
+    state = dict()
+    state['fly']                 = s       & 1  # FLY MASK : (0) ardrone is landed, (1) ardrone is flying
+    state['video']               = s >>  1 & 1  # VIDEO MASK : (0) video disable, (1) video enable
+    state['vision']              = s >>  2 & 1  # VISION MASK : (0) vision disable, (1) vision enable
+    state['control']             = s >>  3 & 1  # CONTROL ALGO (0) euler angles control, (1) angular speed control
+    state['altitude']            = s >>  4 & 1  # ALTITUDE CONTROL ALGO : (0) altitude control inactive (1) altitude control active
+    state['user_feedback_start'] = s >>  5 & 1  # USER feedback : Start button state
+    state['command']             = s >>  6 & 1  # Control command ACK : (0) None, (1) one received
+    state['fw_file']             = s >>  7 & 1  # Firmware file is good (1)
+    state['fw_ver']              = s >>  8 & 1  # Firmware update is newer (1)
+    state['fw_upd']              = s >>  9 & 1  # Firmware update is ongoing (1)
+    state['navdata_demo']        = s >> 10 & 1  # Navdata demo : (0) All navdata, (1) only navdata demo
+    state['navdata_bootstrap']   = s >> 11 & 1  # Navdata bootstrap : (0) options sent in all or demo mode, (1) no navdata options sent
+    state['motors']              = s >> 12 & 1  # Motor status : (0) Ok, (1) Motors problem
+    state['com_lost']            = s >> 13 & 1  # Communication lost : (1) com problem, (0) Com is ok
+    state['vbat_low']            = s >> 15 & 1  # VBat low : (1) too low, (0) Ok
+    state['user_el']             = s >> 16 & 1  # User Emergency Landing : (1) User EL is ON, (0) User EL is OFF
+    state['timer_elapsed']       = s >> 17 & 1  # Timer elapsed : (1) elapsed, (0) not elapsed
+    state['angles_out_of_range'] = s >> 19 & 1  # Angles : (0) Ok, (1) out of range
+    state['ultrasound']          = s >> 21 & 1  # Ultrasonic sensor : (0) Ok, (1) deaf
+    state['cutout']              = s >> 22 & 1  # Cutout system detection : (0) Not detected, (1) detected
+    state['pic_version']         = s >> 23 & 1  # PIC Version number OK : (0) a bad version number, (1) version number is OK
+    state['atcodec_thread_on']   = s >> 24 & 1  # ATCodec thread ON : (0) thread OFF (1) thread ON
+    state['navdata_thread_on']   = s >> 25 & 1  # Navdata thread ON : (0) thread OFF (1) thread ON
+    state['video_thread_on']     = s >> 26 & 1  # Video thread ON : (0) thread OFF (1) thread ON
+    state['acq_thread_on']       = s >> 27 & 1  # Acquisition thread ON : (0) thread OFF (1) thread ON
+    state['ctrl_watchdog']       = s >> 28 & 1  # CTRL watchdog : (1) delay in control execution (> 5ms), (0) control is well scheduled
+    state['adc_watchdog']        = s >> 29 & 1  # ADC Watchdog : (1) delay in uart2 dsr (> 5ms), (0) uart2 is good
+    state['com_watchdog']        = s >> 30 & 1  # Communication Watchdog : (1) com problem, (0) Com is ok
+    state['emergency']           = s >> 31 & 1  # Emergency landing : (0) no emergency, (1) emergency
+
+    data = dict()
+    data['state'] = state
+    data['header'] = _[0]
+    data['sequence'] = _[2]
+    data['vision'] = _[3]
+
+    offset += struct.calcsize('IIII')
+
+    demo_fields = [
+        'ctrl_state',
+        'battery',
+        'theta',
+        'phi',
+        'psi',
+        'altitude',
+        'vx',
+        'vy',
+        'vz',
+        'num_frames'
+    ]
+    angles = ['theta', 'phi', 'psi']
+    while True:
+        try:
+            id_nr, size = struct.unpack_from('HH', packet, offset)
+            offset += struct.calcsize('HH')
+        except struct.error:
+            break
+
+        values = []
+        for i in range(size - struct.calcsize('HH')):
+            values.append(struct.unpack_from('c', packet, offset)[0])
+            offset += struct.calcsize('c')
+
+        if id_nr == 0:
+            values = struct.unpack_from('IIfffIfffI', b''.join(values))
+            demo = dict(zip(demo_fields, values))
+            for a in angles:
+                demo[a] = int(demo[a] / 1000)
+
+            data['demo'] = demo
+
+    return data

ardrone_sdk-0.4.0/ardrone/network.py

@@ -0,0 +1,111 @@
+"""
+This module provides access to the data provided by the AR.Drone.
+"""
+
+import select
+import socket
+import struct
+import threading
+import multiprocessing
+
+import PIL.Image
+
+import ardrone.constant
+import ardrone.navdata
+import ardrone.video
+
+
+class ARDroneNetworkProcess(multiprocessing.Process):
+    """ARDrone Network Process.
+
+    This process collects data from the video and navdata port, converts the
+    data and sends it to the IPCThread.
+    """
+
+    def __init__(self, host, nav_pipe, video_pipe, com_pipe):
+        multiprocessing.Process.__init__(self)
+        self.nav_pipe = nav_pipe
+        self.video_pipe = video_pipe
+        self.com_pipe = com_pipe
+        self.host = host
+
+    def run(self):
+        video_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        video_socket.connect((self.host, ardrone.constant.VIDEO_PORT))
+
+        nav_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        nav_socket.setblocking(False)
+        nav_socket.sendto(b'\x01\x00\x00\x00', (self.host, ardrone.constant.NAVDATA_PORT))
+
+        stopping = False
+        while not stopping:
+            inputready, outputready, exceptready = select.select([nav_socket, video_socket, self.com_pipe], [], [])
+            for i in inputready:
+                if i == video_socket:
+                    # get first few bytes of header
+                    data = video_socket.recv(12, socket.MSG_WAITALL)
+                    if len(data) != 12:
+                        continue
+
+                    # decode relevant portions of the header
+                    sig_p, sig_a, sig_v, sig_e, version, codec, header, payload = struct.unpack('4cBBHI', data)
+
+                    # check signature (and ignore packet otherwise)
+                    if sig_p != b'P' or sig_a != b'a' or sig_v != b'V' or sig_e != b'E':
+                        continue
+
+                    # get remaining frame
+                    data += video_socket.recv(header - 12 + payload, socket.MSG_WAITALL)
+
+                    try:
+                        # decode the frame
+                        image = ardrone.video.decode(data)
+                        self.video_pipe.send(image)
+                    except ardrone.video.DecodeError:
+                        pass
+                elif i == nav_socket:
+                    while 1:
+                        try:
+                            data, _ = nav_socket.recvfrom(65535)
+                        except IOError:
+                            # we consumed every packet from the socket and
+                            # continue with the last one
+                            break
+                    navdata = ardrone.navdata.decode(data)
+                    self.nav_pipe.send(navdata)
+                elif i == self.com_pipe:
+                    _ = self.com_pipe.recv()
+                    stopping = True
+                    break
+        video_socket.close()
+        nav_socket.close()
+
+
+class IPCThread(threading.Thread):
+    """Inter Process Communication Thread.
+
+    This thread collects the data from the ARDroneNetworkProcess and forwards
+    it to the ARDrone.
+    """
+
+    def __init__(self, drone):
+        threading.Thread.__init__(self)
+        self.drone = drone
+        self.stopping = False
+
+    def run(self):
+        while not self.stopping:
+            inputready, outputready, exceptready = select.select([self.drone.video_pipe, self.drone.nav_pipe], [], [], 1)
+            for i in inputready:
+                if i == self.drone.video_pipe:
+                    while self.drone.video_pipe.poll():
+                        width, height, image = self.drone.video_pipe.recv()
+                    self.drone.image = PIL.Image.frombuffer('RGB', (width, height), image, 'raw', 'RGB', 0, 1)
+                elif i == self.drone.nav_pipe:
+                    while self.drone.nav_pipe.poll():
+                        navdata = self.drone.nav_pipe.recv()
+                    self.drone.navdata = navdata
+
+    def stop(self):
+        """Stop the IPCThread activity."""
+        self.stopping = True

ardrone_sdk-0.4.0/ardrone/video.c

@@ -0,0 +1,168 @@
+#include <Python.h>
+
+#include <libavcodec/avcodec.h>
+#include <libavformat/avformat.h>
+#include <libavutil/imgutils.h>
+#include <libswscale/swscale.h>
+
+struct PaVE {
+	uint8_t signature[4]; // "PaVE"
+	uint8_t version; // protocol version
+	uint8_t video_codec; // codec of frame
+	uint16_t header_size; // size of this header
+	uint32_t payload_size; // size of payload frame
+	uint16_t encoded_stream_width; // encoded width
+	uint16_t encoded_stream_height; // encoded height
+	uint16_t display_width; // actual width
+	uint16_t display_height; // actual height
+
+	uint32_t frame_number; // current frame
+	uint32_t timestamp; // timestamp in milliseconds of frame
+	uint8_t total_chunks; // number of packets for frame (unused)
+	uint8_t chunck_index; // current packet number for frame (unused)
+	uint8_t frame_type; // I-frame or P-frame
+	uint8_t control; // control command (e.g. end of stream, advertised frames)
+	uint32_t stream_byte_position_lw; // lower word of byte position in stream
+	uint32_t stream_byte_position_uw; // upper word of byte position in stream
+	uint16_t stream_id; // current stream this frame is associated with
+	uint8_t total_slices; // number of slices in frame
+	uint8_t slice_index; // position of current slice
+	uint8_t header1_size; // size of SPS in frame (h.264 only)
+	uint8_t header2_size; // size of PPS in frame (h.264 only)
+	uint8_t reserved1[2]; // padding to align to 48 bytes
+	uint32_t advertised_size; // size of advertised frame
+	uint8_t reserved2[12]; // padding to align to 64 bytes
+} __attribute__ ((packed));
+
+static PyObject * VideoDecodeError;
+
+static PyObject * video_decode(PyObject * self, PyObject * args);
+
+static PyMethodDef VideoMethods[] = {
+	{"decode",  video_decode, METH_VARARGS, "decode a PaVE video packet into an RGB image buffer"},
+	{NULL, NULL, 0, NULL}
+};
+
+static struct PyModuleDef videomodule = {
+   PyModuleDef_HEAD_INIT,
+   "video",
+   NULL,
+   -1,
+   VideoMethods
+};
+
+const AVCodec * codec;
+AVCodecContext * context;
+AVFrame * frame;
+struct SwsContext * sws_context;
+
+PyMODINIT_FUNC PyInit_video(void) {
+	PyObject * module;
+
+	module = PyModule_Create(&videomodule);
+	if (module == NULL)
+		return NULL;
+
+	VideoDecodeError = PyErr_NewException("ardrone.video.DecodeError", NULL, NULL);
+	Py_INCREF(VideoDecodeError);
+	PyModule_AddObject(module, "DecodeError", VideoDecodeError);
+
+	codec = avcodec_find_decoder(AV_CODEC_ID_H264);
+	if (!codec) {
+		PyErr_SetString(VideoDecodeError, "could not find h.264 decoder");
+		return NULL;
+	}
+
+	context = avcodec_alloc_context3(codec);
+	if (!context) {
+		PyErr_NoMemory();
+		return NULL;
+	}
+
+	if (avcodec_open2(context, codec, NULL) < 0) {
+		PyErr_SetString(VideoDecodeError, "could not open h.264 codec");
+		return NULL;
+	}
+
+	frame = av_frame_alloc();
+	if (!frame) {
+		PyErr_NoMemory();
+		return NULL;
+	}
+
+	return module;
+}
+
+static PyObject * video_decode(PyObject * self, PyObject * args) {
+	unsigned char * data;
+	int data_size;
+
+	struct PaVE header;
+	unsigned char * payload;
+
+	AVPacket * packet;
+
+	unsigned char * image;
+	int image_width;
+	int image_height;
+	int image_size;
+
+	unsigned char * image_data[1];
+	int image_linesize[1];
+
+	PyObject * py_image;
+
+	if (!PyArg_ParseTuple(args, "s#", &data, &data_size))
+		return NULL;
+
+	header = *((struct PaVE *)data);
+	payload = data + header.header_size;
+
+	if (memcmp(header.signature, "PaVE", 4) != 0) {
+		PyErr_SetString(VideoDecodeError, "packet did not have correct signature");
+		return NULL;
+	}
+
+	if (header.header_size + header.payload_size != (unsigned int)data_size) {
+		PyErr_SetString(VideoDecodeError, "packet size did not match expected size from header");
+		return NULL;
+	}
+
+	packet = av_packet_alloc();
+	if (!packet) {
+		PyErr_NoMemory();
+		return NULL;
+	}
+
+	packet->pts = AV_NOPTS_VALUE;
+	packet->dts = AV_NOPTS_VALUE;
+	packet->data = payload;
+	packet->size = header.payload_size;
+
+	if (avcodec_send_packet(context, packet) != 0 || avcodec_receive_frame(context, frame) != 0) {
+		av_packet_free(&packet);
+		PyErr_SetString(VideoDecodeError, "could not decode frame");
+		return NULL;
+	}
+
+	av_packet_free(&packet);
+
+	image_width = frame->width;
+	image_height = frame->height;
+
+	image_size = av_image_get_buffer_size(AV_PIX_FMT_RGB24, image_width, image_height, 1)*sizeof(uint8_t);
+
+	image = (unsigned char *)av_malloc(image_size);
+
+	image_data[0] = image;
+	image_linesize[0] = image_size/image_height;
+
+	sws_context = sws_getCachedContext(sws_context, context->width, context->height, AV_PIX_FMT_YUV420P, context->width, context->height, AV_PIX_FMT_RGB24, SWS_FAST_BILINEAR, NULL, NULL, NULL);
+	sws_scale(sws_context, (const unsigned char * const *)frame->data, frame->linesize, 0, frame->height, image_data, image_linesize);
+
+	py_image = Py_BuildValue("iiy#", image_width, image_height, image, image_size);
+
+	av_free(image);
+
+	return py_image;
+}

ardrone_sdk-0.4.0/ardrone_sdk.egg-info/PKG-INFO

@@ -0,0 +1,54 @@
+Metadata-Version: 2.4
+Name: ardrone_sdk
+Version: 0.4.0
+Summary: A Python library for controlling the Parrot AR.Drone 2.0 over a network
+Author-email: Lily Foster <lily@lily.flowers>
+License-Expression: MIT
+Project-URL: Source, https://github.com/lilyinstarlight/python-ardrone
+Project-URL: Tracker, https://github.com/lilyinstarlight/python-ardrone/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: C
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: System :: Hardware :: Hardware Drivers
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Pillow
+Dynamic: license-file
+
+python-ardrone
+==============
+
+_**Note: This library is looking for testers and/or maintainers! I have not had access myself to an AR.Drone 2.0 for a while, but there are several important unreleased changes that need testing on actual hardware as well as [stuff that still needs to be done](TODO.md) to make the library more robust. Open a new issue on this repository if you are interested!**_
+
+A Python library for controlling the Parrot AR.Drone 2.0 over a network.
+
+Usage
+-----
+
+```python
+import ardrone
+
+drone = ardrone.ARDrone()
+
+drone.takeoff()
+drone.land()
+
+print(drone.navdata['demo']['battery'])
+
+drone.image.show()
+
+drone.halt()
+```
+
+Thanks
+------
+
+Thanks to Bastian Venthur for making the beginnings on which this library was based at https://github.com/venthur/python-ardrone!

ardrone_sdk-0.4.0/ardrone_sdk.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+ardrone/__init__.py
+ardrone/at.py
+ardrone/client.py
+ardrone/constant.py
+ardrone/drone.py
+ardrone/navdata.py
+ardrone/network.py
+ardrone/video.c
+ardrone_sdk.egg-info/PKG-INFO
+ardrone_sdk.egg-info/SOURCES.txt
+ardrone_sdk.egg-info/dependency_links.txt
+ardrone_sdk.egg-info/entry_points.txt
+ardrone_sdk.egg-info/requires.txt
+ardrone_sdk.egg-info/top_level.txt

ardrone_sdk-0.4.0/ardrone_sdk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ardrone_sdk-0.4.0/ardrone_sdk.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ardrone-client = ardrone.client:main

ardrone_sdk-0.4.0/ardrone_sdk.egg-info/requires.txt

@@ -0,0 +1 @@
+Pillow

ardrone_sdk-0.4.0/ardrone_sdk.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+ardrone
+dist

ardrone_sdk-0.4.0/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["setuptools>=64"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ardrone_sdk"
+version = "0.4.0"
+description = "A Python library for controlling the Parrot AR.Drone 2.0 over a network"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.8"
+authors = [
+    { name = "Lily Foster", email = "lily@lily.flowers" },
+]
+dependencies = [
+    "Pillow",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Operating System :: POSIX",
+    "Operating System :: POSIX :: Linux",
+    "Operating System :: MacOS :: MacOS X",
+    "Operating System :: Microsoft :: Windows",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: C",
+    "Topic :: Scientific/Engineering",
+    "Topic :: System :: Hardware :: Hardware Drivers",
+]
+
+[project.urls]
+Source = "https://github.com/lilyinstarlight/python-ardrone"
+Tracker = "https://github.com/lilyinstarlight/python-ardrone/issues"
+
+[project.scripts]
+ardrone-client = "ardrone.client:main"
+
+[tool.setuptools.packages.find]

ardrone_sdk-0.4.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ardrone_sdk-0.4.0/setup.py

@@ -0,0 +1,9 @@
+from setuptools import setup, Extension
+
+video = Extension(
+    name="ardrone.video",
+    libraries=["avcodec", "avformat", "avutil", "swscale"],
+    sources=["ardrone/video.c"],
+)
+
+setup(ext_modules=[video])