alignment of firmware code

Author: pandiannano

m5stack/libs/driver/bh1750.py

@@ -13,7 +13,6 @@ class Power:
 
 
 class BH1750:
-
     CONTINUOUSLY = 0b00010000
     ONE_TIME = 0b00100000
 

m5stack/libs/driver/button.py

@@ -13,7 +13,6 @@
 
 
 class Button:
-
     NO_ACTIVE = 0
     HOLD = 1
     PRESSED = 2

m5stack/libs/driver/ir/transmitter.py

@@ -27,6 +27,7 @@
 # Shared by NEC
 STOP = const(0)  # End of data
 
+
 # IR abstract base class. Array holds periods in μs between toggling 36/38KHz
 # carrier on or off. Physical transmission occurs in an ISR context controlled
 # by timer 2 and timer 5. See TRANSMITTER.md for details of operation.

m5stack/libs/driver/sh1107.py

@@ -38,10 +38,11 @@ def __init__(self, width, height, external_vcc):
         self.pages = self.height // 8
         self.line_bytes = self.width // 8
         size = self.width * self.height // 8
-        self.curr_buffer = bytearray(b'\x00' * size)  # self.fill(0)
-        self.prev_buffer = bytearray(b'\xff' * size)  # force full refresh
-        super().__init__(self.curr_buffer, self.width, self.height,
-                         MONO_VLSB if self.page_mode else MONO_HMSB)
+        self.curr_buffer = bytearray(b"\x00" * size)  # self.fill(0)
+        self.prev_buffer = bytearray(b"\xff" * size)  # force full refresh
+        super().__init__(
+            self.curr_buffer, self.width, self.height, MONO_VLSB if self.page_mode else MONO_HMSB
+        )
         self.init_display()
         self.fill(0)
         self.show()
@@ -58,22 +59,30 @@ def init_display(self):
             # 0x00 = page, 0x01 = vertical
             SET_MEM_MODE | (0x00 if self.page_mode else 0x01),
             # resolution and layout
-            SET_DISP_START_LINE, 0x00,
+            SET_DISP_START_LINE,
+            0x00,
             SET_SEG_REMAP | 0x00,  # 0x01 rotate 180 deg
             # 0x08 rotate 180 deg
             SET_COM_OUT_DIR | (0x00 if self.page_mode else 0x08),
-            SET_MUX_RATIO, 0x7f,  # always this?
+            SET_MUX_RATIO,
+            0x7F,  # always this?
             # offseted for 64 x 128 (Aliexpress 0.96")
-            SET_DISP_OFFSET, 0x60 if self.width != self.height else 0x00,
+            SET_DISP_OFFSET,
+            0x60 if self.width != self.height else 0x00,
             # timing and driving scheme
-            SET_DISP_CLK_DIV, 0x50,
-            SET_PRECHARGE, 0x22 if self.external_vcc else 0xf1,
-            SET_VCOM_DESEL, 0x35,  # 0.77 * Vcc
-            SET_DCDC_MODE, 0x81,  # on, 0.6 * switch freq
+            SET_DISP_CLK_DIV,
+            0x50,
+            SET_PRECHARGE,
+            0x22 if self.external_vcc else 0xF1,
+            SET_VCOM_DESEL,
+            0x35,  # 0.77 * Vcc
+            SET_DCDC_MODE,
+            0x81,  # on, 0.6 * switch freq
             # display
-            SET_CONTRAST, 0x80,  # very low to avoid uneven background
+            SET_CONTRAST,
+            0x80,  # very low to avoid uneven background
             SET_ENTIRE_ON | 0x00,  # output follows RAM contents, not entire on
-            SET_NORM_INV | 0x00  # 0x00 = not inverted, 0x01 = inverted
+            SET_NORM_INV | 0x00,  # 0x00 = not inverted, 0x01 = inverted
         ):
             self.write_cmd(cmd)
         # buffers are initialized as if self.fill(0) was called
@@ -94,7 +103,7 @@ def invert(self, invert):
         self.write_cmd(SET_NORM_INV | (invert & 1))
 
     def image(self, x, y, filename):
-        with open(filename, 'rb') as f:
+        with open(filename, "rb") as f:
             f.readline()
             f.readline()
             width, height = [int(v) for v in f.readline().split()]
@@ -115,34 +124,42 @@ def show_page_mode(self):
             for col1, col2 in self.test_modified(noffs, self.width):
                 c = col1 - noffs
                 self.write_cmd(SET_PAGE_ADDR | page)
-                self.write_cmd(SET_COL_LO_ADDR | (c & 0x0f))
+                self.write_cmd(SET_COL_LO_ADDR | (c & 0x0F))
                 self.write_cmd(SET_COL_HI_ADDR | ((c & 0x70) >> 4))
-                self.write_data(self.curr_buffer[col1: col2])
+                self.write_data(self.curr_buffer[col1:col2])
                 # print('Write offsets {} : {}, col: {}'.format(col1, col2, c))
 
     def show_vert_mode(self):
         for col in range(self.height):
             noffs = col * self.line_bytes
             for page1, page2 in self.test_modified(noffs, self.line_bytes):
                 self.write_cmd(SET_PAGE_ADDR | (page1 - noffs))
-                self.write_cmd(SET_COL_LO_ADDR | (col & 0x0f))
+                self.write_cmd(SET_COL_LO_ADDR | (col & 0x0F))
                 self.write_cmd(SET_COL_HI_ADDR | ((col & 0x70) >> 4))
-                self.write_data(self.curr_buffer[page1: page2])
+                self.write_data(self.curr_buffer[page1:page2])
                 # print('Write offsets {} : {}, page: {}'.format(page1, page2, page1 - noffs))
 
     def test_modified(self, offs, width):
         ptr = offs
         width += offs
         while ptr < width:
             # skip unmodified chunks
-            while ptr < width and self.curr_buffer[ptr: ptr + TEST_CHUNK] == self.prev_buffer[ptr: ptr + TEST_CHUNK]:
+            while (
+                ptr < width
+                and self.curr_buffer[ptr : ptr + TEST_CHUNK]
+                == self.prev_buffer[ptr : ptr + TEST_CHUNK]
+            ):
                 ptr += TEST_CHUNK
 
             if ptr < width:
                 first = ptr
                 ptr += TEST_CHUNK
                 # find modified chunks
-                while ptr < width and self.curr_buffer[ptr:ptr + TEST_CHUNK] != self.prev_buffer[ptr:ptr + TEST_CHUNK]:
+                while (
+                    ptr < width
+                    and self.curr_buffer[ptr : ptr + TEST_CHUNK]
+                    != self.prev_buffer[ptr : ptr + TEST_CHUNK]
+                ):
                     ptr += TEST_CHUNK
 
                 yield first, ptr
@@ -154,7 +171,7 @@ def __init__(self, width, height, i2c, addr=0x3C, external_vcc=False):
         self.i2c = i2c
         self.i2c_addr = addr
         self.temp = bytearray(2)
-        self.write_list = [b'\x40', None]  # Co=0, D/C#=1
+        self.write_list = [b"\x40", None]  # Co=0, D/C#=1
         super().__init__(width, height, external_vcc)
 
     def write_cmd(self, cmd):

m5stack/libs/driver/sht4x.py

@@ -131,17 +131,15 @@ def measure(self) -> Tuple[float, float]:
         self.i2c_device.writeto(self.sht4x_i2c_addr, bytearray([command]))
         time.sleep(Mode.delay[self._mode])
         self._buffer = self.i2c_device.readfrom(self.sht4x_i2c_addr, 6)
-        
+
         # separate the read data
         temp_data = self._buffer[0:2]
         temp_crc = self._buffer[2]
         humidity_data = self._buffer[3:5]
         humidity_crc = self._buffer[5]
 
         # check CRC of bytes
-        if temp_crc != self._crc8(temp_data) or humidity_crc != self._crc8(
-            humidity_data
-        ):
+        if temp_crc != self._crc8(temp_data) or humidity_crc != self._crc8(humidity_data):
             raise RuntimeError("Invalid CRC calculated")
 
         # decode data into human values:
@@ -172,4 +170,4 @@ def _crc8(buffer) -> int:
                     crc = (crc << 1) ^ 0x31
                 else:
                     crc = crc << 1
-        return crc & 0xFF  # return the bottom 8 bits
+        return crc & 0xFF  # return the bottom 8 bits

m5stack/libs/unit/hbridge.py

@@ -12,15 +12,16 @@
 
 HBRIDGE_ADDR = 0x20
 
-DIRECTION_REG           = 0x00
-PWM8BIT_REG             = 0x01
-PWM16BIT_REG            = 0x02
-PWMFREQ_REG             = 0x04
-ADC8BIT_REG             = 0x10
-ADC16BIT_REG            = 0x20
-VIN_CURRENT_REG         = 0x30
-I2C_ADDR_REG            = 0xFF
-FW_VER_REG              = 0xFE
+DIRECTION_REG = 0x00
+PWM8BIT_REG = 0x01
+PWM16BIT_REG = 0x02
+PWMFREQ_REG = 0x04
+ADC8BIT_REG = 0x10
+ADC16BIT_REG = 0x20
+VIN_CURRENT_REG = 0x30
+I2C_ADDR_REG = 0xFF
+FW_VER_REG = 0xFE
+
 
 class HBRIDGE:
     def __init__(self, i2c: Union[I2C, PAHUB], slave_addr=HBRIDGE_ADDR):
@@ -30,8 +31,8 @@ def __init__(self, i2c: Union[I2C, PAHUB], slave_addr=HBRIDGE_ADDR):
         """
         self.hbridge_i2c = i2c
         self.init_i2c_address(slave_addr)
-    
-    def init_i2c_address(self, slave_addr = HBRIDGE_ADDR):
+
+    def init_i2c_address(self, slave_addr=HBRIDGE_ADDR):
         """
         init the i2c address
         slave_addr : 0x20 to 0x2F
@@ -40,7 +41,7 @@ def init_i2c_address(self, slave_addr = HBRIDGE_ADDR):
             self.i2c_addr = slave_addr
         if not (self.i2c_addr in self.hbridge_i2c.scan()):
             raise UnitError("Hbridge unit maybe not connect")
-    
+
     def get_driver_config(self, reg=0):
         """
         get driver config value
@@ -49,7 +50,7 @@ def get_driver_config(self, reg=0):
         if reg > 1:
             leng = 2
             buf = self.read_reg(reg, leng)
-            return struct.unpack('<H', buf)[0]
+            return struct.unpack("<H", buf)[0]
         else:
             return self.read_reg(reg, leng)[0]
 
@@ -59,29 +60,29 @@ def set_direction(self, dir=0):
         dir : 0 stop, 1 forward, 2 reverse
         """
         self.write_mem_list(DIRECTION_REG, [dir])
-    
+
     def set_8bit_pwm(self, duty=0):
         """
         set 8bit pwm dutycycle
         duty : 0 to 255
         """
         self.write_mem_list(PWM8BIT_REG, [duty])
-    
+
     def set_16bit_pwm(self, duty=0):
         """
         set 16bit pwm dutycycle
         duty : 0 to 65535
         """
-        self.write_mem_list(PWM16BIT_REG, [(duty & 0xff), ((duty >> 8) & 0xff)])
+        self.write_mem_list(PWM16BIT_REG, [(duty & 0xFF), ((duty >> 8) & 0xFF)])
 
     def set_pwm_freq(self, freq=0):
         """
         set direction
         duty : 0 to 65535
         """
-        freq = max(min(freq, 10000),100)
-        self.write_mem_list(PWMFREQ_REG, [(freq & 0xff), ((freq >> 8) & 0xff)])
-    
+        freq = max(min(freq, 10000), 100)
+        self.write_mem_list(PWMFREQ_REG, [(freq & 0xFF), ((freq >> 8) & 0xFF)])
+
     def get_adc_value(self, raw=0, res=8):
         """
         get adc value
@@ -90,48 +91,50 @@ def get_adc_value(self, raw=0, res=8):
         if res > 8:
             leng = 2
             buf = self.read_reg(ADC16BIT_REG, leng)
-            val = struct.unpack('<H', buf)[0]
+            val = struct.unpack("<H", buf)[0]
             res = 4095
         else:
             val = self.read_reg(ADC8BIT_REG, leng)[0]
             res = 255
         if raw:
             return val
         else:
-            val = (3.3/res) * val * 11
+            val = (3.3 / res) * val * 11
             return round(val, 2)
-        
-#############################support v1.1################################
+
+    #############################support v1.1################################
     def get_vin_current(self):
         """
         get vin current.
         """
         buf = self.read_reg(VIN_CURRENT_REG, 4)
-        return struct.unpack('<f', buf)[0]
-#############################support v1.1################################
-    
+        return struct.unpack("<f", buf)[0]
+
+    #############################support v1.1################################
+
     def get_device_status(self, mode):
         """
         get firmware version and i2c address.
-        mode : 0xFE and 0xFF 
+        mode : 0xFE and 0xFF
         """
         if mode >= FW_VER_REG and mode <= I2C_ADDR_REG:
             return self.read_reg(mode, 1)[0]
-    
+
     def write_mem_list(self, reg, data):
         buf = bytearray(data)
         self.hbridge_i2c.writeto_mem(self.i2c_addr, reg, buf)
-    
+
     def read_reg(self, reg, num):
         return self.hbridge_i2c.readfrom_mem(self.i2c_addr, reg, num)
-    
+
     def deinit(self):
-        pass   
-    
-'''
+        pass
+
+
+"""
 if __name__ == "__main__":
     import unit
     hbridge = unit.get(unit.HBRIDGE, unit.PORTA)
     hbridge.get_driver_config(0)
     hbridge.get_driver_config(1)
-'''
+"""