Issue #22: Fix en envío de envio y recepción de datos en arduino

Se arreglan bug en el firmware que no permitia la ejecución de varios comandos consecutivos (i.e. más de un comando en el buffer de entrada)

Se arregla bug que asignaba como puerto analógico a un puerto digital.

Author: Marco-GG

MLC/arduino/Firmware/Firmware.ino

@@ -14,12 +14,12 @@ const uint8_t SET_REPORT_MODE_CMD   = 0x05;
 const uint8_t ACTUATE_CMD           = 0xF0;
 
 // Commands executor caller -- one vector position == one command
-void (*executor[255])(const char*);
+int (*executor[255])(const char*);
 
-void not_implemented(const char* data)
+int not_implemented(const char* data)
 {
   //nothing to do...
-  return;
+  return 0;
 }
 
 typedef enum ReportModes {average, bulk, rt};
@@ -39,7 +39,7 @@ const char* ACK = "\xFF\x00";
 /**
    ANALOG_PRECISION: 0x01 0x01 [BITS]
 */
-void set_analog_precision(const char* data)
+int set_analog_precision(const char* data)
 {
   int i = byte(data[2]);
   // Tal vez conviene separar estas funciones ya que hay boards con resoluciones distintas...
@@ -48,55 +48,67 @@ void set_analog_precision(const char* data)
   analogReadResolution(i);
 
   LOG("Resolution changed to: ", i);
+
+  return 3; // Command of 3 bytes
 }
 
 /**
    PIN_MODE: 0x04 0x02 [PIN] [MODE]
 */
-void set_pin_mode(const char* data)
+int set_pin_mode(const char* data)
 {
   pinMode(data[2], data[3]);
   LOG("Changed pin mode on pin ", uint8_t(data[2]));
   LOG("Mode set to ", uint8_t(data[3]));
+
+  return 4; // Command of 4 bytes
 }
 
 /**
    REPORT_MODE: 0x05 0x03 [MODE] [READ_COUNT] [READ_DELAY]
 */
-void set_report_mode(const char* data)
+int set_report_mode(const char* data)
 {
   REPORT_MODE = (ReportModes)(data[2]);
   REPORT_READ_COUNT = byte(data[3]);
   REPORT_READ_DELAY = byte(data[4]);
   LOG("Report mode changed on port ", byte(data[3]));
+
+  return 5; // Command of 5 bytes
 }
 
 /**
    ANALOG_INPUT: 0x02 0x01 [PORT]
 */
-void set_analog_input(const char* data)
+int set_analog_input(const char* data)
 {
   INPUT_PORTS[0] += 1;
   INPUT_PORTS[INPUT_PORTS[0]] = byte(data[2]);
   LOG("New analog input: ", byte(data[2]));
+
+  return 3; // Command of 3 bytes
 }
 
 /**
  * ANALOG_OUTPUT: 0x03 0x01 [PORT]
  */
-void set_analog_output(const char* data)
+int set_analog_output(const char* data)
 {
   // No se si vale la pena guardar registro de pines de salida...
+
+  return 3; // Command of 3 bytes
 }
 
 /**
- * ACTUATE: 0xF0 [PIN_COUNT] [PIN_A] [VALUE_PIN_A] ... [PIN_N] [VALUE_PIN_N]
+ * ACTUATE: 0xF0 [DATA_LEN] [PIN_A] [VALUE_PIN_A] ... [PIN_N] [VALUE_PIN_N]
  */
-void actuate(const char* data)
+int actuate(const char* data)
 {
   int offset = 0;
   int byte_count = byte(data[1]); // Un byte puede llegar a limitar la cantidad de salidas... creo
 
+  LOG("Actutating over payload of size: ", byte_count);
+
   // ACTUATION ZONE
   while (offset < byte_count)
   {
@@ -130,7 +142,7 @@ void actuate(const char* data)
   {
     if ( INPUT_PORTS[i] >= A0 )
     {
-      int data = analogRead(INPUT_PORTS[i]);
+      int data = analogRead(INPUT_PORTS[i]-A0);
       response[len + 1] = byte((data & 0xFF00) >> 8); // Se guarda el msb en el buffer
       response[len + 2] = byte(data & 0xFF);        // Se guarda el lsb en el buffer
 
@@ -148,13 +160,15 @@ void actuate(const char* data)
 
   response[1] = len - 1;
   SerialUSB.write(response, len + 2); // 2 bytes extras por el id de comando y la longitud
+
+  return offset + 2;
 }
 
 void setup() {
   SerialUSB.begin(115200);
 
   #ifdef DEBUG
-  Serial.begin(57600);
+  Serial.begin(115200);
   #endif
 
   for (int i = 0; i < 255; i++)
@@ -172,29 +186,30 @@ void setup() {
   executor[SET_REPORT_MODE_CMD]   = &set_report_mode;
   executor[ACTUATE_CMD]           = &actuate;
 
-  executor[ANALOG_PRECISION_CMD]("\x01\x01\x12");
-  executor[ADD_INPUT_PORT_CMD]("\x02\x01\x37"); // Configura a A1 como lectura
-  executor[ADD_INPUT_PORT_CMD]("\x02\x01\x38"); // Configura a A2 como lectura
-  executor[SET_PIN_MODE_CMD]("\x04\x02\x28\x01");
-  executor[SET_PIN_MODE_CMD]("\x04\x02\x55\x00");
-
 }
 
 void loop() {
-  LOG("Escribiendo...", " ");
-  executor[ACTUATE_CMD]("\xF0\x01\x28\x01");
+  //executor[ACTUATE_CMD]("\xF0\x01\x28\x01");
 
   if (SerialUSB.available() > 0)
   {
+    LOG("USB serial data available ", SerialUSB.available());
     char input[64]; // Esto se reserva en el stack, tal vez hacerlo global consume menos recursos...
-
+    
+    byte b_read = 0;
+    byte b_pos = 0;
+    
     while (SerialUSB.available() > 0)
     {
-      SerialUSB.readBytes(input, SerialUSB.available());
+      b_read += SerialUSB.readBytes(input, SerialUSB.available());
+    }
+    
+    // Loop to process all commands received in the buffer
+    while(b_pos < b_read)
+    {
+      LOG("Executing command: ", int(input[b_pos]));
+      b_pos += executor[input[b_pos]](&input[b_pos]); // Does the callback for the command
+      LOG("b_pos ", b_pos);
     }
-
-    executor[input[0]](input); // Does the callback for the command
   }
-
-  delay(5000);
 }

MLC/arduino/connection/serialconnection.py

@@ -4,6 +4,15 @@
 
 class SerialConnection(BaseConnection):
     def __init__(self, **args):
+        """ Starts a serial connection 
+
+        Keyword arguments:
+        port -- connection to the device. In Linux: /dev/ttyXXX On Windows: COMX. This options is mandatory!
+        baudrates -- baurates of the connection. By default will be set to 115200
+        parity -- parity check bits from pySerial. By default it is set to PARITY_ONE. Available options: PARITY_EVEN, PARITY_ODD, PARITY_MARK & PARITY_SPACE
+        stopbits -- stop bits from pySerial. By default it is set to STOPBITS_ONE. Available options: STOPBITS_ONE_POINT_FIVE & STOPBITS_TWO
+        bytesize -- byte size from pySerial. By default it is set to EIGHTBITS. Available options: FIVEBITS, SIXBITS & SEVENBITS 
+        """
         if "port" not in args.keys():
             raise Exception("Port is mandatory!")
 
@@ -19,4 +28,10 @@ def send(self, data):
         self._connection.write(data)
 
     def recv(self, length):
+        """ Receives the specified amount of bytes
+        WARNING: This function is blocked until receive the amount of bytes
+        
+        Keyword arguments:
+        length -- amount of bytes to receive
+        """
         return self._connection.read(length)

MLC/arduino/protocol.py

@@ -1,11 +1,11 @@
 
 _PROTOCOL_CMDS = {  "ANALOG_PRECISION": '\x01\x01%s',
                     "SET_INPUT"    : '\x02\x01%s',
-                    "PIN_OUTPUT"   : '\x03\x01%s',
+                    "SET_OUTPUT"   : '\x03\x01%s',
                     "PIN_MODE"        : '\x04\x02%s%s',
                     "REPORT_MODE"     : '\x05\x03%s%s%s',
                     "ACK"             : '\xFF\x00',
-                    "ACTUATE"         : '\xF0%s',
+                    "ACTUATE"         : '\xF0',
                     "ACTUATE_REPORT"  : '\xF1' }
 
 class ArduinoInterface:
@@ -27,9 +27,9 @@ def set_precition(self, bits):
         self._connection.send(_PROTOCOL_CMDS["ANALOG_PRECISION"] % chr(bits))
         self._anlg_precition = bits
 
-    def set_pin_mode(self, port, mode):
+    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())))
+            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])))
 
@@ -44,36 +44,35 @@ 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.__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"]:
-            # The "analogRead" arduino function maps the ADC pins not by their base pin number but from their relative ADC pin number
-            self._connection.send(_PROTOCOL_CMDS["SET_INPUT"] % chr(port - min(self._board["ANALOG_PINS"])))
             self._anlg_inputs.append(port)
 
         # 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._connection.send(_PROTOCOL_CMDS["SET_INPUT"] % chr(port))
             self._digital_inputs.append(port)
 
 
     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.__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:
-            self._connection.send(_PROTOCOL_CMDS["PIN_OUTPUT"] % chr(port))
+        if port not in self._anlg_outputs and port in self._board["ANALOG_PINS"]:
             self._anlg_outputs.append(port)
 
         # 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._connection.send(_PROTOCOL_CMDS["PIN_OUTPUT"] % chr(port))
             self._digital_outputs.append(port)
 
-    def _validate_pin(self, pin):
+    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
@@ -88,7 +87,8 @@ def actuate(self, data):
         """
         payload = ""
         size = 0
-        #TODO: Ver como validar puertos digitales
+
+        # Sets as payload every digital or analog port
         for i in 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])
@@ -119,8 +119,11 @@ def actuate(self, data):
                 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
+                if ord(data[pos]) in self._digital_inputs:
+                    results.append((data[pos], bool(ord(data[pos+1]))))
+                    pos = pos + 2
+                else:
+                    raise Exception("Unknown port in response. Restart Arduino board, your software and pray")
 
         return results