pyaidrone 1.0__py3-none-any.whl

pyaidrone/AIDrone.py

@@ -0,0 +1,151 @@
+import serial
+import binascii
+import math
+from time import sleep
+import random
+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):
+        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
+
+    def receiveHandler(self):
+        while self.isThreadRun:
+            readData = self.serial.read(self.serial.in_waiting or 1)
+            packet = self.parse.packetArrange(readData)
+            if not eq(packet, "None"):
+                if self.receiveCallback != 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=115200, 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)
+                exit()
+                return False
+        except:
+            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 != None:
+            if self.serial.isOpen() == True:
+                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)
+        alt = 0x2F 
+        data = alt.to_bytes(2, byteorder="little", signed=False)
+        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())
+
+

pyaidrone/deflib.py

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

pyaidrone/ikeyevent.py

@@ -0,0 +1,99 @@
+from pynput import keyboard
+
+class IKeyEvent:
+    def on_press(self, key):
+        if key == keyboard.Key.enter:
+            self.keyEnter = True
+        if key == keyboard.Key.space:
+            self.keySpace = True
+        if key == keyboard.Key.up:
+            self.keyUp = True
+        if key == keyboard.Key.down:
+            self.keyDown = True
+        if key == keyboard.Key.right:
+            self.keyRight = True
+        if key == keyboard.Key.left:
+            self.keyLeft = True
+        if key == keyboard.KeyCode(char="w"):
+            self.keyGoUp = True
+        if key == keyboard.KeyCode(char="x"):
+            self.keyGoDown = True
+        if key == keyboard.KeyCode(char="a"):
+            self.keyLTurn = True
+        if key == keyboard.KeyCode(char="d"):
+            self.keyRTurn = True
+        if key == keyboard.Key.esc:
+           self.keyEsc = True
+
+    def on_release(self, key):
+        if key == keyboard.Key.enter:
+            self.keyEnter = False
+        if key == keyboard.Key.space:
+            self.keySpace = False
+        if key == keyboard.Key.up:
+            self.keyUp = False
+        if key == keyboard.Key.down:
+            self.keyDown = False
+        if key == keyboard.Key.right:
+            self.keyRight = False
+        if key == keyboard.Key.left:
+            self.keyLeft = False
+        if key == keyboard.KeyCode(char="w"):
+            self.keyGoUp = False
+        if key == keyboard.KeyCode(char="x"):
+            self.keyGoDown = False
+        if key == keyboard.KeyCode(char="a"):
+            self.keyLTurn = False
+        if key == keyboard.KeyCode(char="d"):
+            self.keyRTurn = False
+        if key == keyboard.Key.esc:
+           self.keyEsc = False
+
+    def __init__(self):
+        self.keyEnter = False
+        self.keySpace = False   
+        self.keyUp = False
+        self.keyDown = False
+        self.keyLeft = False
+        self.keyRight = False
+        self.keyGoUp = False
+        self.keyGoDown = False
+        self.keyLTurn= False
+        self.keyRTurn = False
+        self.keyEsc = False
+
+        listener = keyboard.Listener(on_press=self.on_press, on_release=self.on_release)
+        listener.start()
+
+    def isKeyEnterPressed(self):
+        return self.keyEnter
+
+    def isKeySpacePressed(self):
+        return self.keySpace
+        
+    def isKeyUpPressed(self):
+        return self.keyUp
+
+    def isKeyDownPressed(self):
+        return self.keyDown
+
+    def isKeyLeftPressed(self):
+        return self.keyLeft
+
+    def isKeyRightPressed(self):
+        return self.keyRight
+    
+    def isKeyWPressed(self):
+        return self.keyGoUp
+    
+    def isKeyXPressed(self):
+        return self.keyGoDown
+    
+    def isKeyAPressed(self):
+        return self.keyLTurn
+    
+    def isKeyDPressed(self):
+        return self.keyRTurn
+
+    def isKeyEscPressed(self):
+        return self.keyEsc

pyaidrone/packet.py

@@ -0,0 +1,28 @@
+from pyirbrain.deflib import *
+
+class Packet:
+    def __init__(self, model = AIRONE):
+        self.model = model
+        self.packet = bytearray(20) 
+        if self.model == AIRONE:
+            self.packet[0:5] = [0x26, 0xA8, 0x14, 0xB1, 0x14]
+
+    def getPacket(self):
+        return self.packet
+
+
+    def makePacket(self, start, data):
+        for n in range(start, start+len(data)):
+            self.packet[n] = data[n-start]
+        self.packet[5] = DefLib.checksum(self.packet)
+#        DefLib._print(self.packet)
+        return self.packet
+       
+
+    def clearPacket(self):
+        for n in range(5, 20):
+            self.packet[n] = 0
+        if self.model == AIRONE:
+            self.packet[5] = self.packet[14] = 0x01
+            self.packet[16] = self.packet[18] = 0x64
+        return self.packet

pyaidrone/parse.py

@@ -0,0 +1,45 @@
+from pyirbrain.deflib import *
+
+class Parse:
+    def __init__(self, model=AIDRONE):
+        self.model = model
+        self.packet = bytearray(20)
+        self.offset = 0
+        self.type = 0
+        self.packetLen = 20 
+        self.headMatchCnt = 0
+        if self.model == AIDRONE:
+            self.head = (0x26, 0xA8, 0x14, 0xA0)
+        
+        
+    def findHeader(self, ch):
+        if self.headMatchCnt==3:
+            ch = ch&0xF0
+        if ch == self.head[self.headMatchCnt]:
+            self.headMatchCnt += 1
+        else:
+            self.headMatchCnt = 0
+        if self.headMatchCnt==4:
+            self.headMatchCnt = 0
+            self.offset = 4
+            self.packetLen = 20 
+            return True
+        else:
+            return False
+
+    def packetArrange(self, data):
+        for n in range(0, len(data)):
+            if self.findHeader(data[n]) == True:
+                self.type = data[n]&0x0F
+            elif self.offset>0:
+                self.packet[self.offset] = data[n]
+                if self.offset == 4:
+                    self.packetLen = data[n]
+                self.offset += 1
+            if self.offset == self.packetLen:
+                self.offset = 0
+                chksum = DefLib.checksum(self.packet)
+                if chksum == self.packet[5]:
+                    return self.packet
+        return "None"
+

pyaidrone-1.0.dist-info/METADATA

@@ -0,0 +1,10 @@
+Metadata-Version: 2.1
+Name: pyaidrone
+Version: 1.0
+Summary: Library for AIDrone Products
+Home-page: http://www.ir-brain.com
+Author: IR-Brain
+Author-email: ceo@ir-brain.com
+Requires-Dist: pyserial (>=3.4)
+Requires-Dist: pynput (>=1.7.3)
+

pyaidrone-1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+pyaidrone/AIDrone.py,sha256=p0-JQtpzmv_TCk1EY9lmkoa8JCJ43Q8ByBVwkgM0QOY,4562
+pyaidrone/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyaidrone/deflib.py,sha256=ZeA_qfnhuXEIhJHUMNSKkCkBEaWuoIS5X7ZqjTo9Sx4,735
+pyaidrone/ikeyevent.py,sha256=ZpRiFu71GhW2XQgyiXzCvb2FYoLU8bH4fVeaKoGEMqM,2866
+pyaidrone/packet.py,sha256=sA7v9MbptPVxCm1_Lah1vHnoeQdrWY87NH-C5CP4Gz8,810
+pyaidrone/parse.py,sha256=J8FOblxPhWw9VpovaBLgltkL7YVX0HXLZHTzH6519G8,1363
+pyaidrone-1.0.dist-info/METADATA,sha256=QBFVuZgu0Qa5Tc9UJadDQA31xLlaDI4jqmED0NE82KU,237
+pyaidrone-1.0.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+pyaidrone-1.0.dist-info/top_level.txt,sha256=YLnJwG3F2TdfFcg6r7jcx02fekcXHF_GC0nv12hJGT8,10
+pyaidrone-1.0.dist-info/RECORD,,

pyaidrone-1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pyaidrone-1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pyaidrone