Calibration suggestion (#129)

* Nov1 code review suggestions

* refactoring eeprom access module to accomodate the hardware change

* EEPROM class is refactored to accomodate the larger memory size #125

* pylint fix

Author: sjpark608

src/edgepi/calibration/edgepi_calibration.py

@@ -40,11 +40,14 @@ def __init__(self, module: ModuleNames):
 # 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'))

src/edgepi/calibration/edgepi_eeprom.py

@@ -1,11 +1,13 @@
 '''Helper class to access on board eeprom'''
 
 import logging
+import math
 
-from edgepi.calibration.eeprom_constants import EEPROMAddress
+from edgepi.calibration.eeprom_constants import EEPROMInfo
 from edgepi.peripherals.i2c import I2CDevice
 
-
+#TODO: Maybe use protobuff
+#TODO: EEPROM should return structured data class of parameters to calibration class.
 class EdgePiEEPROM(I2CDevice):
     '''
     Helper class to read eeprom using I2C
@@ -16,6 +18,31 @@ def __init__(self):
         self.log = logging.getLogger(__name__)
         super().__init__(self.__dev_path)
 
+    def __pack_mem_address(self, page_addr: int = None, byte_addr: int = None):
+        """
+        Pack page address and byte address to generate address message. The address message will
+        let the EEPROM memory address point to know at which address the read/write operation to
+        take in place
+        Args:
+            page_addr (int): page address (0~511)
+            byte_addr (int): byte address in the page(0~63)
+        return:
+            (list): 2-byte address message
+        """
+        address = page_addr<<6 | byte_addr
+        return [(address>>8)&0xFF, address&0xFF]
+
+    def __byte_address_generation(self, memory_address: int = None):
+        """
+        Generates page address and bytes address from the memory address provided.
+        Args:
+            memory_address (int): memory address to start read/write operation. This is in bytes
+            from 0 - 32768
+        """
+        page_addr  = math.floor(memory_address/EEPROMInfo.PAGE_SIZE.value)
+        byte_addr = memory_address%EEPROMInfo.PAGE_SIZE.value
+        self.log.debug(f'Page address = {page_addr}, byte Address = {byte_addr}')
+        return page_addr, byte_addr
 
     def sequential_read(self, mem_addr: int = None, length: int = None):
         '''
@@ -28,9 +55,11 @@ def sequential_read(self, mem_addr: int = None, length: int = None):
             List of read data
 
         '''
-        msg = self.set_read_msg(mem_addr, [0x00]*length)
+        page_addr, byte_addr = self.__byte_address_generation(mem_addr)
+        mem_addr_list = self.__pack_mem_address(page_addr, byte_addr)
+        msg = self.set_read_msg(mem_addr_list, [0x00]*length)
         self.log.debug(f'Reading Address {mem_addr}, {length} bytes, {msg[1].data}')
-        read_result = self.transfer(EEPROMAddress.DEV_ADDR.value, msg)
+        read_result = self.transfer(EEPROMInfo.DEV_ADDR.value, msg)
         self.log.debug(f'Read data: {msg[1].data}')
         return read_result
 
@@ -43,9 +72,11 @@ def selective_read(self, mem_addr: int = None):
         Returns:
             List of read data
         '''
+        page_addr, byte_addr = self.__byte_address_generation(mem_addr)
+        mem_addr_list = self.__pack_mem_address(page_addr, byte_addr)
         msg = self.set_read_msg(mem_addr, [0x00])
-        self.log.debug(f'Reading Address {mem_addr}, {msg[1].data}')
-        read_result = self.transfer(EEPROMAddress.DEV_ADDR.value, msg)
+        self.log.debug(f'Reading Address {mem_addr_list}, {msg[1].data}')
+        read_result = self.transfer(EEPROMInfo.DEV_ADDR.value, msg)
         self.log.debug(f'Read data: {msg[1].data}')
         return read_result
 
@@ -58,9 +89,11 @@ def byte_write_register(self, mem_addr: int = None, data: int = None):
         Returns:
             N/A
         '''
-        msg = self.set_write_msg(mem_addr, [data])
+        page_addr, byte_addr = self.__byte_address_generation(mem_addr)
+        mem_addr_list = self.__pack_mem_address(page_addr, byte_addr)
+        msg = self.set_write_msg(mem_addr_list, [data])
         self.log.debug(f'Writing {data} to memory address of {mem_addr}, {msg[0].data}')
-        self.transfer(EEPROMAddress.DEV_ADDR.value, msg)
+        self.transfer(EEPROMInfo.DEV_ADDR.value, msg)
 
     def page_write_register(self, mem_addr: int = None, data: list = None):
         '''
@@ -71,6 +104,8 @@ def page_write_register(self, mem_addr: int = None, data: list = None):
         Returns:
             N/A
         '''
-        msg = self.set_write_msg(mem_addr, data)
+        page_addr, byte_addr = self.__byte_address_generation(mem_addr)
+        mem_addr_list = self.__pack_mem_address(page_addr, byte_addr)
+        msg = self.set_write_msg(mem_addr_list, data)
         self.log.debug(f'Writing {data} to memory address of {mem_addr}, {msg[0].data}')
-        self.transfer(EEPROMAddress.DEV_ADDR.value, msg)
+        self.transfer(EEPROMInfo.DEV_ADDR.value, msg)

src/edgepi/calibration/eeprom_constants.py

@@ -2,11 +2,13 @@
 
 from enum import Enum
 
-class EEPROMAddress(Enum):
+class EEPROMInfo(Enum):
     """
     EEPROM device address for I2C addressing
     """
     DEV_ADDR = 0x50
+    PAGE_SIZE = 64
+    NUM_OF_PAGE = 512
 
 class ModuleNames(Enum):
     """

src/test_edgepi/unit_tests/test_calibration/test_access_eeprom.py

@@ -15,6 +15,30 @@ def fixture_test_dac(mocker):
     mocker.patch("edgepi.peripherals.i2c.I2C")
     yield EdgePiEEPROM()
 
+@pytest.mark.parametrize("page_addr, byte_addr, result",
+                        [(0, 8, [0x00, 0x08]),
+                         (0, 63, [0x00, 0x3F]),
+                         (511, 63, [0x7F, 0xFF]),
+                         (511, 0, [0x7F, 0xC0])
+                        ])
+def test__pack_mem_address(page_addr, byte_addr, result, eeprom):
+    # pylint: disable=protected-access
+    address_message = eeprom._EdgePiEEPROM__pack_mem_address(page_addr, byte_addr)
+    assert address_message == result
+
+@pytest.mark.parametrize("memory_address, result",
+                        [(0, [0, 0]),
+                         (63, [0, 63]),
+                         (64, [1, 0]),
+                         (32767, [511, 63]),
+                         (32704, [511, 0])
+                        ])
+def test__byte_address_generation(memory_address, result, eeprom):
+    # pylint: disable=protected-access
+    page_addr, byte_addr = eeprom._EdgePiEEPROM__byte_address_generation(memory_address)
+    assert page_addr == result[0]
+    assert byte_addr == result[1]
+
 @pytest.mark.parametrize("reg_addr, mock_val, result", [(1, [23], [23])])
 def test_selective_read(mocker, eeprom, reg_addr, mock_val, result):
     mocker.patch("edgepi.peripherals.i2c.I2CDevice.transfer",return_value = mock_val)