#52 protocol board configuration persistence implemented

raulopez0 · raulopez0 · commit 607dc1bd4ad4 · 2017-02-12T20:18:21.000-03:00
diff --git a/MLC/db/mlc_repository.py b/MLC/db/mlc_repository.py
@@ -103,6 +103,19 @@ def update_individual_cost(self, individual_id, cost, evaluation_time, generatio
     def remove_unused_individuals(self):
         raise NotImplementedError("This method must be implemented")
 
+    # board configuration
+    def save_board_configuration(self, board_config, board_id=None):
+        raise NotImplementedError("This method must be implemented")
+
+    def load_board_configuration(self, board_id):
+        raise NotImplementedError("This method must be implemented")
+
+    def save_connection(self, serial_connection, board_id, connection_id=None):
+        raise NotImplementedError("This method must be implemented")
+
+    def load_connection(self, connection_id):
+        raise NotImplementedError("This method must be implemented")
+
     @staticmethod
     def get_instance():
         # FIXME: use factories instead of this
diff --git a/MLC/db/sqlite/sql_statements_board_configuration.py b/MLC/db/sqlite/sql_statements_board_configuration.py
@@ -0,0 +1,115 @@
+def stmt_create_table_board():
+    return ''' CREATE TABLE board(id INTEGER PRIMARY KEY AUTOINCREMENT,
+                                  board_type TEXT,
+                                  connection_type INTEGER,
+                                  read_count INTEGER,
+                                  read_delay INTEGER,
+                                  report_mode INTEGER,
+                                  analog_resolution INTEGER)'''
+
+
+def stmt_create_table_serial_connection():
+    return ''' CREATE TABLE serial_connection(id INTEGER PRIMARY KEY AUTOINCREMENT,
+                                              board_id INTEGER,
+                                              baud_rate INTEGER,
+                                              parity INTEGER,
+                                              stop_bits INTEGER,
+                                              byte_size INTEGER,
+                                              FOREIGN KEY(board_id) REFERENCES board(id))'''
+
+
+def stmt_create_table_digital_pin():
+    return ''' CREATE TABLE digital_pin(pin_id INTEGER,
+                                        board_id INTEGER,
+                                        pin_type INTEGER,
+                                        PRIMARY KEY (pin_id, board_id),
+                                        FOREIGN KEY(board_id) REFERENCES board(id))'''
+
+
+def stmt_create_table_analog_pin():
+    return ''' CREATE TABLE analog_pin(pin_id INTEGER,
+                                       board_id INTEGER,
+                                       pin_type INTEGER,
+                                       PRIMARY KEY (pin_id, board_id),
+                                       FOREIGN KEY(board_id) REFERENCES board(id))'''
+
+
+def stmt_create_table_pwm_pin():
+    return ''' CREATE TABLE pwm_pin(pin_id INTEGER,
+                                    board_id INTEGER,
+                                    PRIMARY KEY (pin_id, board_id),
+                                    FOREIGN KEY(board_id) REFERENCES board(id))'''
+
+def stmt_insert_board(board_type, connection_type, read_count, read_delay, report_mode, analog_resolution):
+    return '''INSERT INTO board (board_type, connection_type, read_count, read_delay, report_mode, analog_resolution)
+              VALUES ("%s", %s, %s, %s, %s, %s)''' % (board_type,
+                                                      connection_type,
+                                                      read_count,
+                                                      read_delay,
+                                                      report_mode,
+                                                      analog_resolution)
+
+def stmt_update_board(board_id, board_type, connection_type, read_count, read_delay, report_mode, analog_resolution):
+    return '''UPDATE board SET
+              board_type = "%s",
+              connection_type = %s,
+              read_count = %s,
+              read_delay = %s,
+              report_mode = %s,
+              analog_resolution = %s
+              WHERE id = %s''' % (board_type,
+                                  connection_type,
+                                  read_count,
+                                  read_delay,
+                                  report_mode,
+                                  analog_resolution,
+                                  board_id)
+
+
+def stmt_get_board(board_id):
+    return '''SELECT board_type, report_mode, read_count, read_delay, analog_resolution
+              FROM board WHERE id = %s''' % board_id
+
+
+def stmt_delete_digital_pin(board_id):
+    return __stmt_delete_pin("digital_pin", board_id)
+
+
+def stmt_delete_analog_pin(board_id):
+    return __stmt_delete_pin("analog_pin", board_id)
+
+
+def stmt_delete_pwm_pin(board_id):
+    return __stmt_delete_pin("pwm_pin", board_id)
+
+
+def __stmt_delete_pin(pin_table, board_id):
+    return '''DELETE FROM %s WHERE board_id = %s''' % (pin_table, board_id)
+
+
+def stmt_insert_digital_pin(board_id, pin_id, pin_type):
+    return __stmt_insert_pin("digital_pin", board_id, pin_id, pin_type)
+
+
+def stmt_insert_analog_pin(board_id, pin_id, pin_type):
+    return __stmt_insert_pin("analog_pin", board_id, pin_id, pin_type)
+
+
+def __stmt_insert_pin(pin_table, board_id, pin_id, pin_type):
+    return '''INSERT INTO %s (pin_id, board_id, pin_type) VALUES (%s, %s, %s)''' % (pin_table, pin_id, board_id, pin_type)
+
+
+def stmt_insert_pwm_pin(board_id, pin_id):
+    return '''INSERT INTO pwm_pin (pin_id, board_id) VALUES (%s, %s)''' % (pin_id, board_id)
+
+
+def stmt_get_analog_pins(board_id):
+    return "SELECT pin_id, pin_type FROM analog_pin WHERE board_id = %s" % (board_id)
+
+
+def stmt_get_digital_pins(board_id):
+    return "SELECT pin_id, pin_type FROM digital_pin WHERE board_id = %s" % (board_id)
+
+
+def stmt_get_pwm_pins(board_id):
+    return "SELECT pin_id FROM pwm_pin WHERE board_id = %s" % (board_id)
diff --git a/MLC/db/sqlite/sqlite_repository.py b/MLC/db/sqlite/sqlite_repository.py
@@ -7,6 +7,9 @@
 from MLC.Log.log import get_gui_logger
 from MLC.Simulation import Simulation
 from sql_statements import *
+from sql_statements_board_configuration import *
+from MLC.arduino.protocol import ProtocolConfig
+from MLC.arduino.boards import types
 
 logger = get_gui_logger()
 
@@ -43,8 +46,18 @@ def __init__(self, database, init_db=False):
 
     def __initialize_db(self):
         cursor = self._conn.cursor()
+
+        # MLC Population tables
         cursor.execute(stmt_create_table_individuals())
         cursor.execute(stmt_create_table_population())
+
+        # Board configuration tables
+        cursor.execute(stmt_create_table_board())
+        cursor.execute(stmt_create_table_serial_connection())
+        cursor.execute(stmt_create_table_digital_pin())
+        cursor.execute(stmt_create_table_analog_pin())
+        cursor.execute(stmt_create_table_pwm_pin())
+
         cursor.close()
         self._conn.commit()
 
@@ -239,6 +252,7 @@ def update_individual_cost(self, individual_id, cost, evaluation_time, generatio
         self.__execute(stmt_to_update_cost)
 
     def __execute(self, statement):
+        # print ">>> %s" % statement
         conn = self.__get_db_connection()
         cursor = conn.cursor()
         cursor.execute(statement)
@@ -289,3 +303,113 @@ def __load_individuals(self):
         cursor.close()
         conn.commit()
         return individuals
+
+    # board configuration
+    def save_board_configuration(self, board_config, board_id=None):
+
+        conn = self.__get_db_connection()
+        cursor = conn.cursor()
+
+        try:
+            # save/update board configuration
+            if board_id is None:
+                cursor.execute(stmt_insert_board(board_config.board_type["SHORT_NAME"],
+                                                 0, # serial connection hardcoded
+                                                 board_config.read_count,
+                                                 board_config.read_delay,
+                                                 board_config.report_mode,
+                                                 board_config.analog_resolution))
+                board_id = cursor.lastrowid
+            else:
+                cursor.execute(stmt_update_board(board_id,
+                                                 board_config.board_type["SHORT_NAME"],
+                                                 0,
+                                                 board_config.read_count,
+                                                 board_config.read_delay,
+                                                 board_config.report_mode,
+                                                 board_config.analog_resolution))
+                if cursor.rowcount < 1:
+                    raise KeyError("Board %s does not exist" % board_id)
+
+            # if board update is successful, update board pins
+            # delete board pin configuration
+            cursor.execute(stmt_delete_digital_pin(board_id))
+            cursor.execute(stmt_delete_analog_pin(board_id))
+            cursor.execute(stmt_delete_pwm_pin(board_id))
+
+            # update digital pins
+            self.__insert_pins(board_config.digital_input_pins, cursor, stmt_insert_digital_pin, board_id, 0)
+            self.__insert_pins(board_config.digital_output_pins, cursor, stmt_insert_digital_pin, board_id, 1)
+
+            # update analog pins
+            self.__insert_pins(board_config.analog_input_pins, cursor, stmt_insert_analog_pin, board_id, 0)
+            self.__insert_pins(board_config.analog_output_pins, cursor, stmt_insert_analog_pin, board_id, 1)
+
+            # update pwm pins
+            for pin_id in board_config.pwm_pins:
+                cursor.execute(stmt_insert_pwm_pin(board_id, pin_id))
+
+        except Exception:
+            raise
+        finally:
+            cursor.close()
+            conn.commit()
+
+        return board_id
+
+    def __insert_pins(self, pin_list, cursor, stmt_insert_pin, board_id, pin_type):
+        for pin_id in pin_list:
+            cursor.execute(stmt_insert_pin(board_id, pin_id, pin_type))
+
+    def __get_pins(self, cursor, stmt_get_pins, board_id):
+        input_pins = []
+        output_pins = []
+
+        for row in cursor.execute(stmt_get_pins(board_id)):
+            pin_id, pin_type = row[0], row[1]
+            if pin_type == 0:
+                input_pins.append(pin_id)
+            else:
+                output_pins.append(pin_id)
+        return input_pins, output_pins
+
+    def load_board_configuration(self, board_id):
+        protocol = None
+        conn = self.__get_db_connection()
+        cursor = conn.execute(stmt_get_board(board_id))
+
+        for row in cursor:
+            board_type = filter(lambda x: x["SHORT_NAME"] == row[0], types)
+
+            protocol = ProtocolConfig(connection=None,
+                                      board_type=board_type[0],
+                                      report_mode=row[1],
+                                      read_count=row[2],
+                                      read_delay=row[3],
+                                      analog_resolution=row[4])
+            break
+
+        if protocol is None:
+            raise KeyError("Board %s dows not exists" % board_id)
+
+        # load pins
+        input_pins, output_pins = self.__get_pins(cursor, stmt_get_analog_pins, board_id)
+        protocol.analog_input_pins.extend(input_pins)
+        protocol.analog_output_pins.extend(output_pins)
+
+        input_pins, output_pins = self.__get_pins(cursor, stmt_get_digital_pins, board_id)
+        protocol.digital_input_pins.extend(input_pins)
+        protocol.digital_output_pins.extend(output_pins)
+
+        for row in cursor.execute(stmt_get_pwm_pins(board_id)):
+            protocol.pwm_pins.append(row[0])
+
+        cursor.close()
+
+        return protocol
+
+    def save_connection(self, serial_connection, board_id, connection_id=None):
+        raise NotImplementedError("This method must be implemented")
+
+    def load_connection(self, connection_id):
+        raise NotImplementedError("This method must be implemented")
diff --git a/tests/mlc/db/test_mlc_repository.py b/tests/mlc/db/test_mlc_repository.py
