generate_calib_param dictionary added (#134)

sjpark608 · web-flow · commit 84e38fff3399 · 2022-11-17T18:13:58.000-08:00
* generate_calib_param dictionary added

* pytest fix

* suggested fix

- calib_params nomenclature
- better description for docstring

* suggest fix

- calib param dataclass formation done in eeprom class
- removed redundant methods and tests
diff --git a/src/edgepi/calibration/edgepi_calibration.py b/src/edgepi/calibration/edgepi_calibration.py
@@ -3,20 +3,9 @@
 able to generate new calibration parameters using measurements tools.
 '''
 
-from struct import pack
+from edgepi.calibration.eeprom_constants import ModuleNames
+from edgepi.calibration.calibration_constants import NumOfCh
 
-from edgepi.calibration.eeprom_constants import (
-    ModuleNames,
-    MemoryAddr
-)
-from edgepi.calibration.calibration_constants import(
-    NumOfCh,
-    CalibParam,
-    # ReferenceV
-)
-
-
-# TODO: calibration class should only handle the calibration process and separate the data storage
 
 class EdgePiCalibration():
     '''
@@ -33,122 +22,9 @@ class EdgePiCalibration():
     def __init__(self, module: ModuleNames):
         self.module = module.value
         self.num_of_ch = NumOfCh[module.name].value
-        self.calib_dict_gen = {ModuleNames.DAC.value : self.__generat_dac_calib_dict}
         self.full_scale_range = None
         self.full_scale_code = None
 
-# TODO: to be used for prepare a value to be upkoaded to eeprom
-# pylint: disable=unused-private-member
-    def __from_value_to_memory(self, param: float = None):
-        # TODO: Create range check for calibration param, unittest,change packing into float and
-        #  chekc precision instead of int
-        param = int(param*10**9)
-        value = pack("i", param)
-        return list(value)
-
-    def __from_memory_to_value(self, memory: list = None) -> float:
-        # TODO: Create range check for calibration param, unittest
-        value = pack("BBBB", memory[0], memory[1], memory[2], memory[3])
-        value = int.from_bytes(value, "little", signed=True)
-        return float(format(value*10**-9, '.9f'))
-
-    def __generat_dac_calib_dict(self, calib_param: list = None) :
-        '''
-        Function to generate DAC calibration parameter dictionary based on the list of imported cal-
-        ibration parameter from DAC module.
-
-        Arg:
-            calib_param (list): list contains the parameter read from eeprom and passed from each mo
-            -dule
-        Return:
-            calib_dict (dict):
-        '''
-        calib_dict={}
-        for ch in range(self.num_of_ch):
-            offset = ch * MemoryAddr.CH_OFFSET.value
-            packed_gain = self.__from_memory_to_value(calib_param[offset:offset+4])
-            packed_offset = self.__from_memory_to_value(calib_param[offset+4:offset+8])
-            calib_dict[ch] = CalibParam(gain = packed_gain, offset=packed_offset)
-
-        return calib_dict
-
-# TODO: ADC Calib to be added
-    # def __generat_adc_calib_dict(self, calib_param: list = None) :
-    #     '''
-    #     Function to generate ADC calibration parameter dictionary based on the list of imported
-    #     calibration parameter from ADC module.
-
-    #     Arg:
-    #         calib_param (list): list contains the parameter read from eeprom and passed from each
-    #         module
-    #     Return:
-    #         calib_dict (dict):
-    #     '''
-
-    #     return 2
-
-# TODO: RTD Calib to be added
-    # def __generat_rtd_calib_dict(self, calib_param: list = None) :
-    #     '''
-    #     Function to generate RTD calibration parameter dictionary based on the list of imported
-    #     calibration parameter from RTD module.
-
-    #     Arg:
-    #         calib_param (list): list contains the parameter read from eeprom and passed from each
-    #         module
-    #     Return:
-    #         calib_dict (dict):
-    #     '''
-
-    #     return 3
-
-# TODO: TC Calib to be added
-    # def __generat_tc_calib_dict(self, calib_param: list = None) :
-    #     '''
-    #     Function to generate TC calibration parameter dictionary based on the list of imported
-    #     calibration parameter from TC module.
-
-    #     Arg:
-    #         calib_param (list): list contains the parameter read from eeprom and passed from each
-    #         module
-    #     Return:
-    #         calib_dict (dict):
-    #     '''
-
-    #     return 4
-
-    def get_calibration_dict(self, calib_param: list = None):
-        '''
-        Function to generate calibration parameter dictionary based on the list of imported
-        calibration parameter from each module.
-
-        Arg:
-            calib_param (list): list contains the parameter read from eeprom and passed from each
-            module
-        Return:
-            calib_dict (dict):
-        '''
-        gen_calib_dict = self.calib_dict_gen[self.module]
-        return gen_calib_dict(calib_param)
-
-    def generate_calib_param_dict(self):
-        '''
-        Function to generate dictionary of calibration parameters
-        Args:
-            N/A
-        Return:
-            ch_to_calib_dict (dict): dictionary mapped channel to CalibParam data class
-            ie) {1 : CalibParam(gain, offset)
-                 .
-                 .
-                 .
-                 nth_channel : CalibParam(gain, offset)}
-        '''
-        ch_to_calib_dict = {}
-        for ch in range(self.num_of_ch):
-            ch_to_calib_dict[ch] = CalibParam(gain=1, offset=0)
-        return ch_to_calib_dict
-
     def generate_measurements_dict(self, num_of_points: int = None):
         '''
         Function to generate dictionary of measurements to generate calibration parameter. It will
diff --git a/src/edgepi/calibration/edgepi_eeprom.py b/src/edgepi/calibration/edgepi_eeprom.py
@@ -99,10 +99,10 @@ def get_edgepi_reserved_data(self):
         # pylint: disable=no-member
         self.eeprom_layout.ParseFromString(self.__read_edgepi_reserved_memory())
         eeprom_data = EdgePiEEPROMData()
-        eeprom_data.dac_calib_parms=eeprom_data.message_to_list(self.eeprom_layout.dac)
-        eeprom_data.adc_calib_parms=eeprom_data.message_to_list(self.eeprom_layout.adc)
-        eeprom_data.rtd_calib_parms=eeprom_data.message_to_list(self.eeprom_layout.rtd)
-        eeprom_data.tc_calib_parms=eeprom_data.message_to_list(self.eeprom_layout.tc)
+        eeprom_data.dac_calib_parms=eeprom_data.message_to_dict(self.eeprom_layout.dac)
+        eeprom_data.adc_calib_parms=eeprom_data.message_to_dict(self.eeprom_layout.adc)
+        eeprom_data.rtd_calib_parms=eeprom_data.message_to_dict(self.eeprom_layout.rtd)
+        eeprom_data.tc_calib_parms=eeprom_data.message_to_dict(self.eeprom_layout.tc)
         eeprom_data.config_key=eeprom_data.keys_to_str(self.eeprom_layout.config_key)
         eeprom_data.data_key=eeprom_data.keys_to_str(self.eeprom_layout.data_key)
         eeprom_data.serial= self.eeprom_layout.serial_number
diff --git a/src/edgepi/calibration/eeprom_constants.py b/src/edgepi/calibration/eeprom_constants.py
@@ -3,6 +3,7 @@
 from enum import Enum
 from dataclasses import dataclass
 from edgepi.calibration.eeprom_mapping_pb2 import EepromLayout
+from edgepi.calibration.calibration_constants import CalibParam
 
 class EEPROMInfo(Enum):
     """
@@ -21,53 +22,6 @@ class ModuleNames(Enum):
     RTD = 0x2
     TC = 0x3
 
-# TODO: to be deleted once protobuf is implemented
-class DACParamAddr(Enum):
-    """
-    EdgePi DAC Calibration Parameter Addresses
-    Each parameter, gain and offset, are 4 bytes long 0x200~0x23F
-    Ex) CH0_gain = 0x200~0x203, CH0_offset = 0x204~0x207
-    """
-    CH0 = 0x200
-    CH1 = 0x208
-    CH2 = 0x210
-    CH3 = 0x218
-    CH4 = 0x220
-    CH5 = 0x228
-    CH6 = 0x230
-    CH7 = 0x238
-    LEN = 63
-# TODO: to be deleted once protobuf is implemented
-class ADCParamAddr(Enum):
-    """
-    EdgePi DAC Calibration Parameter Addresses
-    Each parameter, gain and offset, are 4 bytes long
-    """
-    CH0 = 0x240
-    CH1 = 0x248
-    CH2 = 0x240
-    CH3 = 0x248
-    CH4 = 0x240
-    CH5 = 0x248
-    CH6 = 0x240
-    CH7 = 0x248
-    DIFF1 =0x250
-    DIFF2 =0x258
-    DIFF3 =0x260
-    DIFF4 =0x268
-# TODO: to be deleted once protobuf is implemented
-class MemoryAddr(Enum):
-    """
-    Memory offset values
-    """
-    START = 0x000
-    DAC = 0x200
-    ADC = 0x240
-    TC = 0x280
-    RTD = 0x2C0
-    END = 0x3FF
-    CH_OFFSET = 0x8
-
 class EdgePiMemoryInfo(Enum):
     """
     Information regarding Edgepi reserved memory space
@@ -123,19 +77,19 @@ class EdgePiEEPROMData:
     model: str = None
     client_id: str = None
 
-    def message_to_list(self, data_to_unpack: EepromLayout = None):
+    def message_to_dict(self, data_to_unpack: EepromLayout = None):
         """
         Function to unpack message to list
         Args:
             data_to_unpack: EepromLayout message modules
         Returns:
             calib_list: 1-D array
         """
-        calib_list=[]
-        for ch in data_to_unpack.calibs:
-            calib_list.append(ch.gain)
-            calib_list.append(ch.offset)
-        return calib_list
+        calib_dict={}
+        for indx, ch in enumerate(data_to_unpack.calibs):
+            calib_dict[indx] = CalibParam(gain=ch.gain,
+                                        offset=ch.offset)
+        return calib_dict
 
     def keys_to_str(self, data_to_unpack: EepromLayout = None):
         """
diff --git a/src/edgepi/dac/edgepi_dac.py b/src/edgepi/dac/edgepi_dac.py
@@ -21,11 +21,6 @@
 from edgepi.gpio.edgepi_gpio import EdgePiGPIO
 from edgepi.gpio.gpio_configs import GpioConfigs
 from edgepi.calibration.edgepi_eeprom import EdgePiEEPROM
-from edgepi.calibration.eeprom_constants import MemoryAddr,DACParamAddr, ModuleNames
-from edgepi.calibration.edgepi_calibration import EdgePiCalibration
-
-
-
 
 class EdgePiDAC(spi):
     """A EdgePi DAC device"""
@@ -59,12 +54,12 @@ def __init__(self):
         self.log.info("Initializing DAC Bus")
         super().__init__(bus_num=6, dev_id=3, mode=1, max_speed=1000000)
 
+        # Read edgepi reserved data and generate calibration parameter dictionary
         eeprom = EdgePiEEPROM()
-        calib = EdgePiCalibration(ModuleNames.DAC)
-        calib_param = eeprom.sequential_read(MemoryAddr.DAC.value, DACParamAddr.LEN.value)
-        calib_dict = calib.get_calibration_dict(calib_param)
+        eeprom_data  = eeprom.get_edgepi_reserved_data()
+        dac_calib_params = eeprom_data.dac_calib_parms
 
-        self.dac_ops = DACCommands(calib_dict)
+        self.dac_ops = DACCommands(dac_calib_params)
         self.gpio = EdgePiGPIO(GpioConfigs.DAC.value)
 
         self.__dac_power_state = {
diff --git a/src/test_edgepi/unit_tests/test_calibration/test_edgepi_calibration.py b/src/test_edgepi/unit_tests/test_calibration/test_edgepi_calibration.py
@@ -4,14 +4,21 @@
 # pylint: disable=protected-access
 
 from unittest import mock
+import os
+PATH = os.path.dirname(os.path.abspath(__file__))
 import sys
 sys.modules['periphery'] = mock.MagicMock()
 
 import pytest
 from edgepi.calibration.edgepi_calibration import EdgePiCalibration
-from edgepi.calibration.calibration_constants import CalibParam
 from edgepi.calibration.eeprom_constants import ModuleNames
 
+def read_binfile():
+    """Read the dummy serializedFile and return byte string"""
+    with open(PATH+"/serializedFile","rb") as fd:
+        b_string = fd.read()
+    return b_string
+
 # @pytest.fixture(name="calib")
 # def fixture_test_dac():
 #     yield EdgePiCalibration()
@@ -25,19 +32,6 @@ def test_init_class(module_name, result):
     assert edge_calib.module == result[0]
     assert edge_calib.num_of_ch == result[1]
 
-@pytest.mark.parametrize("module_name, result", [(ModuleNames.DAC, [1, 0]),
-                                                 (ModuleNames.ADC, [1, 0]),
-                                                 (ModuleNames.RTD, [1, 0]),
-                                                 (ModuleNames.TC, [1, 0])])
-def test_generate_calib_param_dict(module_name, result):
-    edge_calib = EdgePiCalibration(module_name)
-    calib_dict = edge_calib.generate_calib_param_dict()
-    for _, value in calib_dict.items():
-        assert value.gain == result[0]
-        assert value.offset == result[1]
-    dict_length = len(calib_dict.values())
-    assert dict_length == edge_calib.num_of_ch
-
 @pytest.mark.parametrize("module_name, num_of_points, result", [(ModuleNames.DAC, 10, 0),
                                                                 (ModuleNames.ADC, 5, 0),
                                                                 (ModuleNames.RTD, 2, 0),
@@ -103,41 +97,3 @@ def test_record_measurements(module_name, num_of_points, values_to_record):
         assert value_dict['input_unit'] != 0
         assert value_dict['expected_out'] != 0
         assert value_dict['actual_out'] != 0
-
-@pytest.mark.parametrize("module_name, memory, result",
-                        [(ModuleNames.DAC,[105,60,232,254], -0.018334615)])
-def test_from_memory_to_value(module_name, memory, result):
-    edge_calib = EdgePiCalibration(module_name)
-    assert edge_calib._EdgePiCalibration__from_memory_to_value(memory) == result
-
-@pytest.mark.parametrize("module_name, value, result",
-                        [(ModuleNames.DAC, -0.018334615,[105,60,232,254]),
-                         (ModuleNames.DAC, -0.018334615234,[105,60,232,254]),
-                         (ModuleNames.DAC, -0.018334615999,[105,60,232,254]),
-                         (ModuleNames.DAC, 0.0,[0,0,0,0])])
-def test_from_value_to_memory(module_name, value, result):
-    edge_calib = EdgePiCalibration(module_name)
-    assert edge_calib._EdgePiCalibration__from_value_to_memory(value) == result
-
-@pytest.mark.parametrize("module_name, calib_param, result",
-                        [(ModuleNames.DAC,
-                            [0,225,245,5,0,225,245,5,
-                             0,194,235,11,0,194,235,11,
-                             0,163,225,17,0,163,225,17,
-                             0,132,215,23,0,132,215,23,
-                             0,101,205,29,0,101,205,29,
-                             0,70,195,35,0,70,195,35,
-                             0,39,185,41,0,39,185,41,
-                             0,8,175,47,0,8,175,47],
-                                {0:CalibParam(gain=0.1,offset=0.1),
-                                 1:CalibParam(gain=0.2,offset=0.2),
-                                 2:CalibParam(gain=0.3,offset=0.3),
-                                 3:CalibParam(gain=0.4,offset=0.4),
-                                 4:CalibParam(gain=0.5,offset=0.5),
-                                 5:CalibParam(gain=0.6,offset=0.6),
-                                 6:CalibParam(gain=0.7,offset=0.7),
-                                 7:CalibParam(gain=0.8,offset=0.8)})])
-def test_get_calibration_dict(module_name, calib_param, result):
-    edge_calib = EdgePiCalibration(module_name)
-    calib_dict = edge_calib.get_calibration_dict(calib_param)
-    assert calib_dict == result
diff --git a/src/test_edgepi/unit_tests/test_calibration/test_eeprom_constants.py b/src/test_edgepi/unit_tests/test_calibration/test_eeprom_constants.py
@@ -20,19 +20,19 @@ def test_edgepi_eeprom_data():
     memory_map = EepromLayout()
     memory_map.ParseFromString(read_binfile())
     eeprom_data = EdgePiEEPROMData()
-    eeprom_data.dac_calib_parms=eeprom_data.message_to_list(memory_map.dac)
-    eeprom_data.adc_calib_parms=eeprom_data.message_to_list(memory_map.adc)
-    eeprom_data.rtd_calib_parms=eeprom_data.message_to_list(memory_map.rtd)
-    eeprom_data.tc_calib_parms=eeprom_data.message_to_list(memory_map.tc)
+    eeprom_data.dac_calib_parms=eeprom_data.message_to_dict(memory_map.dac)
+    eeprom_data.adc_calib_parms=eeprom_data.message_to_dict(memory_map.adc)
+    eeprom_data.rtd_calib_parms=eeprom_data.message_to_dict(memory_map.rtd)
+    eeprom_data.tc_calib_parms=eeprom_data.message_to_dict(memory_map.tc)
     eeprom_data.config_key=eeprom_data.keys_to_str(memory_map.config_key)
     eeprom_data.data_key=eeprom_data.keys_to_str(memory_map.data_key)
     eeprom_data.serial=memory_map.serial_number
     eeprom_data.model=memory_map.model
     eeprom_data.client_id=memory_map.client_id
-    assert eeprom_data.dac_calib_parms == eeprom_data.message_to_list(memory_map.dac)
-    assert eeprom_data.adc_calib_parms==eeprom_data.message_to_list(memory_map.adc)
-    assert eeprom_data.rtd_calib_parms==eeprom_data.message_to_list(memory_map.rtd)
-    assert eeprom_data.tc_calib_parms==eeprom_data.message_to_list(memory_map.tc)
+    assert eeprom_data.dac_calib_parms == eeprom_data.message_to_dict(memory_map.dac)
+    assert eeprom_data.adc_calib_parms==eeprom_data.message_to_dict(memory_map.adc)
+    assert eeprom_data.rtd_calib_parms==eeprom_data.message_to_dict(memory_map.rtd)
+    assert eeprom_data.tc_calib_parms==eeprom_data.message_to_dict(memory_map.tc)
     assert eeprom_data.config_key.certificate == memory_map.config_key.certificate
     assert eeprom_data.config_key.private == memory_map.config_key.private_key
     assert eeprom_data.data_key.certificate == memory_map.data_key.certificate
diff --git a/src/test_edgepi/unit_tests/test_dac/test_edgepi_dac.py b/src/test_edgepi/unit_tests/test_dac/test_edgepi_dac.py
