#52 Board Configuration and Connection persistence integrated to the MLC API

Author: raulopez0

MLC/GUI/Experiment/ExperimentWindow.py

@@ -109,9 +109,7 @@ def __init__(self, mlc_local,
                                                              mlc_local=self._mlc_local)
 
         # Arduino board configurations
-        # FIXME Board configuration must come from the experiment DB
-        self._board_config = ProtocolConfig(None)
-        self._serial_conn = SerialConnectionConfig('/dev/ttyACM0')
+        self._board_config, self._serial_conn = mlc_local.get_board_configuration(self._experiment_name)
 
     def closeEvent(self, event):
         logger.debug('[EXPERIMENT {0}] [CLOSE_DIALOG] - Executing overriden closeEvent function'.format(self._experiment_name))
@@ -750,6 +748,11 @@ def _store_board_configuration(self, board_config, serial_conn):
         try:
             ArduinoInterfaceSingleton.get_instance(protocol_config=self._board_config,
                                                    conn_setup=self._serial_conn._asdict())
+
+
+            # Update board configuration in the DB
+            self._mlc_local.save_board_configuration(self._experiment_name, self._board_config, self._serial_conn)
+
         except Exception, err:
             logger.debug('[EXPERIMENT {0}] [BOARD_CONFIG] - '
                          'Serial port could not be initialized. Error Msg: {1}'
@@ -764,3 +767,6 @@ def _store_board_configuration(self, board_config, serial_conn):
                 self.on_board_config_button_clicked()
             else:
                 self._board_config = self._board_config._replace(connection=BaseConnection())
+                self._mlc_local.save_board_configuration(self._experiment_name,
+                                                         self._board_config,
+                                                         self._serial_conn)

MLC/api/MLCLocal.py

@@ -26,6 +26,8 @@
 from MLC.Log.log import get_gui_logger
 from MLC.mlc_parameters.mlc_parameters import Config
 from MLC.Simulation import Simulation
+from MLC.arduino.protocol import ProtocolConfig
+from MLC.arduino.connection.serialconnection import SerialConnectionConfig
 
 logger = get_gui_logger()
 
@@ -219,6 +221,57 @@ def get_experiment_info(self, experiment_name):
             experiment_info["best_indiv_value"] = min_indiv_data.get_value()
         return experiment_info
 
+    def get_board_configuration(self, experiment_name):
+        if experiment_name not in self._experiments:
+            raise ExperimentNotExistException(experiment_name)
+
+        if experiment_name not in self._open_experiments:
+            raise ClosedExperimentException("get_experiment_info", experiment_name)
+
+        mlc_repo = MLCRepository.get_instance()
+
+        boards = mlc_repo.get_board_configuration_ids()
+
+        if len(boards) == 0:
+            # creates default board configuration if not exists
+            serial_connection = SerialConnectionConfig('/dev/ttyACM0')
+            board_configuration = ProtocolConfig(serial_connection)
+
+            # save default board configuration and serial connection
+            board_id = mlc_repo.save_board_configuration(board_configuration)
+            mlc_repo.save_serial_connection(serial_connection, board_id)
+
+            return board_configuration, serial_connection
+        else:
+            # take first board configuration
+            board_id = boards[0]
+
+            # load board configuration and serial connection
+            board_configuration = mlc_repo.load_board_configuration(board_id)
+            serial_connection = mlc_repo.load_serial_connection(board_id)
+
+            return board_configuration, serial_connection
+
+    def save_board_configuration(self, experiment_name, board_configuration, connection):
+        if experiment_name not in self._experiments:
+            raise ExperimentNotExistException(experiment_name)
+
+        if experiment_name not in self._open_experiments:
+            raise ClosedExperimentException("get_experiment_info", experiment_name)
+
+        mlc_repo = MLCRepository.get_instance()
+
+        boards = mlc_repo.get_board_configuration_ids()
+
+        if len(boards) == 0:
+            # save board configuration and serial connection
+            board_id = mlc_repo.save_board_configuration(board_configuration)
+            mlc_repo.save_serial_connection(connection, board_id)
+        else:
+            board_id = boards[0]
+            mlc_repo.save_board_configuration(board_configuration, board_id=board_id)
+            mlc_repo.save_serial_connection(connection, board_id=board_id, connection_id=board_id)
+
     def go(self, experiment_name, to_generation, from_generation=0, 
            callbacks={}, gen_creator=None):
         if experiment_name not in self._experiments:

MLC/db/sqlite/sql_statements_board_configuration.py

@@ -11,9 +11,9 @@ def stmt_create_table_board():
 def stmt_create_table_serial_connection():
     return ''' CREATE TABLE serial_connection(id INTEGER PRIMARY KEY AUTOINCREMENT,
                                               board_id INTEGER,
-                                              port INTEGER,
+                                              port TEXT,
                                               baudrate INTEGER,
-                                              parity INTEGER,
+                                              parity TEXT,
                                               stopbits INTEGER,
                                               bytesize INTEGER,
                                               FOREIGN KEY(board_id) REFERENCES board(id))'''
@@ -118,19 +118,19 @@ def stmt_get_pwm_pins(board_id):
 
 def stmt_insert_serial_connection(board_id, port, baudrate, parity, stopbits, bytesize):
     return '''INSERT INTO serial_connection (board_id, port, baudrate, parity, stopbits, bytesize)
-              VALUES (%s, %s, %s, %s, %s, %s)''' % (board_id,
-                                                    port,
-                                                    baudrate,
-                                                    parity,
-                                                    stopbits,
-                                                    bytesize)
+              VALUES (%s, "%s", %s, "%s", %s, %s)''' % (board_id,
+                                                        port,
+                                                        baudrate,
+                                                        parity,
+                                                        stopbits,
+                                                        bytesize)
 
 def stmt_update_serial_connection(connection_id, board_id, port, baudrate, parity, stopbits, bytesize):
     return '''UPDATE serial_connection SET
               board_id = "%s",
-              port = %s,
+              port = "%s",
               baudrate = %s,
-              parity = %s,
+              parity = "%s",
               stopbits = %s,
               bytesize = %s
               WHERE id = %s''' % (board_id,
@@ -141,6 +141,11 @@ def stmt_update_serial_connection(connection_id, board_id, port, baudrate, parit
                                   bytesize,
                                   connection_id)
 
+
 def stmt_get_serial_connection(board_id):
     return '''SELECT port, baudrate, parity, stopbits, bytesize
-              FROM serial_connection WHERE board_id = %s''' % board_id
+              FROM serial_connection WHERE board_id = %s''' % board_id
+
+
+def stmt_get_board_configuration_ids():
+    return '''SELECT id FROM board'''

MLC/db/sqlite/sqlite_repository.py

@@ -374,6 +374,15 @@ def __get_pins(self, cursor, stmt_get_pins, board_id):
                 output_pins.append(pin_id)
         return input_pins, output_pins
 
+    def get_board_configuration_ids(self):
+        board_ids = []
+        conn = self.__get_db_connection()
+        cursor = conn.execute(stmt_get_board_configuration_ids())
+        for row in cursor:
+            board_ids.append(row[0])
+        cursor.close()
+        return board_ids
+
     def load_board_configuration(self, board_id):
         protocol = None
         conn = self.__get_db_connection()

tests/mlc/api/test_mlc.py

@@ -18,7 +18,9 @@
 from MLC.Population.Population import Population as MLCPopulation
 from MLC.Simulation import Simulation
 
-
+from MLC.arduino import boards
+from MLC.arduino.protocol import ProtocolConfig
+from MLC.arduino.connection.serialconnection import SerialConnectionConfig
 
 class MLCWorkspaceTest(unittest.TestCase):
     WORKSPACE_DIR = os.path.abspath("/tmp/mlc_workspace/")
@@ -201,6 +203,85 @@ def test_get_info_empty_simulation(self):
 
         mlc.close_experiment(MLCWorkspaceTest.ORIGINAL_EXPERIMENT)
 
+    def test_create_experiment_and_obtain_configuration(self):
+        try:
+            mlc = MLCLocal(working_dir=MLCWorkspaceTest.WORKSPACE_DIR)
+            mlc.new_experiment(MLCWorkspaceTest.NEW_EXPERIMENT,
+                               MLCWorkspaceTest.NEW_CONFIGURATION)
+            mlc.open_experiment(MLCWorkspaceTest.NEW_EXPERIMENT)
+            configuration = mlc.get_experiment_configuration(
+                MLCWorkspaceTest.NEW_EXPERIMENT)
+            print configuration
+            mlc.close_experiment(MLCWorkspaceTest.NEW_EXPERIMENT)
+
+            # check configuration structure
+            self.assertIsInstance(configuration, dict)
+            self.assertTrue(configuration.has_key("PARAMS"))
+            self.assertIsInstance(configuration["PARAMS"], dict)
+            self.assertTrue(configuration["PARAMS"].has_key("test_param"))
+            self.assertEqual(configuration["PARAMS"]["test_param"],
+                             "test_value")
+
+        finally:
+            # FIXME: use Setup/TearDown testcase
+            mlc.delete_experiment(MLCWorkspaceTest.NEW_EXPERIMENT)
+
+    def test_get_default_board_configuration(self):
+        try:
+            mlc = MLCLocal(working_dir=MLCWorkspaceTest.WORKSPACE_DIR)
+            mlc.new_experiment(MLCWorkspaceTest.NEW_EXPERIMENT,
+                               MLCWorkspaceTest.NEW_CONFIGURATION)
+            mlc.open_experiment(MLCWorkspaceTest.NEW_EXPERIMENT)
+
+            board_configuration, serial_connection = mlc.get_board_configuration(MLCWorkspaceTest.NEW_EXPERIMENT)
+
+            self.assertEqual(board_configuration.board_type, boards.Due)
+            self.assertEqual(board_configuration.read_count, 2)
+            self.assertEqual(board_configuration.read_delay, 0)
+            self.assertEqual(board_configuration.report_mode, 0)
+            self.assertEqual(board_configuration.analog_resolution, 12)
+
+            self.assertEqual(serial_connection.port, "/dev/ttyACM0")
+            self.assertEqual(serial_connection.baudrate, 115200)
+            self.assertEqual(serial_connection.parity, "N")
+            self.assertEqual(serial_connection.stopbits, 1)
+            self.assertEqual(serial_connection.bytesize, 8)
+
+        finally:
+            # FIXME: use Setup/TearDown testcase
+            mlc.delete_experiment(MLCWorkspaceTest.NEW_EXPERIMENT)
+
+    def test_update_board_configuration(self):
+        try:
+            mlc = MLCLocal(working_dir=MLCWorkspaceTest.WORKSPACE_DIR)
+            mlc.new_experiment(MLCWorkspaceTest.NEW_EXPERIMENT, MLCWorkspaceTest.NEW_CONFIGURATION)
+            mlc.open_experiment(MLCWorkspaceTest.NEW_EXPERIMENT)
+
+            board_configuration, serial_connection = mlc.get_board_configuration(MLCWorkspaceTest.NEW_EXPERIMENT)
+
+            new_board_config = ProtocolConfig(None, report_mode=12, read_count=10, read_delay=11, board_type=boards.Leonardo, analog_resolution=13)
+            new_connection = SerialConnectionConfig("/dev/ttyACM1", baudrate=5000, parity="P", stopbits=2, bytesize=6)
+            mlc.save_board_configuration(MLCWorkspaceTest.NEW_EXPERIMENT, new_board_config, new_connection)
+
+            loaded_board_configuration, loaded_connection = mlc.get_board_configuration(MLCWorkspaceTest.NEW_EXPERIMENT)
+
+
+            self.assertEqual(loaded_board_configuration.board_type, boards.Leonardo)
+            self.assertEqual(loaded_board_configuration.read_count, 10)
+            self.assertEqual(loaded_board_configuration.read_delay, 11)
+            self.assertEqual(loaded_board_configuration.report_mode, 12)
+            self.assertEqual(loaded_board_configuration.analog_resolution, 13)
+
+            self.assertEqual(loaded_connection.port, "/dev/ttyACM1")
+            self.assertEqual(loaded_connection.baudrate, 5000)
+            self.assertEqual(loaded_connection.parity, "P")
+            self.assertEqual(loaded_connection.stopbits, 2)
+            self.assertEqual(loaded_connection.bytesize, 6)
+
+        finally:
+            # FIXME: use Setup/TearDown testcase
+            mlc.delete_experiment(MLCWorkspaceTest.NEW_EXPERIMENT)
+
     @nottest
     def test_go_and_check_simulation_info(self):
         try: