Protocol actuate output modified

The actuate method now returns a dictionary with values on keys with names as "D%d" or "A%d" (D for digital and A for analog)

Added constant collection for report mode selection

Author: Marco-GG

MLC/arduino/protocol.py

@@ -1,35 +1,39 @@
+import collections
 
-_PROTOCOL_CMDS = {  "ANALOG_PRECISION": '\x01\x01%s',
-                    "SET_INPUT"       : '\x02\x01%s',
-                    "SET_OUTPUT"      : '\x03\x01%s',
-                    "PIN_MODE"        : '\x04\x02%s%s',
-                    "REPORT_MODE"     : '\x05\x03%s%s%s',
-                    "ANALOG_WRITE"    : '\x06\x03%s%s%s',
-                    "ACK"             : '\xFF\x00',
-                    "ACTUATE"         : '\xF0',
-                    "PROT_VERSION"    : '\xF2\x00',
-                    "RESET"           : '\xFE',
-                    "ACTUATE_REPORT"  : '\xF1' }
+_PROTOCOL_CMDS = {"ANALOG_PRECISION": '\x01\x01%s',
+                  "SET_INPUT": '\x02\x01%s',
+                  "SET_OUTPUT": '\x03\x01%s',
+                  "PIN_MODE": '\x04\x02%s%s',
+                  "REPORT_MODE": '\x05\x03%s%s%s',
+                  "ANALOG_WRITE": '\x06\x03%s%s%s',
+                  "ACK": '\xFF\x00',
+                  "ACTUATE": '\xF0',
+                  "PROT_VERSION": '\xF2\x00',
+                  "RESET": '\xFE',
+                  "ACTUATE_REPORT": '\xF1'}
+
+
+PIN_MODES=collections.namedtuple('PIN', ['AVERAGE', 'BULK', 'RT'], verbose=False)(AVERAGE=0, BULK=1, RT=2)
+REPORT_MODES=collections.namedtuple('REPORT', ['INPUT', 'OUTPUT'], verbose=False)(INPUT=0, OUTPUT=1)
 
 class ArduinoInterface:
-    PIN_MOD = {"INPUT":0, "OUTPUT":1} # 0=input 1=output -- wiring_constants.h
-    REPORT_MOD = {"AVERAGE":0, "BULK":1, "RT":2}
+    # 0=input 1=output -- wiring_constants.h
 
     def __init__(self, connection, board):
         self._connection = connection
         self._anlg_inputs = []
         self._digital_inputs = []
         self._anlg_outputs = []
         self._digital_outputs = []
-        self._anlg_precition = 10 #Default Arduino analog precision
-        self._report_mode = "AVERAGE"
-        self._read_count = 0 #Default number of inputs read
+        self._anlg_precition = 10  # Default Arduino analog precision
+        self._report_mode = PIN_MODES.AVERAGE
+        self._read_count = 0  # Default number of inputs read
         self._read_delay = 0
         self._board = board
 
     def get_analog_inputs(self):
         return self._anlg_inputs()
-   
+
     def get_digital_inputs(self):
         return self._digital_inputs
 
@@ -55,7 +59,8 @@ def set_pwm(self, pin, duty_cicle):
         if port in self._anlg_inputs or port in self._digital_inputs:
             raise Exception("Port %s is configured as input!" % port)
 
-        self._connection.send(_PROTOCOL_CMDS["ANALAOG_WRITE"] % (chr(pin), chr((duty_cicle & 0xFF00) >> 8), chr(duty_cicle & 0x00FF)))
+        self._connection.send(_PROTOCOL_CMDS["ANALAOG_WRITE"] % (
+            chr(pin), chr((duty_cicle & 0xFF00) >> 8), chr(duty_cicle & 0x00FF)))
 
     def set_precision(self, bits):
         if bits > 32 or bits < 1:
@@ -64,13 +69,15 @@ def set_precision(self, bits):
         self._anlg_precition = bits
 
     def __set_pin_mode(self, port, mode):
-        if mode not in self.PIN_MOD.keys():
-            raise Exception("Pind mode error. Unknown mode: %s. Modes availables: %s " % (mode, str(self.PIN_MOD.keys())))
-        
-        self._connection.send(_PROTOCOL_CMDS["PIN_MODE"] % (chr(port), chr(self.PIN_MOD[mode])))
+        if mode not in PIN_MODES._asdict().values():
+            raise Exception("Pind mode error. Unknown mode: %s. Modes availables: %s " %
+                            (mode, str(PIN_MODES_asdict().keys())))
+
+        self._connection.send(
+            _PROTOCOL_CMDS["PIN_MODE"] % (chr(port), chr(mode)))
 
     def set_report_mode(self, mode, read_count=1, read_delay=0):
-        if mode not in self.REPORT_MOD.keys():
+        if mode not in REPORT_MODES._asdict().values():
             raise Exception("Report mode error. Unknown value: %s" % mode)
 
         if read_count <= 0:
@@ -79,27 +86,27 @@ def set_report_mode(self, mode, read_count=1, read_delay=0):
         self._report_mode = mode
         self._read_count = read_count - 1
         self._read_delay = read_delay
-        
-        self._connection.send(_PROTOCOL_CMDS["REPORT_MODE"] % (chr(self.REPORT_MOD[mode]), chr(self._read_count), chr(self._read_delay)))
-  
-    
+
+        self._connection.send(_PROTOCOL_CMDS["REPORT_MODE"] % (
+            chr(self._report_mode), chr(self._read_count), chr(self._read_delay)))
+
     def add_input(self, port):
         if port in self._anlg_outputs or port in self._digital_outputs:
             raise Exception("Pin %s is configured as output!" % port)
-   
+
         self.__validate_pin(port)
 
         # Determines if we are setting as input an analog port
         if port not in self._anlg_inputs and port in self._board["ANALOG_PINS"]:
             self._anlg_inputs.append(port)
             self._connection.send(_PROTOCOL_CMDS["SET_INPUT"] % chr(port))
-            self.__set_pin_mode(port, "INPUT")
+            self.__set_pin_mode(port, REPORT_MODES.INPUT)
 
         # Determines if we are setting as input a Digital port
         if port not in self._digital_inputs and port in self._board["DIGITAL_PINS"]:
             self._digital_inputs.append(port)
             self._connection.send(_PROTOCOL_CMDS["SET_INPUT"] % chr(port))
-            self.__set_pin_mode(port, "INPUT")
+            self.__set_pin_mode(port, REPORT_MODES.INPUT)
 
     def add_output(self, port):
         if port in self._anlg_inputs or port in self._digital_inputs:
@@ -110,18 +117,19 @@ def add_output(self, port):
         if port not in self._anlg_outputs and port in self._board["ANALOG_PINS"]:
             self._anlg_outputs.append(port)
             self._connection.send(_PROTOCOL_CMDS["SET_OUTPUT"] % chr(port))
-            self.__set_pin_mode(port, "OUTPUT")
+            self.__set_pin_mode(port, REPORT_MODES.OUTPUT)
 
         # Determines if we are setting as input a Digital port
         if port not in self._digital_outputs and port in self._board["DIGITAL_PINS"]:
             self._digital_outputs.append(port)
             self._connection.send(_PROTOCOL_CMDS["SET_OUTPUT"] % chr(port))
-            self.__set_pin_mode(port, "OUTPUT")
+            self.__set_pin_mode(port, REPORT_MODES.OUTPUT)
 
     def __validate_pin(self, pin):
         if pin not in self._board["DIGITAL_PINS"] and pin not in self._board["ANALOG_PINS"]:
-            raise Exception("Invalid pin %s for board %s" % (pin, self._board["NAME"]))
-  
+            raise Exception("Invalid pin %s for board %s" %
+                            (pin, self._board["NAME"]))
+
     def reset(self):
         self._connection.send(_PROTOCOL_CMDS["RESET"])
         self._anlg_outputs = []
@@ -143,49 +151,62 @@ def actuate(self, data):
             if i[0] not in self._anlg_outputs and i[0] not in self._digital_outputs:
                 raise Exception("Port %s not configured as output!" % i[0])
             if i[0] in self._anlg_outputs:
-                payload = "".join([payload, chr(i[0]), chr((i[1] & 0xFF00) >> 8), chr(i[1] & 0x00FF)])
+                payload = "".join(
+                    [payload, chr(i[0]), chr((i[1] & 0xFF00) >> 8), chr(i[1] & 0x00FF)])
                 size += 3
             if i[0] in self._digital_outputs:
                 payload = "".join([payload, chr(i[0]), chr(i[1])])
                 size += 2
 
-        self._connection.send("".join([_PROTOCOL_CMDS["ACTUATE"], chr(size), payload]))
+        self._connection.send(
+            "".join([_PROTOCOL_CMDS["ACTUATE"], chr(size), payload]))
         response = self._connection.recv(1)
 
         if response == _PROTOCOL_CMDS["ACK"]:
             response = self._connection.recv(1)
             raise Exception("Actuate error. Code: %s" % response)
 
-        if response <> _PROTOCOL_CMDS["ACTUATE_REPORT"]:
-            raise Exception("Actuate error. Unknown response %s after actuate operation" % ord(response))
+        if response != _PROTOCOL_CMDS["ACTUATE_REPORT"]:
+            raise Exception(
+                "Actuate error. Unknown response %s after actuate operation" % ord(response))
 
         length = ord(self._connection.recv(1))
         data = self._connection.recv(length)
 
         pos = 0
-        results = {x: [] for x in self._anlg_inputs + self._digital_inputs} # One dictionary to save all ports results
+        digital_res = {"D%d" % (x): [] for x in self._digital_inputs}
+        analog_res = {"A%d" % (x): [] for x in self._anlg_inputs}
+        # results = {x: []
+        # for x in self._anlg_inputs + self._digital_inputs}  # One dictionary
+        # to save all ports results
+
+        results = dict(digital_res.items() + analog_res.items())
 
         while pos < length:
             pin = ord(data[pos])
             if pin in self._anlg_inputs:
                 for i in range(0, self._read_count + 1):
-                    results[pin].append((ord(data[pos+1]) << 8) + ord(data[pos+2]))
+                    results["A%d" % (pin)].append(
+                        (ord(data[pos + 1]) << 8) + ord(data[pos + 2]))
                     pos = pos + 2
                 pos = pos + 1
 
                 if self._report_mode == "AVERAGE":
-                    results[pin] = [sum(results[pin]) / (self._read_count + 1)]
+                    results["A%d" % (pin)] = [
+                        sum(results["A%d" % (pin)]) / (self._read_count + 1)]
             else:
                 if pin in self._digital_inputs:
                     for i in range(0, self._read_count + 1):
-                        results[pin].append(bool(ord(data[pos + 1 + i/8]) & (0x01 << (i % 8))))
-                    pos = pos + 1 + self._read_count/8 + 1
+                        results["D%d" % (pin)].append(
+                            bool(ord(data[pos + 1 + i / 8]) & (0x01 << (i % 8))))
+                    pos = pos + 1 + self._read_count / 8 + 1
 
                     if self._report_mode == "AVERAGE":
-                        results[pin] = [ (sum(results[pin]) * 2) > (self._read_count + 1) ]
+                        results["D%d" % (pin)] = [
+                            (sum(results["D%d" % (pin)]) * 2) > (self._read_count + 1)]
 
                 else:
-                    raise Exception("Unknown port \"%d\" in response. Restart Arduino board, your software and pray" % pin)
+                    raise Exception(
+                        "Unknown port \"%d\" in response. Restart Arduino board, your software and pray" % pin)
 
         return results
-        

tests/pocs/performance_test.py

@@ -1,16 +1,22 @@
 #from MLC.arduino.connection import MockConnection
 from MLC.arduino.connection import SerialConnection
+import MLC.arduino.protocol as protocol
 from MLC.arduino.protocol import ArduinoInterface
 from MLC.arduino import boards
+import MLC.arduino 
 import sys
 import time
 
+
+BREAK_COUNT=20000
+
 def actuate(terminal):
+    global BREAK_COUNT
     connection = SerialConnection(port=terminal)
     arduinoDue = ArduinoInterface(connection, boards.Due)
 
     arduinoDue.reset() #Just in case
-    arduinoDue.set_report_mode("AVERAGE", read_count=1, read_delay=200)
+    arduinoDue.set_report_mode(protocol.PIN_MODES.AVERAGE, read_count=5, read_delay=0)
 
     arduinoDue.add_output(40)
     arduinoDue.add_output(66)
@@ -26,12 +32,13 @@ def actuate(terminal):
 #    arduinoDue.add_input(56)
 #    arduinoDue.add_input(55)
     arduinoDue.add_input(54)
+    arduinoDue.add_input(55)
 
     last_time = time.time()
     start_time = last_time
     read_c = 0
 
-    for i in xrange(0, 2):
+    for i in xrange(0, BREAK_COUNT):
         output = arduinoDue.actuate([(40,1),(66,255)])
         #print output
         read_c = read_c + 1

tests/pocs/test_connection.py

@@ -10,7 +10,7 @@ def actuate(terminal):
     arduinoDue = ArduinoInterface(connection, boards.Due)
 
     arduinoDue.reset()
-#    arduinoDue.set_report_mode("BULK", read_count=5, read_delay=200)    
+    arduinoDue.set_report_mode("BULK", read_count=5, read_delay=100)    
     arduinoDue.add_output(40)
     arduinoDue.add_input(64)
     arduinoDue.add_input(63)