Merge pull request #146 from cogip/145-add-sc-servo-driver-and-usage-example

Add SC Servo driver and usage example feature

Author: ecourtois

cogip/scservo_sdk/__init__.py

@@ -0,0 +1,8 @@
+#!/usr/bin/env python
+
+from .port_handler import *
+from .protocol_packet_handler import *
+from .group_sync_write import *
+from .group_sync_read import *
+from .sms_sts import *
+from .scscl import *

cogip/scservo_sdk/group_sync_read.py

@@ -0,0 +1,151 @@
+#!/usr/bin/env python
+
+from .scservo_def import *
+
+class GroupSyncRead:
+    def __init__(self, ph, start_address, data_length):
+        self.ph = ph
+        self.start_address = start_address
+        self.data_length = data_length
+
+        self.last_result = False
+        self.is_param_changed = False
+        self.param = []
+        self.data_dict = {}
+
+        self.clearParam()
+
+    def makeParam(self):
+        if not self.data_dict:  # len(self.data_dict.keys()) == 0:
+            return
+
+        self.param = []
+
+        for scs_id in self.data_dict:
+            self.param.append(scs_id)
+
+    def addParam(self, scs_id):
+        if scs_id in self.data_dict:  # scs_id already exist
+            return False
+
+        self.data_dict[scs_id] = []  # [0] * self.data_length
+
+        self.is_param_changed = True
+        return True
+
+    def removeParam(self, scs_id):
+        if scs_id not in self.data_dict:  # NOT exist
+            return
+
+        del self.data_dict[scs_id]
+
+        self.is_param_changed = True
+
+    def clearParam(self):
+        self.data_dict.clear()
+
+    def txPacket(self):
+        if len(self.data_dict.keys()) == 0:
+
+            return COMM_NOT_AVAILABLE
+
+        if self.is_param_changed is True or not self.param:
+            self.makeParam()
+
+        return self.ph.syncReadTx(self.start_address, self.data_length, self.param, len(self.data_dict.keys()))
+
+    def rxPacket(self):
+        self.last_result = True
+
+        result = COMM_RX_FAIL
+
+        if len(self.data_dict.keys()) == 0:
+            return COMM_NOT_AVAILABLE
+
+        result, rxpacket = self.ph.syncReadRx(self.data_length, len(self.data_dict.keys()))
+        # print(rxpacket)
+        if len(rxpacket) >= (self.data_length+6):
+            for scs_id in self.data_dict:
+                self.data_dict[scs_id], result = self.readRx(rxpacket, scs_id, self.data_length)
+                if result != COMM_SUCCESS:
+                    self.last_result = False
+                # print(scs_id)
+        else:
+            self.last_result = False
+        # print(self.last_result)
+        return result
+
+    def txRxPacket(self):
+        result = self.txPacket()
+        if result != COMM_SUCCESS:
+            return result
+
+        return self.rxPacket()
+
+    def readRx(self, rxpacket, scs_id, data_length):
+        # print(scs_id)
+        # print(rxpacket)
+        data = []
+        rx_length = len(rxpacket)
+        # print(rx_length)
+        rx_index = 0;
+        while (rx_index+6+data_length) <= rx_length:
+            headpacket = [0x00, 0x00, 0x00]
+            while rx_index < rx_length:
+                headpacket[2] = headpacket[1];
+                headpacket[1] = headpacket[0];
+                headpacket[0] = rxpacket[rx_index];
+                rx_index += 1
+                if (headpacket[2] == 0xFF) and (headpacket[1] == 0xFF) and headpacket[0] == scs_id:
+                    # print(rx_index)
+                    break
+            # print(rx_index+3+data_length)
+            if (rx_index+3+data_length) > rx_length:
+                break;
+            if rxpacket[rx_index] != (data_length+2):
+                rx_index += 1
+                # print(rx_index)
+                continue
+            rx_index += 1
+            Error = rxpacket[rx_index]
+            rx_index += 1
+            calSum = scs_id + (data_length+2) + Error
+            data = [Error]
+            data.extend(rxpacket[rx_index : rx_index+data_length])
+            for i in range(0, data_length):
+                calSum += rxpacket[rx_index]
+                rx_index += 1
+            calSum = ~calSum & 0xFF
+            # print(calSum)
+            if calSum != rxpacket[rx_index]:
+                return None, COMM_RX_CORRUPT
+            return data, COMM_SUCCESS 
+        # print(rx_index)
+        return None, COMM_RX_CORRUPT
+
+    def isAvailable(self, scs_id, address, data_length):
+        #if self.last_result is False or scs_id not in self.data_dict:
+        if scs_id not in self.data_dict:
+            return False, 0
+
+        if (address < self.start_address) or (self.start_address + self.data_length - data_length < address):
+            return False, 0
+        if not self.data_dict[scs_id]:
+            return False, 0
+        if len(self.data_dict[scs_id])<(data_length+1):
+            return False, 0
+        return True, self.data_dict[scs_id][0]
+
+    def getData(self, scs_id, address, data_length):
+        if data_length == 1:
+            return self.data_dict[scs_id][address-self.start_address+1]
+        elif data_length == 2:
+            return self.ph.scs_makeword(self.data_dict[scs_id][address-self.start_address+1],
+                                self.data_dict[scs_id][address-self.start_address+2])
+        elif data_length == 4:
+            return self.ph.scs_makedword(self.ph.scs_makeword(self.data_dict[scs_id][address-self.start_address+1],
+                                              self.data_dict[scs_id][address-self.start_address+2]),
+                                 self.ph.scs_makeword(self.data_dict[scs_id][address-self.start_address+3],
+                                              self.data_dict[scs_id][address-self.start_address+4]))
+        else:
+            return 0

cogip/scservo_sdk/group_sync_write.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env python
+
+from .scservo_def import *
+
+class GroupSyncWrite:
+    def __init__(self, ph, start_address, data_length):
+        self.ph = ph
+        self.start_address = start_address
+        self.data_length = data_length
+
+        self.is_param_changed = False
+        self.param = []
+        self.data_dict = {}
+
+        self.clearParam()
+
+    def makeParam(self):
+        if not self.data_dict:
+            return
+
+        self.param = []
+
+        for scs_id in self.data_dict:
+            if not self.data_dict[scs_id]:
+                return
+
+            self.param.append(scs_id)
+            self.param.extend(self.data_dict[scs_id])
+
+    def addParam(self, scs_id, data):
+        if scs_id in self.data_dict:  # scs_id already exist
+            return False
+
+        if len(data) > self.data_length:  # input data is longer than set
+            return False
+
+        self.data_dict[scs_id] = data
+
+        self.is_param_changed = True
+        return True
+
+    def removeParam(self, scs_id):
+        if scs_id not in self.data_dict:  # NOT exist
+            return
+
+        del self.data_dict[scs_id]
+
+        self.is_param_changed = True
+
+    def changeParam(self, scs_id, data):
+        if scs_id not in self.data_dict:  # NOT exist
+            return False
+
+        if len(data) > self.data_length:  # input data is longer than set
+            return False
+
+        self.data_dict[scs_id] = data
+
+        self.is_param_changed = True
+        return True
+
+    def clearParam(self):
+        self.data_dict.clear()
+
+    def txPacket(self):
+        if len(self.data_dict.keys()) == 0:
+            return COMM_NOT_AVAILABLE
+
+        if self.is_param_changed is True or not self.param:
+            self.makeParam()
+
+        return self.ph.syncWriteTxOnly(self.start_address, self.data_length, self.param,
+                                       len(self.data_dict.keys()) * (1 + self.data_length))

cogip/scservo_sdk/port_handler.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python
+
+import time
+import serial
+import sys
+import platform
+
+DEFAULT_BAUDRATE = 1000000
+LATENCY_TIMER = 50 
+
+class PortHandler(object):
+    def __init__(self, port_name):
+        self.is_open = False
+        self.baudrate = DEFAULT_BAUDRATE
+        self.packet_start_time = 0.0
+        self.packet_timeout = 0.0
+        self.tx_time_per_byte = 0.0
+
+        self.is_using = False
+        self.port_name = port_name
+        self.ser = None
+
+    def openPort(self):
+        return self.setBaudRate(self.baudrate)
+
+    def closePort(self):
+        self.ser.close()
+        self.is_open = False
+
+    def clearPort(self):
+        self.ser.flush()
+
+    def setPortName(self, port_name):
+        self.port_name = port_name
+
+    def getPortName(self):
+        return self.port_name
+
+    def setBaudRate(self, baudrate):
+        baud = self.getCFlagBaud(baudrate)
+
+        if baud <= 0:
+            # self.setupPort(38400)
+            # self.baudrate = baudrate
+            return False  # TODO: setCustomBaudrate(baudrate)
+        else:
+            self.baudrate = baudrate
+            return self.setupPort(baud)
+
+    def getBaudRate(self):
+        return self.baudrate
+
+    def getBytesAvailable(self):
+        return self.ser.in_waiting
+
+    def readPort(self, length):
+        if (sys.version_info > (3, 0)):
+            ret = self.ser.read(length)
+            return ret
+        else:
+            return [ord(ch) for ch in self.ser.read(length)]
+
+    def writePort(self, packet):
+        return self.ser.write(packet)
+
+    def setPacketTimeout(self, packet_length):
+        self.packet_start_time = self.getCurrentTime()
+        self.packet_timeout = (self.tx_time_per_byte * packet_length) + (self.tx_time_per_byte * 3.0) + LATENCY_TIMER
+
+    def setPacketTimeoutMillis(self, msec):
+        self.packet_start_time = self.getCurrentTime()
+        self.packet_timeout = msec
+
+    def isPacketTimeout(self):
+        if self.getTimeSinceStart() > self.packet_timeout:
+            self.packet_timeout = 0
+            return True
+
+        return False
+
+    def getCurrentTime(self):
+        return round(time.time() * 1000000000) / 1000000.0
+
+    def getTimeSinceStart(self):
+        time_since = self.getCurrentTime() - self.packet_start_time
+        if time_since < 0.0:
+            self.packet_start_time = self.getCurrentTime()
+
+        return time_since
+
+    def setupPort(self, cflag_baud):
+        if self.is_open:
+            self.closePort()
+
+        self.ser = serial.Serial(
+            port=self.port_name,
+            baudrate=self.baudrate,
+            # parity = serial.PARITY_ODD,
+            # stopbits = serial.STOPBITS_TWO,
+            bytesize=serial.EIGHTBITS,
+            timeout=0
+        )
+
+        self.is_open = True
+
+        self.ser.reset_input_buffer()
+
+        self.tx_time_per_byte = (1000.0 / self.baudrate) * 10.0
+
+        return True
+
+    def getCFlagBaud(self, baudrate):
+        if baudrate in [4800, 9600, 14400, 19200, 38400, 57600, 115200, 128000, 250000, 500000, 921600, 1000000]:
+            return baudrate
+        else:
+            return -1