refactoring and linting

Author: siddacious

adafruit_mcp4728.py

@@ -33,7 +33,6 @@
 
 **Hardware:**
 
-.. todo:: Update the PID for the below and add links to any specific hardware product page(s), or category page(s)
 * Adafruit's MCP4728 Breakout: https://adafruit.com/product/44XX
 
 **Software and Dependencies:**
@@ -48,12 +47,9 @@
 
 from time import sleep
 import adafruit_bus_device.i2c_device as i2c_device
-from adafruit_register.i2c_struct import UnaryStruct, ROUnaryStruct
-from adafruit_register.i2c_struct_array import StructArray
-from adafruit_register.i2c_bit import RWBit
-from adafruit_register.i2c_bits import RWBits
+from adafruit_register.i2c_struct import UnaryStruct
 
-_MCP4728_DEFAULT_ADDRESS = 0x60 
+_MCP4728_DEFAULT_ADDRESS = 0x60
 
 """
 # DAC1, DAC0 DAC Channel Selection bits:
@@ -64,7 +60,7 @@
 
 0 = slave addr(auto)
 0 1 0 0 0 DAC1 DAC0 UDAC[A]
-01000 + 00 + UDAC = 
+01000 + 00 + UDAC =
 0b01000000 = 0x40 (+2 for each successive)
 VREF PD1 PD0 Gx D11 D10 D9 D8 [A]
 D7 D6 D5 D4 D3 D2 D1 D0 [A]
@@ -78,21 +74,20 @@
 1 0 1 0 0 Write Power-Down bits to Input Registers
 """
 
-'0b 010 00 000'
 _MCP4728_CH_A_MULTI_IB = 0x40
 _MCP4728_CH_B_MULTI_IB = 0x42
 _MCP4728_CH_C_MULTI_IB = 0x44
 _MCP4728_CH_D_MULTI_IB = 0x46
 
-'0b 010 11 000'
 _MCP4728_CH_A_SINGLE_EEPROM = 0x58
 _MCP4728_CH_B_SINGLE_EEPROM = 0x5A
 _MCP4728_CH_C_SINGLE_EEPROM = 0x5C
 _MCP4728_CH_D_SINGLE_EEPROM = 0x5E
 
-'0b 010 10 000'
 _MCP4728_CH_A_MULTI_EEPROM = 0x50
 
+#TODO: REMOVE THIS
+#pylint: disable=unused-variable,no-self-use,invalid-name,too-few-public-methods
 class MCP4728:
     """Helper library for the Microchip MCP4728 I2C 12-bit Quad DAC.
 
@@ -103,7 +98,7 @@ class MCP4728:
     _channel_a_single_write_eeprom = UnaryStruct(_MCP4728_CH_A_SINGLE_EEPROM, ">H")
     _channel_b_single_write_eeprom = UnaryStruct(_MCP4728_CH_B_SINGLE_EEPROM, ">H")
     _channel_c_single_write_eeprom = UnaryStruct(_MCP4728_CH_C_SINGLE_EEPROM, ">H")
-    _channel_d_single_write_eeprom = UnaryStruct(_MCP4728_CH_D_SINGLE_EEPROM, ">H") 
+    _channel_d_single_write_eeprom = UnaryStruct(_MCP4728_CH_D_SINGLE_EEPROM, ">H")
 
     _channel_a_multi_write = UnaryStruct(_MCP4728_CH_A_MULTI_IB, ">H")
     _channel_b_multi_write = UnaryStruct(_MCP4728_CH_B_MULTI_IB, ">H")
@@ -113,145 +108,134 @@ class MCP4728:
     _multi_write_channel_a_start = UnaryStruct(_MCP4728_CH_A_MULTI_EEPROM, ">HHHH")
 
     def __init__(self, i2c_bus, address=_MCP4728_DEFAULT_ADDRESS):
-        self.i2c_device = i2c_device.I2CDevice(i2c_bus, address)
-
-    @property
-    def channel_a(self):
-        """channel a's current value"""
-        return "hamsters"
-    
-    @channel_a.setter
-    def channel_a(self, value):
-        self._channel_a_multi = value
-
 
-    @property
-    def channel_b(self):
-        """channel b's current value"""
-        return "elves"
-    
-    @channel_b.setter
-    def channel_b(self, value):
-        self._channel_b_multi = value
-
-    @property
-    def channel_c(self):
-        """channel c's current value"""
-        return "pancakes"
-    
-    @channel_c.setter
-    def channel_c(self, value):
-        self._channel_c_multi = value
+        self.i2c_device = i2c_device.I2CDevice(i2c_bus, address)
+        self._create_channels()
 
-    @property
-    def channel_d(self):
-        """channel d's current value"""
-        return "gummies"
-    
-    @channel_d.setter
-    def channel_d(self, value):
-        self._channel_d_multi = value
-
-
-    def write_init(self, register_address, struct_format):
-        self.format = struct_format
-        self.address = register_address
-
-    # def read(self, obj):
-    #     buf = bytearray(1+struct.calcsize(self.format))
-    #     buf[0] = self.address
-    #     with self.i2c_device as i2c:
-    #         i2c.write_then_readinto(buf, buf, out_end=1, in_start=1)
-    #     return struct.unpack_from(self.format, buf, 1)[0]
-
-    # def write(self, obj, value):
-    #     buf = bytearray(1+struct.calcsize(self.format))
-    #     buf[0] = self.address
-    #     struct.pack_into(self.format, buf, 1, value)
-    #     with self.i2c_device as i2c:
-    #         i2c.write(buf)
-    def chunks(self, l, n):
+    def _chunk(self, l, n):
         # For item i in a range that is a length of l,
         for i in range(0, len(l), n):
             # Create an index range for l of n items:
             yield l[i:i+n]
 
-    def get_flags(self, high_byte):
+    def _lzb(self, byte_val): # leading zero bin
+        return format(byte_val, '#010b')
+
+    def _get_flags(self, high_byte):
         vref = (high_byte & 1<<7) > 0
         gain = (high_byte & 1<<4) > 0
         pd = (high_byte & 0b011<<5)>>5
         return (vref, gain, pd)
 
-    def read_registers(self):
+    def _cache_page(self, value, vref, gain, pd):
+        return {"value": value, "vref": vref, "gain": gain, "pd": pd}
+
+    def _create_channels(self):
+        raw_registers = self._read_registers()
+
+        self.channel_a = Channel(self._cache_page(*raw_registers[0]))
+        self.channel_b = Channel(self._cache_page(*raw_registers[1]))
+        self.channel_c = Channel(self._cache_page(*raw_registers[2]))
+        self.channel_d = Channel(self._cache_page(*raw_registers[3]))
+
+    def _read_registers(self):
         buf = bytearray(24)
 
         with self.i2c_device as i2c:
             i2c.readinto(buf)
         index = 0
         for index, value in enumerate(buf):
-            if index %3 is 0:
+            if index %3 == 0:
                 print("\n%4s\t"%index, end="")
-            print("%s %s "%( format(value, '#010b'), hex(value)), end="")
+            print("%s %s "%(format(value, '#010b'), hex(value)), end="")
         print()
-        # stride is 6 because we get 6 bytes for each channel; 3 for the output regs 
-        # and 3 for the eeprom. here we only care about the output buffer
+
+        # stride is 6 because we get 6 bytes for each channel; 3 for the output regs
+        # and 3 for the eeprom. here we only care about the output buffer so we throw out
+        # the eeprom values as 'n/a'
         current_values = []
-        for header, high_byte, low_byte, na_1, na_2, na_3 in self.chunks(buf,6):
+        for header, high_byte, low_byte, na_1, na_2, na_3 in self._chunk(buf, 6):
             value = (high_byte & 0b00001111) << 8 | low_byte
-            vref, gain, pd = self.get_flags(high_byte)
-            current_values << (value, vref, pd, gain)
+            vref, gain, pd = self._get_flags(high_byte)
+            current_values.append((value, vref, gain, pd))
 
         return current_values
-        # ch_a_header, ch_a_hb, ch_a_lb = buf[0:3]
-        # ch_aee_header, ch_aee_hb, ch_aee_lb = buf[3:6]
-        # # ch_c_header, ch_c_hb, ch_c_lb = buf[6:9]
-        # # ch_d_header, ch_d_hb, ch_d_lb = buf[9:12]
 
-        # ch_a_val = 
 
-        # print("%s %s %s"%( self.b(ch_a_header),self.b(ch_a_hb), self.b(ch_a_lb) ))
-        # print("%s %s %s"%( self.b(ch_b_header),self.b(ch_b_hb), self.b(ch_b_lb) ))
-        # # print("%s %s %s"%( self.b(ch_c_header),self.b(ch_c_hb), self.b(ch_c_lb) ))
-        # # print("%s %s %s"%( self.b(ch_d_header),self.b(ch_d_hb), self.b(ch_d_lb) ))
-
-    def b(self, byte_val):
-        return format(byte_val, '#010b')
-
-    def write_multi_eeprom(self, byte_list, start=0):
+    # TODO: add the ability to set an offset
+    def _write_multi_eeprom(self, byte_list):
         buffer_list = [_MCP4728_CH_A_MULTI_EEPROM]
         buffer_list += byte_list
-        print("Byte List:")
-        print(buffer_list)
+
         buf = bytearray(buffer_list)
-        # struct.pack_into(self.format, buf, 1, value)
         with self.i2c_device as i2c:
             i2c.write(buf)
 
+        sleep(0.015) # the better to write you with
 
 
-        
+class Channel:
+    """An instance of a single channel for a multi-channel DAC"""
+    def __init__(self, cache_page):
+        self._vref = cache_page['vref']
+        self._gain = cache_page['gain']
+        self._raw_value = cache_page['value']
 
+    @property
+    def normalized_value(self):
+        """The DAC value as a floating point number in the range 0.0 to 1.0."""
+        return self._raw_value / (2**12-1)
+
+    @normalized_value.setter
+    def normalized_value(self, value):
+        if value < 0.0 or value > 1.0:
+            raise AttributeError("`normalized_value` must be between 0.0 and 1.0")
+
+        self._raw_value = int(value * 4095.0)
 
     @property
-    def ch_a(self):
-        return "poo"
+    def value(self):
+        """The 16-bit scaled current value for the channel. Note that the MCP4728 is a 12-bit piece
+        so quantization errors will occour"""
+        return self.normalized_value * (2**16-1)
 
-    @ch_a.setter
-    def ch_a(self, value):
-        self._channel_a_multi = value
+    @value.setter
+    def value(self, value):
+        if value < 0 or value > (2**16-1):
+            raise AttributeError("`value` must be a 16-bit integer between 0 and %s"%(2**16-1))
 
-"""
-# set the gain for a channel
-    cache each, set all?
+        # Scale from 16-bit to 12-bit value (quantization errors will occur!).
+        self._raw_value = value >> 4
 
-# set reference source for a channel
-    cache each, set all?
+    @property
+    def raw_value(self):
+        """The native 12-bit value used by the DAC"""
+        return self._raw_value
 
-# save settings to eeprom
+    @raw_value.setter
+    def raw_value(self, value):
+        if value < 0 or value > (2**12-1):
+            raise AttributeError("`raw_value` must be a 12-bit integer between 0 and %s"%(2**12-1))
+        self._raw_value = value
 
-# write a channel 
+    @property
+    def gain(self):
+        """Sets the gain of the channel. Must be 1 or 2"""
+        return self._gain
 
-# write all channels
+    @gain.setter
+    def gain(self, value):
+        if value < 1 or value > 2:
+            raise AttributeError("`gain` must be 1 or 2")
+        self._vref = value
 
-# latching?
-"""
+    @property
+    def vref(self):
+        """Sets the DAC's voltage reference source. Must be a ``VREF``"""
+        return self._vref
+
+    @vref.setter
+    def vref(self, value):
+        if value < 0 or value > 3:
+            raise AttributeError("`vref` must be a ``VREF``")
+        self._vref = value

examples/mcp4728_simpletest.py

@@ -1,14 +1,11 @@
-import time
 import board
 import busio
 import adafruit_mcp4728
 
 i2c = busio.I2C(board.SCL, board.SDA)
 mcp4728 =  adafruit_mcp4728.MCP4728(i2c)
 
-
-mcp4728.channel_a = 4095 # Voltage = VCC
-mcp4728.channel_b = 2048 # VCC/2
-mcp4728.channel_c = 1024 # VCC/4 
-mcp4728.channel_d = 512  # VCC/8
-
+mcp4728.channel_a.value = 4095 # Voltage = VCC
+mcp4728.channel_b.value = 2048 # VCC/2
+mcp4728.channel_c.value = 1024 # VCC/4
+mcp4728.channel_d.value = 512  # VCC/8

examples/mcp4728_sine_wave.py

@@ -1,8 +1,7 @@
-import time
+import math
 import board
 import busio
 import adafruit_mcp4728
-import math
 i2c = busio.I2C(board.SCL, board.SDA, frequency=3200000)
 
 mcp4728 =  adafruit_mcp4728.MCP4728(i2c)