Issue: #22 -- Primera implementación del protocolo para Arduino

Agrego la clase base para manejar la comunicación junto con los conectores (solo se implemento comunicación serial y un mock). Falta pullir algunas cosas pero la mayor parte está.

Se agrega el controlador para el firmware de Arduino

Se agrega test unitario del conector (se articula con el mock)

Author: Marco-GG

MLC/arduino/connection/__init__.py

@@ -0,0 +1,6 @@
+
+from base import BaseConnection
+from serialconnection import SerialConnection
+from mockconnection import MockConnection
+
+__all__ = ["BaseConnection", "SerialConnection", "MockConnection" ]

MLC/arduino/connection/base.py

@@ -0,0 +1,14 @@
+
+class BaseConnection:
+    '''
+    Connection base class
+    
+    Defines method for I/O with an Arduino device
+    '''
+    def send(self,data):
+       """ Sends data to arduino device """
+       raise Exception("Implement me!")
+
+    def recv(self, length):
+       """ Receive data from the arduino device """
+       raise Exception("Implement me!") 

MLC/arduino/connection/ethernet.py

@@ -0,0 +1,34 @@
+from base import BaseConnection
+
+class MockConnection(BaseConnection):
+    """ Connection that save the data sent using "send" method and response 
+        on a "recv" call using a pre-configured response buffer
+    """
+    def __init__(self, responses):
+        """ response -- bytes stream of responses that will be used in recv method """
+        self._received = []
+        self._responses = responses
+        self._resp_idx = 0
+    
+    def send(self, data):
+        """ \"sends\" the data to a inner buffer """
+        self._received.insert(0,data)
+
+    def pop_data(self):
+        """ Pops a complete data stream received """
+        return self._received.pop()
+
+    def recv(self, length):
+        """
+        Looping receiver (if buffer run out of data, it add to the response bytes from the beginning)
+
+        length -- count of bytes to \"receive\"
+        """
+        pos = self._resp_idx
+        if pos + length > len(self._responses):
+            self._resp_idx = (length - (len(self._responses)-pos))%len(self._responses)
+            return self._responses[pos:] + self._responses[0:length - (len(self._responses)-pos)]
+
+        self._resp_idx = pos + length
+        return self._responses[pos:pos+length]
+

MLC/arduino/connection/mockconnection.py

@@ -0,0 +1,22 @@
+from base import BaseConnection
+import serial
+
+
+class SerialConnection(BaseConnection):
+    def __init__(self, **args):
+        if "port" not in args.keys():
+            raise Exception("Port is mandatory!")
+
+        args["baudrate"] = 115200 if not "baudrate" in args.keys() else args["baudrate"]
+        args["parity"] = serial.PARITY_NONE if not "parity" in args.keys() else args["parity"]
+        args["stopbits"] = serial.STOPBITS_ONE if not "stopbits" in args.keys() else args["stopbits"]
+        args["bytesize"] = serial.EIGHTBITS if not "bytesize" in args.keys() else args["bytesize"]
+        
+        self._connection = serial.Serial(**args); 
+        
+    
+    def send(self, data):
+        self._connection.write(data)
+
+    def recv(self, length):
+        return self._connection.read(length)

MLC/arduino/connection/serialconnection.py

@@ -0,0 +1,97 @@
+
+_PROTOCOL_CMDS = {  "ANALOG_PRECISION": '\x01\x01%s',
+                    "ANALOG_INPUT"    : '\x02\x01%s',
+                    "ANALOG_OUTPUT"   : '\x03\x01%s',
+                    "PIN_MODE"        : '\x04\x02%s%s',
+                    "REPORT_MODE"     : '\x05\x03%s%s%s',
+                    "ACK"             : '\xFF\x00',
+                    "ACTUATE"         : '\xF0%s',
+                    "ACTUATE_REPORT"  : '\xF1' }
+
+class ArduinoInterface:
+    PIN_MOD = {"INPUT":0, "OUTPUT":1} # 0=input 1=output -- wiring_constants.h
+    REPORT_MOD = {"AVERAGE":0, "BULK":1, "RT":2}
+
+    def __init__(self, connection):
+        self._connection = connection
+        self._anlg_inputs = []
+        self._anlg_outputs = []
+        self._anlg_precition = 10 #Default Arduino analog precition
+
+    def set_precition(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))
+        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(PIN_MOD.keys())))
+        
+        self._connection.send(_PROTOCOL_CMDS["PIN_MODE"] % (chr(port), chr(self.PIN_MOD[mode])))
+
+    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)
+        
+        self._connection.send(_PROTOCOL_CMDS["REPORT_MODE"] % (chr(self.REPORT_MOD[mode]), chr(read_count), chr(read_delay)))
+       
+    
+    def add_analog_input(self, port):
+        if port in self._anlg_outputs:
+            raise Exception("Port %s is configured as output!" % port)
+
+        if port not in self._anlg_inputs:
+            self._connection.send(_PROTOCOL_CMDS["ANALOG_INPUT"] % chr(port))
+            self._anlg_inputs.append(port)
+
+    def add_analog_output(self, port):
+        if port in self._anlg_inputs:
+            raise Exception("Port %s is configured as input!" % port)
+
+        if port not in self._anlg_outputs:
+            self._connection.send(_PROTOCOL_CMDS["ANALOG_OUTPUT"] % chr(port))
+            self._anlg_outputs.append(port)
+
+    def actuate(self, data):
+        """
+        Actuate over the input port sent as parameters
+        All the ports must has been configured as output!
+
+        arguments:
+        data -- port & value set to actuate
+        """
+        payload = ""
+        size = 0
+        #TODO: Ver como validar puertos digitales
+        for i in data:
+            if i[0] not in self._anlg_outputs:
+                raise Exception("Port %s not configured as output!" % i[0])
+            payload = "".join([payload, chr(i[0]), chr((i[1] & 0xFF00) >> 8), chr(i[1] & 0x00FF)])
+            size += 3 
+
+        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" % response)
+
+        length = ord(self._connection.recv(1))
+        data = self._connection.recv(length)
+
+        pos = 0
+        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:
+                results.append((data[pos], bool(ord(data[pos+1]))))
+                pos = pos + 2
+
+        return results
+        

MLC/arduino/protocol.py

@@ -0,0 +1,79 @@
+import unittest
+from MLC.arduino.connection import MockConnection
+from MLC.arduino.protocol import ArduinoInterface
+
+ACK = "\xFF\x00"
+NACK = "\xFF\x01"
+REPORT = "\xF1\x05\x10\x01\x3D\x05\x20"
+
+
+class TestArduinoInterface(unittest.TestCase):
+
+    def setUp(self):
+        self._connection = MockConnection(ACK)
+        self._interface = ArduinoInterface(self._connection)
+    
+    def test_set_precition(self):
+        self._interface.set_precition(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._interface.set_report_mode("AVERAGE", read_count=10, read_delay=5)
+        data = self._connection.pop_data()
+        self.assertEqual("\x05\x03\x00\x0A\x05", data)
+        with self.assertRaises(Exception):
+            self._interface.set_report_mode("SOMETHING")
+
+    def test_add_analog_input(self):
+        self._interface.add_analog_input(60)
+        data = self._connection.pop_data()
+        self.assertEqual("\x02\x01\x3C", data)
+        self._interface.add_analog_input(60)
+        with self.assertRaises(Exception):  # Checks that no data has been sent
+            data = self._connection.pop_data()
+
+    def test_add_analog_output(self):
+        self._interface.add_analog_output(60)
+        data = self._connection.pop_data()
+        self.assertEqual("\x03\x01\x3C", data)
+        self._interface.add_analog_output(60)
+        with self.assertRaises(Exception):  # Checks that no data has been sent
+            data = self._connection.pop_data()
+        
+    def test_error_adding_output_that_is_input(self):
+        self._interface.add_analog_input(60)
+        with self.assertRaises(Exception): 
+            self._interface.add_analog_output(60)
+             
+    def test_actuate_error_response(self):
+        self._interface.add_analog_output(60)
+        self._connection.pop_data()
+        with self.assertRaises(Exception): 
+            self._interface.actuate([(60, 128)])
+
+    def test_actuate(self):
+        self._connection = MockConnection(REPORT)
+        self._interface = ArduinoInterface(self._connection)
+        self._interface.add_analog_output(60)
+        self._interface.add_analog_input(61)
+        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])
+        
+