Merge branch 'arduino_manager_refactor'

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

@@ -28,6 +28,7 @@
 from MLC.arduino import boards
 from MLC.arduino.connection.serialconnection import SerialConnection, SerialConnectionConfig
 from MLC.arduino.protocol import ProtocolConfig, BuildSerial
+from MLC.arduino.connection.base import ConnectionException, ConnectionTimeoutException
 
 from PyQt5.QtWidgets import QMessageBox
 from PyQt5.QtCore import QTimer
@@ -150,10 +151,12 @@ def conn_check(self):
             arduino_if = BuildSerial(config)
             version = arduino_if.get_version()
             self.__connection_status.set_ok()
-        except serial.SerialTimeoutException:
+        except ConnectionTimeoutException:
             self.__connection_status.set_error("Error: connection timeout")
-        except serial.SerialException:
+        except ConnectionException:
             self.__connection_status.set_error("Error: Board unreachable")
+        except ValueError, err:
+            self.__connection_status.set_error("Error: {0}".format(err))
 
     def board_changed(self, new_idx, old_idx):
         ret = QMessageBox.Yes
@@ -180,7 +183,7 @@ def board_changed(self, new_idx, old_idx):
     def start_bench(self):
         try:
             self.__setup = self.__setup._replace(connection=self.start_connection(), **self.__main_window.checkout_board_setup())
-        except serial.SerialException:
+        except SerialConnectionException:
             self.show_error(
                 "Error", "Connection failure", "Could not start connection to board", QMessageBox.Critical, QMessageBox.Ok)
             return

MLC/GUI/Experiment/ArduinoConfigManager/ArduinoBoardManager.py

@@ -32,6 +32,7 @@
 from MLC.Application import MLC_CALLBACKS
 from MLC.GUI.Autogenerated.autogenerated import Ui_ExperimentInProgressWindow
 from MLC.GUI.Experiment.QtCharts.QtChartWrapper import QtChartWrapper
+from MLC.arduino.protocol import ProtocolIOException, ProtocolSetupException
 from MLC.Log.log import get_gui_logger
 
 from PyQt5.QtCore import pyqtSignal
@@ -59,6 +60,7 @@ def __init__(self):
         self._condition = Condition()
         self._experiment_stopped = False
         self._experiment_cancelled = False
+        self._experiment_failure = False
 
     def stop_experiment(self):
         self._condition.acquire()
@@ -78,6 +80,12 @@ def cancel_experiment(self):
         self._condition.notify()
         self._condition.release()
 
+    def fail_experiment(self):
+        self._condition.acquire()
+        self._experiment_failure = True
+        self._condition.notify()
+        self._condition.release()
+
     def wait_if_experiment_stopped(self):
         had_to_wait = False
         self._condition.acquire()
@@ -94,11 +102,19 @@ def experiment_cancelled(self):
         self._condition.release()
         return cancelled
 
+    def experiment_failure(self):
+        self._condition.acquire()
+        failure = self._experiment_failure
+        self._condition.release()
+        return failure
+
 
 class ExperimentInProgressWindow(QMainWindow):
     indiv_evaluated = pyqtSignal([int, int, int, float])
     new_generation = pyqtSignal()
     simulation_finished = pyqtSignal()
+    board_setup_failure = pyqtSignal([str])
+    board_io_error = pyqtSignal([str])
 
     def __init__(self, parent, parent_signal, chart_params, from_gen, to_gen):
         QMainWindow.__init__(self, parent)
@@ -115,6 +131,8 @@ def __init__(self, parent, parent_signal, chart_params, from_gen, to_gen):
         self.indiv_evaluated.connect(self._update_dialog)
         self.simulation_finished.connect(self._simulation_finished)
         self.new_generation.connect(self._create_new_chart)
+        self.board_setup_failure.connect(self._board_setup_failure)
+        self.board_io_error.connect(self._board_io_error)
 
         # Signal to be emited when the experiment finished
         self._parent_signal = parent_signal
@@ -172,7 +190,8 @@ def _update_dialog(self, indivs_per_gen_counter, total_indivs_counter, gen_count
 
     def _simulation_finished(self):
         logger.debug('{0} [SIM_FINISHED] - Executing _simulation_finished function'.format(self._log_prefix))
-        self._parent_signal.emit(self._experiment_condition.experiment_cancelled())
+        self._parent_signal.emit(self._experiment_condition.experiment_cancelled(),
+                                 self._experiment_condition.experiment_failure())
 
     def _update_current_gen_experiment(self, indiv_index, cost):
         if cost > self._chart_params["max_cost"]:
@@ -227,6 +246,21 @@ def _create_new_chart(self):
         picture_layout.addWidget(indiv_canvas)
         self._indiv_chart = indiv_chart
 
+    def _board_setup_failure(self, error):
+        logger.debug('{0} [SIM_FINISHED] - Board setup failure: {1}'.format(self._log_prefix, error))
+        selection = QMessageBox.critical(self, "Board Setup error",
+                                            error,
+                                            QMessageBox.Ok)
+        self._experiment_condition.cancel_experiment()
+        self._simulation_finished()
+
+    def _board_io_error(self, error):
+        logger.debug('{0} [SIM_FINISHED] - Board IO error: {1}'.format(self._log_prefix, error))
+        selection = QMessageBox.critical(self, "Board IO error",
+                                            error,
+                                            QMessageBox.Ok)
+        self._experiment_condition.cancel_experiment()
+        self._simulation_finished()
 
 class ExperimentInProgress(Thread):
 
@@ -283,6 +317,16 @@ def run(self):
             logger.info('{0} [RUN] - Thread was cancelled by the user'
                         .format(self._log_prefix))
             self._dialog.simulation_finished.emit()
+        except ProtocolSetupException, err:
+            logger.info('{0} [RUN] - Error in arduino configuration'
+                        .format(self._log_prefix))
+            self._experiment_condition.fail_experiment()
+            self._dialog.board_setup_failure.emit(str(err))
+        except ProtocolIOException, err:
+            logger.info('{0} [RUN] - I/O error in arduino connection'
+                        .format(self._log_prefix))
+            self._experiment_condition.fail_experiment()
+            self._dialog.board_io_error.emit(srt(err))
         except Exception:
             logger.info('{0} [RUN] - Unknown Exception catch. Aborting experiment'
                         .format(self._log_prefix))

MLC/GUI/Experiment/ExperimentInProgress.py

@@ -55,16 +55,16 @@
 from PyQt5.QtWidgets import QMessageBox
 from PyQt5.QtWidgets import QInputDialog
 
-from MLC.arduino.protocol import ProtocolConfig
+from MLC.arduino.protocol import ProtocolConfig, ProtocolSetupException, ProtocolIOException
 from MLC.arduino.protocol import ArduinoInterfaceSingleton
-from MLC.arduino.connection.serialconnection import SerialConnectionConfig, SerialConnection
+from MLC.arduino.connection.serialconnection import SerialConnectionConfig, SerialConnection, ConnectionException
 from MLC.arduino.connection.base import BaseConnection
 
 logger = get_gui_logger()
 
 
 class ExperimentWindow(QMainWindow):
-    experiment_finished = pyqtSignal([bool])
+    experiment_finished = pyqtSignal([bool, bool])
 
     MAX_GENERATIONS = 30
 
@@ -140,6 +140,31 @@ 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 (ProtocolSetupException, ConnectionException) as 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
+        except Exception as err:
+            self._report_arduino_unhandled_error(err)
+            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"]
@@ -837,12 +862,12 @@ def _ask_if_experiment_config_must_be_saved(self):
 
             self._autogenerated_object.save_config_button.setDisabled(True)
 
-    def _update_experiment(self, cancelled):
+    def _update_experiment(self, cancelled, failed):
         self._progress_dialog.close_window()
-        if not cancelled:
+        if not cancelled and not failed:
             QMessageBox.information(self, 'Experiment {0}'.format(self._experiment_name),
                                     'Experiment was succesfully executed.', QMessageBox.Ok)
-        else:
+        if cancelled and not failed:
             QMessageBox.information(self, 'Experiment {0}'.format(self._experiment_name),
                                     'Experiment was cancelled by the user.', QMessageBox.Ok)
 
@@ -871,7 +896,7 @@ def _store_board_configuration(self, board_config, serial_conn):
             # Update board configuration in the DB
             self._mlc_local.save_board_configuration(self._experiment_name, self._board_config, self._serial_conn)
 
-        except Exception, err:
+        except (ProtocolSetupException, ConnectionException) as err:
             logger.debug('[EXPERIMENT {0}] [BOARD_CONFIG] - '
                          'Serial port could not be initialized. Error Msg: {1}'
                          .format(self._experiment_name, err))
@@ -888,3 +913,13 @@ def _store_board_configuration(self, board_config, serial_conn):
                 self._mlc_local.save_board_configuration(self._experiment_name,
                                                          self._board_config,
                                                          self._serial_conn)
+
+        except Exception as err:
+            self._report_arduino_unhandled_error(err)
+            return
+
+    def _report_arduino_unhandled_error(self, error):
+        logger.debug('[EXPERIMENT {0}] [BOARD_CONFIG] - '
+                     'Unhandled error. Error Msg: {1}'
+                     .format(self._experiment_name, error))
+        QMessageBox.critical(self, "Critical error", "Error: {0}".format(error))

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__(self, "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 serial.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