Added support to average and bulk reads in protocol

Issue #22

Author: Marco-GG

MLC/arduino/protocol.py

@@ -1,7 +1,7 @@
 
 _PROTOCOL_CMDS = {  "ANALOG_PRECISION": '\x01\x01%s',
-                    "SET_INPUT"    : '\x02\x01%s',
-                    "SET_OUTPUT"   : '\x03\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',
                     "ACK"             : '\xFF\x00',
@@ -21,11 +21,11 @@ def __init__(self, connection, board):
         self._digital_outputs = []
         self._anlg_precition = 10 #Default Arduino analog precision
         self._report_mode = "AVERAGE"
-        self._read_count = 1 #Default number of inputs read
+        self._read_count = 0 #Default number of inputs read
         self._read_delay = 0
         self._board = board
 
-    def set_precition(self, bits):
+    def set_precision(self, bits):
         if bits > 32 or bits < 1:
             raise Exception("Precision bits must be between 1 and 32!")
         self._connection.send(_PROTOCOL_CMDS["ANALOG_PRECISION"] % chr(bits))
@@ -37,53 +37,58 @@ def __set_pin_mode(self, port, mode):
 
         self._connection.send(_PROTOCOL_CMDS["PIN_MODE"] % (chr(port), chr(self.PIN_MOD[mode])))
 
-    def set_report_mode(self, mode, read_count=0, read_delay=0):
+    def set_report_mode(self, mode, read_count=1, read_delay=0):
         if mode not in self.REPORT_MOD.keys():
             raise Exception("Report mode error. Unknown value: %s" % mode)
 
+        if read_count <= 0:
+            raise Exception("Read count value must be >= 0")
+
         self._report_mode = mode
-        self._read_count = read_count + 1
+        self._read_count = read_count - 1
         self._read_delay = read_delay
 
-        self._connection.send(_PROTOCOL_CMDS["REPORT_MODE"] % (chr(self.REPORT_MOD[mode]), chr(read_count), chr(read_delay)))
+        self._connection.send(_PROTOCOL_CMDS["REPORT_MODE"] % (chr(self.REPORT_MOD[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)
-        self._connection.send(_PROTOCOL_CMDS["SET_INPUT"] % chr(port))
-        self.__set_pin_mode(port, "INPUT")
 
         # 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")
 
         # 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")
 
     def add_output(self, port):
         if port in self._anlg_inputs or port in self._digital_inputs:
             raise Exception("Port %s is configured as input!" % port)
 
         self.__validate_pin(port)
-        self._connection.send(_PROTOCOL_CMDS["SET_OUTPUT"] % chr(port))
-        self.__set_pin_mode(port, "OUTPUT")
 
         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")
 
         # 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")
 
     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"]))
-        return
 
     def reset(self):
         self._connection.send(_PROTOCOL_CMDS["RESET"])
@@ -124,16 +129,27 @@ def actuate(self, data):
         data = self._connection.recv(length)
 
         pos = 0
-        results = []
+        results = {x: [] for x in self._anlg_inputs + self._digital_inputs} # One dictionary to save all ports results
+
         while pos < length:
-            if ord(data[pos]) in self._anlg_inputs:
-                results.append((data[pos], (ord(data[pos+1]) << 8) + ord(data[pos+2])))
-                pos = pos + 3
-            else:
-                if ord(data[pos]) in self._digital_inputs:
-                    for i in range(0, self._read_count):
-                        results.append((data[pos], bool(ord(data[pos+1]))))
+            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]))
                     pos = pos + 2
+                pos = pos + 1
+
+                if self._report_mode == "AVERAGE":
+                    results[pin] = [sum(results[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]) & (0x80 >> (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) ]
+
                 else:
                     raise Exception("Unknown port in response. Restart Arduino board, your software and pray")
 

tests/mlc/arduino_protocol/test_protocol.py

@@ -5,7 +5,8 @@
 
 ACK = "\xFF\x00"
 NACK = "\xFF\x01"
-REPORT = "\xF1\x05\x10\x01\x3D\x05\x20"
+REPORT = "\xF1\x05\x10\x80\x3D\x05\x20"
+REPORT_B = "\xF1\x1A\x10\xF1\xA0\x3D\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00"
 
 
 class TestArduinoInterface(unittest.TestCase):
@@ -15,33 +16,28 @@ def setUp(self):
         self._interface = ArduinoInterface(self._connection, boards.Due)
 
     def test_set_precition(self):
-        self._interface.set_precition(12)
+        self._interface.set_precision(12)
         data = self._connection.pop_data()
         self.assertEqual("\x01\x01\x0C", data)
         with self.assertRaises(Exception):
             self._interface.set_precition(33)
 
-    def test_set_pin_mode(self):
-        self._interface.set_pin_mode(1, "INPUT")
-        data = self._connection.pop_data()
-        self.assertEqual("\x04\x02\x01\x00", data)
-        with self.assertRaises(Exception):
-            self._interface.set_pin_mode(1, "SOMETHING")
-        
     def test_report_mode(self):
         self._interface.set_report_mode("AVERAGE")
         data = self._connection.pop_data()
-        self.assertEqual("\x05\x03\x00\x01\x00", data)
+        self.assertEqual("\x05\x03\x00\x00\x00", data)
         self._interface.set_report_mode("AVERAGE", read_count=10, read_delay=5)
         data = self._connection.pop_data()
-        self.assertEqual("\x05\x03\x00\x0A\x05", data)
+        self.assertEqual("\x05\x03\x00\x09\x05", data)
         with self.assertRaises(Exception):
             self._interface.set_report_mode("SOMETHING")
 
     def test_add_input(self):
         self._interface.add_input(60)
         data = self._connection.pop_data()
-        self.assertEqual("\x02\x01\x06", data) # 6 = 60 - min(boards.Due["ANALOG_PINS"])
+        self.assertEqual("\x02\x01\x3C", data)
+        data = self._connection.pop_data()
+        self.assertEqual("\x04\x02\x3C\x00", data)
         self._interface.add_input(60)
         with self.assertRaises(Exception):  # Checks that no data has been sent
             data = self._connection.pop_data()
@@ -52,6 +48,8 @@ def test_add_output(self):
         self._interface.add_output(60)
         data = self._connection.pop_data()
         self.assertEqual("\x03\x01\x3C", data)
+        data = self._connection.pop_data()
+        self.assertEqual("\x04\x02\x3C\x01", data)
         self._interface.add_output(60)
         with self.assertRaises(Exception):  # Checks that no data has been sent
             data = self._connection.pop_data()
@@ -69,16 +67,48 @@ def test_actuate_error_response(self):
         with self.assertRaises(Exception): 
             self._interface.actuate([(60, 128)])
 
-    def test_actuate(self):
+    def test_actuate_with_one_read(self):
         self._connection = MockConnection(REPORT)
         self._interface = ArduinoInterface(self._connection, boards.Due)
         self._interface.add_output(60)
+        self._interface.add_input(16)
+        self._interface.add_input(61)
+        response = self._interface.actuate([(60, 128)])
+        self.assertEqual(1, len(response[0x10]))
+        self.assertTrue(response[0x10][0])
+        self.assertEqual(1, len(response[0x3D]))
+        self.assertEqual(0x0520,response[0x3D][0])
+        
+    def test_actuate_with_many_readings(self):
+        self._connection = MockConnection(REPORT_B)
+        self._interface = ArduinoInterface(self._connection, boards.Due)
+        self._interface.set_report_mode("BULK", read_count=11, read_delay=5)
+        self._interface.add_output(60)
+        self._interface.add_input(61)
+        self._interface.add_input(16)
+        response = self._interface.actuate([(60, 128)])
+        self.assertEqual(2, len(response))
+        self.assertTrue(response[0x10][0])
+        self.assertFalse(response[0x10][6])
+        self.assertTrue(response[0x10][7])
+        self.assertTrue(response[0x10][8])
+        self.assertFalse(response[0x10][9])
+        self.assertTrue(response[0x10][10])
+        for i in range(0, 11):
+           self.assertEqual(0x0100, response[0x3D][i])
+
+
+    def test_average(self):
+        self._connection = MockConnection(REPORT_B)
+        self._interface = ArduinoInterface(self._connection, boards.Due)
+        self._interface.set_report_mode("AVERAGE", read_count=11, read_delay=5)
+        self._interface.add_output(60)
         self._interface.add_input(61)
+        self._interface.add_input(16)
         response = self._interface.actuate([(60, 128)])
         self.assertEqual(2, len(response))
-        self.assertEqual("\x10",response[0][0])
-        self.assertTrue(response[0][1])
-        self.assertEqual("\x3D",response[1][0])
-        self.assertEqual(0x0520,response[1][1])
+        self.assertEqual(1, len(response[0x10]))
+        self.assertTrue(response[0x10][0])
+        self.assertEqual(0x0100, response[0x3D][0])