ArduinoManager GUI update & specific protocol/connection exception

* Now the ArduinoManager windows allows to setup one reading for every pin
* Added specific protocol and connection expcetion for better error handling
* Forced a arduino protocol setup just before experiment start in order to check the board status and refresh the firmware setup on every experiment run.

Author: Marco-GG

MLC/GUI/Autogenerated/autogenerated.py

@@ -1191,11 +1191,14 @@
                </sizepolicy>
               </property>
               <property name="minimum">
-               <number>2</number>
+               <number>1</number>
               </property>
               <property name="maximum">
                <number>255</number>
               </property>
+              <property name="value">
+               <number>1</number>
+              </property>
              </widget>
             </item>
            </layout>

MLC/GUI/Autogenerated/mlc_qtcreator/board_config_design.ui

@@ -140,6 +140,28 @@ def closeEvent(self, event):
     def on_start_button_clicked(self):
 
         logger.debug('[EXPERIMENT {0}] [START_BUTTON] - Executing on_start_button_clicked function'.format(self._experiment_name))
+
+        try:
+            ArduinoInterfaceSingleton.get_instance(protocol_config=self._board_config,
+                                                   conn_setup=self._serial_conn._asdict())
+
+        except Exception, err:
+            logger.debug('[EXPERIMENT {0}] [BOARD_CONFIG] - '
+                         'Serial port could not be initialized. Error Msg: {1}'
+                         .format(self._experiment_name, err))
+            selection = QMessageBox.critical(self, "Connection failure",
+                                             "The current connection arduino setup failed during initialization "
+                                             "(Error: {0}), This may generate an error in your experiment.\n"
+                                             "Do you want to continue?".format(err),
+                                             QMessageBox.Yes | QMessageBox.No,
+                                             QMessageBox.Yes)
+            if selection == QMessageBox.No:
+                logger.debug('[EXPERIMENT {0}] [START_BUTTON] - Experiment cancelled by user before start'.format(
+                    self._experiment_name))
+                QMessageBox.information(self, "Check setup", "Please, open the arduino board configurator in order to "
+                                                             "analize and resolve the error.", QMessageBox.Ok)
+                return
+
         from_gen = int(self._autogenerated_object.from_gen_combo.currentText())
         to_gen = int(self._autogenerated_object.to_gen_combo.currentText())
         number_of_gens = self._mlc_local.get_experiment_info(self._experiment_name)["generations"]

MLC/GUI/Experiment/ExperimentWindow.py

@@ -17,8 +17,6 @@ void loop() {
   controller.handle_commands();
 
   /**
-   * 
-   * 
    * HERE the user can insert any command
    */
 

MLC/arduino/Firmware/Firmware.ino

@@ -19,6 +19,12 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>
 
+class ConnectionException(Exception):
+    pass
+
+class ConnectionTimeoutException(ConnectionException):
+    def __init__(self, what):
+        ConnectionException.__init__("Connection timeout: %s" % (what))
 
 class BaseConnection:
     '''

MLC/arduino/connection/base.py

@@ -19,10 +19,13 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>
 
-from base import BaseConnection
+from base import BaseConnection, ConnectionException, ConnectionTimeoutException
 from collections import namedtuple
 import serial
 
+class SerialConnectionException(ConnectionException):
+    def __init__(self, what):
+        ConnectionException.__init__("Error in connection initialization. {0}".format(what))
 
 class SerialConnection(BaseConnection):
 
@@ -35,9 +38,13 @@ def __init__(self, **args):
         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
+        
+        Raises:
+            SerialConnectionException: If the port could not be open or configured
+            ValueError: In case that port is not specified or if any of the parameters have errors
         """
         if "port" not in args.keys():
-            raise Exception("Port is mandatory!")
+            raise ValueError("Port is mandatory!")
 
         args["baudrate"] = 115200 if "baudrate" not in args.keys() else args["baudrate"]
         args["parity"] = serial.PARITY_NONE if "parity" not in args.keys() else args["parity"]
@@ -46,22 +53,43 @@ def __init__(self, **args):
         args["timeout"] = 5
         args["write_timeout"] = 5
 
-        self._connection = serial.Serial(**args)
+        self._timeout = args["timeout"]
+        self._write_timeout = args["write_timeout"]
+
+        try:
+            self._connection = serial.Serial(**args)
+        except SerialException, err:
+            raise SerialConnectionException(str(err))
 
     def send(self, data):
-        self._connection.write(data)
+        """
+        Sends data through serial connection
+        
+        Args:
+            data: Bytes to be send
+        
+        Raises:
+            ConnectionTimeoutException: If could not write all data through serial connection
+        """
+        try:
+            self._connection.write(data)
+        except serial.SerialTimeoutException, err:
+            raise ConnectionTimeoutException("write operation timeout after {0} seconds".format(self._write_timeout))
 
     def recv(self, length):
         """ Receives the specified amount of bytes
-        WARNING: This function is blocked until receive the amount of bytes
+        WARNING: This function will raise SerialTimeoutException if the recv bytes are not equals to expected bytes
 
         Keyword arguments:
         length -- amount of bytes to receive
+        
+        Raises:
+            ConnectionTimeoutException: In case that the "length" of bytes is not received
         """
         recv = self._connection.read(length)
 
         if len(recv) != length:
-            raise serial.SerialTimeoutException
+            raise ConnectionTimeoutException("timeout when receiving expected data")
         else:
             return recv
 

MLC/arduino/connection/serialconnection.py

@@ -41,6 +41,16 @@
 PIN_MODES = collections.namedtuple(
     'PIN_MODES', ['INPUT', 'OUTPUT'], verbose=False)(INPUT=0, OUTPUT=1)
 
+class ProtocolException(Exception):
+    pass
+
+class ProtocolIOException(ProtocolException):
+    def __init__(self,what):
+        ProtocolException.__init__(self, "Protocol IO error: %s" % (what))
+
+class ProtocolSetupException(ProtocolException):
+    def __init__(self, what):
+        ProtocolException.__init__(self, "Setup error: %s" % (what))
 
 class ArduinoInterfaceSingleton():
     _instance = None
@@ -53,16 +63,16 @@ def get_instance(protocol_config=None, conn_setup=None):
             serial_conn = None
             try:
                 serial_conn = SerialConnection(**conn_setup)
-            except Exception, err:
+            except ConnectionException, err:
                 lg.logger_.info("[PROTOCOL] Error while loading SerialConnection. "
-                                "Err msg: {0}".format(err))
+                                "Err info: {0}".format(err))
                 raise
 
             protocol_config = protocol_config._replace(connection=serial_conn)
             ArduinoInterfaceSingleton._instance = BuildSerial(protocol_config)
 
         if ArduinoInterfaceSingleton._instance is None:
-            raise Exception("ArduinoInterface was not configured.")
+            raise ValueError("ArduinoInterface was not configured.")
 
         return ArduinoInterfaceSingleton._instance
 
@@ -108,31 +118,31 @@ def get_version(self):
 
     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)
+            raise ProtocolSetupException("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)))
 
     def set_precision(self, bits):
         if bits > 32 or bits < 1:
-            raise Exception("Precision bits must be between 1 and 32!")
+            raise ValueError("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 PIN_MODES._asdict().values():
-            raise Exception("Pind mode error. Unknown mode: %s. Modes availables: %s " %
+            raise ValueError("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 REPORT_MODES._asdict().values():
-            raise Exception("Report mode error. Unknown value: %s" % mode)
+            raise ValueError("Report mode error. Unknown value: %s" % mode)
 
         if read_count <= 0:
-            raise Exception("Read count value must be > 0")
+            raise ValueError("Read count value must be > 0")
 
         self._report_mode = mode
         self._read_count = read_count - 1
@@ -143,7 +153,7 @@ def set_report_mode(self, mode, read_count=1, read_delay=0):
 
     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)
+            raise ProtocolSetupException("Pin %s is configured as output!" % port)
 
         self.__validate_pin(port)
 
@@ -161,7 +171,7 @@ def add_input(self, 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)
+            raise ProtocolSetupException("Port %s is configured as input!" % port)
 
         self.__validate_pin(port)
 
@@ -178,7 +188,7 @@ def add_output(self, port):
 
     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" %
+            raise ValueError("Invalid pin %s for board %s" %
                             (pin, self._board["NAME"]))
 
     def reset(self):
@@ -200,7 +210,7 @@ def actuate(self, data):
         # 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])
+                raise ProtocolSetupException("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)])
@@ -212,20 +222,21 @@ def actuate(self, data):
         self._connection.send(
             "".join([_PROTOCOL_CMDS["ACTUATE"], chr((size & 0xFF000000) >> 24), chr((size & 0x00FF0000) >> 16),
                      chr((size & 0x0000FF00) >> 8), chr(size & 0x000000FF), payload]))
-
+        #FIXME catch connection exceptions
         response = self._connection.recv(1)
 
         if response == _PROTOCOL_CMDS["ACK"]:
             response = self._connection.recv(4) # Clears buffer
-            raise Exception("Actuate error. Code: %s" % response)
+            raise ProtocolIOException("Actuate error. Code: %s" % response)
 
         if response != _PROTOCOL_CMDS["ACTUATE_REPORT"]:
             response = self._connection.recv(4)
-            raise Exception(
+            raise ProtocolIOException(
                 "Actuate error. Unknown response %s after actuate operation" % ord(response))
-
+        # FIXME catch connection exceptions
         raw_len = self._connection.recv(4)
         length = (ord(raw_len[0]) << 24) + (ord(raw_len[1]) << 16) + (ord(raw_len[2]) << 8) + ord(raw_len[3])
+        # FIXME catch connection exceptions
         data = self._connection.recv(length)
 
         pos = 0
@@ -261,8 +272,8 @@ def actuate(self, data):
                             (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 ProtocolIOException(
+                        "Unknown port \"%d\" in response. Please, restart the Arduino board and the experiment." % pin)
 
         return results
 
@@ -287,11 +298,9 @@ def __new__(cls, connection, report_mode=REPORT_MODES.AVERAGE, read_count=2, rea
 
 
 def BuildSerial(protocol_config):
-    interface = ArduinoInterface(
-        protocol_config.connection, protocol_config.board_type)
+    interface = ArduinoInterface(protocol_config.connection, protocol_config.board_type)
     interface.reset()
-    interface.set_report_mode(
-        protocol_config.report_mode, protocol_config.read_count, protocol_config.read_delay)
+    interface.set_report_mode(protocol_config.report_mode, protocol_config.read_count, protocol_config.read_delay)
 
     interface.set_precision(protocol_config.analog_resolution)
 
@@ -307,7 +316,6 @@ def BuildSerial(protocol_config):
     for port in protocol_config.analog_output_pins:
         interface.add_output(port)
 
-    # FIXME: Make this variable configurable
-    interface.set_precision(12)
+    interface.set_precision(protocol_config.analog_resolution)
 
     return interface

MLC/arduino/protocol.py

@@ -21,7 +21,7 @@
 
 import unittest
 from MLC.arduino.connection import MockConnection
-from MLC.arduino.protocol import ArduinoInterface
+from MLC.arduino.protocol import ArduinoInterface, ProtocolSetupException, ProtocolIOException
 from MLC.arduino.protocol import REPORT_MODES
 from MLC.arduino import boards
 
@@ -41,8 +41,8 @@ def test_set_precision(self):
         self._interface.set_precision(12)
         data = self._connection.pop_data()
         self.assertEqual("\x01\x00\x00\x00\x01\x0C", data)
-        with self.assertRaises(Exception):
-            self._interface.set_precition(33)
+        with self.assertRaises(ValueError):
+            self._interface.set_precision(33)
 
     def test_report_mode(self):
         self._interface.set_report_mode(REPORT_MODES.AVERAGE)
@@ -51,7 +51,7 @@ def test_report_mode(self):
         self._interface.set_report_mode(REPORT_MODES.AVERAGE, read_count=10, read_delay=5)
         data = self._connection.pop_data()
         self.assertEqual("\x05\x00\x00\x00\x03\x00\x09\x05", data)
-        with self.assertRaises(Exception):
+        with self.assertRaises(ValueError):
             self._interface.set_report_mode(12334)  # Invalid report mode
 
     def test_add_input(self):
@@ -63,7 +63,7 @@ def test_add_input(self):
         self._interface.add_input(60)
         with self.assertRaises(Exception):  # Checks that no data has been sent
             data = self._connection.pop_data()
-        with self.assertRaises(Exception):  # Checks that no data has been sent
+        with self.assertRaises(ValueError):  # Checks that no data has been sent
             self._interface.add_output(128)
 
     def test_add_output(self):
@@ -75,18 +75,18 @@ def test_add_output(self):
         self._interface.add_output(60)
         with self.assertRaises(Exception):  # Checks that no data has been sent
             data = self._connection.pop_data()
-        with self.assertRaises(Exception):  # Checks that no data has been sent
+        with self.assertRaises(ValueError):  # Checks that no data has been sent
             self._interface.add_output(128)
 
     def test_error_adding_output_that_is_input(self):
         self._interface.add_input(60)
-        with self.assertRaises(Exception):
-            self._interface.add_analog_output(60)
+        with self.assertRaises(ProtocolSetupException):
+            self._interface.add_output(60)
 
     def test_actuate_error_response(self):
         self._interface.add_output(60)
         self._connection.pop_data()
-        with self.assertRaises(Exception):
+        with self.assertRaises(ProtocolIOException):
             self._interface.actuate([(60, 128)])
 
     def test_actuate_with_one_read(self):