all: Reformat C and Python source code with tools/codeformat.py.

This is run with uncrustify 0.70.1, and black 19.10b0.

3 files changed, 155 insertions, 120 deletions

diff --git a/drivers/display/lcd160cr.py b/drivers/display/lcd160cr.py
index cf562a40d..f792418aa 100644
--- a/drivers/display/lcd160cr.py
+++ b/drivers/display/lcd160cr.py
@@ -29,16 +29,17 @@ _uart_baud_table = {
     460800: 8,
 }
 
+
 class LCD160CR:
     def __init__(self, connect=None, *, pwr=None, i2c=None, spi=None, i2c_addr=98):
-        if connect in ('X', 'Y', 'XY', 'YX'):
+        if connect in ("X", "Y", "XY", "YX"):
             i = connect[-1]
             j = connect[0]
-            y = j + '4'
-        elif connect == 'C':
+            y = j + "4"
+        elif connect == "C":
             i = 2
             j = 2
-            y = 'A7'
+            y = "A7"
         else:
             if pwr is None or i2c is None or spi is None:
                 raise ValueError('must specify valid "connect" or all of "pwr", "i2c" and "spi"')
@@ -74,8 +75,8 @@ class LCD160CR:
 
         # set default orientation and window
         self.set_orient(PORTRAIT)
-        self._fcmd2b('<BBBBBB', 0x76, 0, 0, self.w, self.h) # viewport 'v'
-        self._fcmd2b('<BBBBBB', 0x79, 0, 0, self.w, self.h) # window 'y'
+        self._fcmd2b("<BBBBBB", 0x76, 0, 0, self.w, self.h)  # viewport 'v'
+        self._fcmd2b("<BBBBBB", 0x79, 0, 0, self.w, self.h)  # window 'y'
 
     def _send(self, cmd):
         i = self.i2c.writeto(self.i2c_addr, cmd)
@@ -135,7 +136,7 @@ class LCD160CR:
 
     @staticmethod
     def rgb(r, g, b):
-        return ((b & 0xf8) << 8) | ((g & 0xfc) << 3) | (r >> 3)
+        return ((b & 0xF8) << 8) | ((g & 0xFC) << 3) | (r >> 3)
 
     @staticmethod
     def clip_line(c, w, h):
@@ -207,43 +208,43 @@ class LCD160CR:
         sleep_ms(15)
 
     def set_orient(self, orient):
-        self._fcmd2('<BBB', 0x14, (orient & 3) + 4)
+        self._fcmd2("<BBB", 0x14, (orient & 3) + 4)
         # update width and height variables
         self.iflush()
-        self._send(b'\x02g0')
+        self._send(b"\x02g0")
         self._waitfor(4, self.buf[5])
         self.w = self.buf[5][1]
         self.h = self.buf[5][2]
 
     def set_brightness(self, value):
-        self._fcmd2('<BBB', 0x16, value)
+        self._fcmd2("<BBB", 0x16, value)
 
     def set_i2c_addr(self, addr):
         # 0x0e set i2c addr
         if addr & 3:
-            raise ValueError('must specify mod 4 aligned address')
-        self._fcmd2('<BBW', 0x0e, 0x433249 | (addr << 24))
+            raise ValueError("must specify mod 4 aligned address")
+        self._fcmd2("<BBW", 0x0E, 0x433249 | (addr << 24))
 
     def set_uart_baudrate(self, baudrate):
         try:
             baudrate = _uart_baud_table[baudrate]
         except KeyError:
-            raise ValueError('invalid baudrate')
-        self._fcmd2('<BBB', 0x18, baudrate)
+            raise ValueError("invalid baudrate")
+        self._fcmd2("<BBB", 0x18, baudrate)
 
     def set_startup_deco(self, value):
-        self._fcmd2('<BBB', 0x19, value)
+        self._fcmd2("<BBB", 0x19, value)
 
     def save_to_flash(self):
-        self._send(b'\x02fn')
+        self._send(b"\x02fn")
 
     #### PIXEL ACCESS ####
 
     def set_pixel(self, x, y, c):
-        self._fcmd2b('<BBBBH', 0x41, x, y, c)
+        self._fcmd2b("<BBBBH", 0x41, x, y, c)
 
     def get_pixel(self, x, y):
-        self._fcmd2('<BBBB', 0x61, x, y)
+        self._fcmd2("<BBBB", 0x61, x, y)
         t = 1000
         while t:
             self.i2c.readfrom_into(self.i2c_addr, self.buf1)
@@ -256,7 +257,7 @@ class LCD160CR:
 
     def get_line(self, x, y, buf):
         l = len(buf) // 2
-        self._fcmd2b('<BBBBB', 0x10, l, x, y)
+        self._fcmd2b("<BBBBB", 0x10, l, x, y)
         l *= 2
         t = 1000
         while t:
@@ -280,42 +281,47 @@ class LCD160CR:
             # split line if more than 254 bytes needed
             buflen = (w + 1) // 2
             line = bytearray(2 * buflen + 1)
-            line2 = memoryview(line)[:2 * (w - buflen) + 1]
+            line2 = memoryview(line)[: 2 * (w - buflen) + 1]
         for i in range(min(len(buf) // (2 * w), h)):
             ix = i * w * 2
             self.get_line(x, y + i, line)
-            buf[ix:ix + len(line) - 1] = memoryview(line)[1:]
+            buf[ix : ix + len(line) - 1] = memoryview(line)[1:]
             ix += len(line) - 1
             if line2:
                 self.get_line(x + buflen, y + i, line2)
-                buf[ix:ix + len(line2) - 1] = memoryview(line2)[1:]
+                buf[ix : ix + len(line2) - 1] = memoryview(line2)[1:]
                 ix += len(line2) - 1
 
     def screen_load(self, buf):
-        l = self.w * self.h * 2+2
-        self._fcmd2b('<BBHBBB', 0x70, l, 16, self.w, self.h)
+        l = self.w * self.h * 2 + 2
+        self._fcmd2b("<BBHBBB", 0x70, l, 16, self.w, self.h)
         n = 0
         ar = memoryview(buf)
         while n < len(buf):
             if len(buf) - n >= 0x200:
-                self._send(ar[n:n + 0x200])
+                self._send(ar[n : n + 0x200])
                 n += 0x200
             else:
                 self._send(ar[n:])
                 while n < self.w * self.h * 2:
-                    self._send(b'\x00')
+                    self._send(b"\x00")
                     n += 1
 
     #### TEXT COMMANDS ####
 
     def set_pos(self, x, y):
-        self._fcmd2('<BBBB', 0x58, x, y)
+        self._fcmd2("<BBBB", 0x58, x, y)
 
     def set_text_color(self, fg, bg):
-        self._fcmd2('<BBHH', 0x63, fg, bg)
+        self._fcmd2("<BBHH", 0x63, fg, bg)
 
     def set_font(self, font, scale=0, bold=0, trans=0, scroll=0):
-        self._fcmd2('<BBBB', 0x46, (scroll << 7) | (trans << 6) | ((font & 3) << 4) | (bold & 0xf), scale & 0xff)
+        self._fcmd2(
+            "<BBBB",
+            0x46,
+            (scroll << 7) | (trans << 6) | ((font & 3) << 4) | (bold & 0xF),
+            scale & 0xFF,
+        )
 
     def write(self, s):
         # TODO: eventually check for room in LCD input queue
@@ -324,14 +330,14 @@ class LCD160CR:
     #### PRIMITIVE DRAWING COMMANDS ####
 
     def set_pen(self, line, fill):
-        self._fcmd2('<BBHH', 0x50, line, fill)
+        self._fcmd2("<BBHH", 0x50, line, fill)
 
     def erase(self):
-        self._send(b'\x02\x45')
+        self._send(b"\x02\x45")
 
     def dot(self, x, y):
         if 0 <= x < self.w and 0 <= y < self.h:
-            self._fcmd2('<BBBB', 0x4b, x, y)
+            self._fcmd2("<BBBB", 0x4B, x, y)
 
     def rect(self, x, y, w, h, cmd=0x72):
         if x + w <= 0 or y + h <= 0 or x >= self.w or y >= self.h:
@@ -348,19 +354,19 @@ class LCD160CR:
                 y = 0
             if cmd == 0x51 or cmd == 0x72:
                 # draw interior
-                self._fcmd2b('<BBBBBB', 0x51, x, y, min(w, 255), min(h, 255))
+                self._fcmd2b("<BBBBBB", 0x51, x, y, min(w, 255), min(h, 255))
             if cmd == 0x57 or cmd == 0x72:
                 # draw outline
                 if left:
-                    self._fcmd2b('<BBBBBB', 0x57, x, y, 1, min(h, 255))
+                    self._fcmd2b("<BBBBBB", 0x57, x, y, 1, min(h, 255))
                 if top:
-                    self._fcmd2b('<BBBBBB', 0x57, x, y, min(w, 255), 1)
+                    self._fcmd2b("<BBBBBB", 0x57, x, y, min(w, 255), 1)
                 if x + w < self.w:
-                    self._fcmd2b('<BBBBBB', 0x57, x + w, y, 1, min(h, 255))
+                    self._fcmd2b("<BBBBBB", 0x57, x + w, y, 1, min(h, 255))
                 if y + h < self.h:
-                    self._fcmd2b('<BBBBBB', 0x57, x, y + h, min(w, 255), 1)
+                    self._fcmd2b("<BBBBBB", 0x57, x, y + h, min(w, 255), 1)
         else:
-            self._fcmd2b('<BBBBBB', cmd, x, y, min(w, 255), min(h, 255))
+            self._fcmd2b("<BBBBBB", cmd, x, y, min(w, 255), min(h, 255))
 
     def rect_outline(self, x, y, w, h):
         self.rect(x, y, w, h, 0x57)
@@ -375,48 +381,48 @@ class LCD160CR:
         ar4[2] = x2
         ar4[3] = y2
         if self.clip_line(ar4, self.w, self.h):
-            self._fcmd2b('<BBBBBB', 0x4c, ar4[0], ar4[1], ar4[2], ar4[3])
+            self._fcmd2b("<BBBBBB", 0x4C, ar4[0], ar4[1], ar4[2], ar4[3])
 
     def dot_no_clip(self, x, y):
-        self._fcmd2('<BBBB', 0x4b, x, y)
+        self._fcmd2("<BBBB", 0x4B, x, y)
 
     def rect_no_clip(self, x, y, w, h):
-        self._fcmd2b('<BBBBBB', 0x72, x, y, w, h)
+        self._fcmd2b("<BBBBBB", 0x72, x, y, w, h)
 
     def rect_outline_no_clip(self, x, y, w, h):
-        self._fcmd2b('<BBBBBB', 0x57, x, y, w, h)
+        self._fcmd2b("<BBBBBB", 0x57, x, y, w, h)
 
     def rect_interior_no_clip(self, x, y, w, h):
-        self._fcmd2b('<BBBBBB', 0x51, x, y, w, h)
+        self._fcmd2b("<BBBBBB", 0x51, x, y, w, h)
 
     def line_no_clip(self, x1, y1, x2, y2):
-        self._fcmd2b('<BBBBBB', 0x4c, x1, y1, x2, y2)
+        self._fcmd2b("<BBBBBB", 0x4C, x1, y1, x2, y2)
 
     def poly_dot(self, data):
         if len(data) & 1:
-            raise ValueError('must specify even number of bytes')
-        self._fcmd2('<BBB', 0x71, len(data) // 2)
+            raise ValueError("must specify even number of bytes")
+        self._fcmd2("<BBB", 0x71, len(data) // 2)
         self._send(data)
 
     def poly_line(self, data):
         if len(data) & 1:
-            raise ValueError('must specify even number of bytes')
-        self._fcmd2('<BBB', 0x78, len(data) // 2)
+            raise ValueError("must specify even number of bytes")
+        self._fcmd2("<BBB", 0x78, len(data) // 2)
         self._send(data)
 
     #### TOUCH COMMANDS ####
 
     def touch_config(self, calib=False, save=False, irq=None):
-        self._fcmd2('<BBBB', 0x7a, (irq is not None) << 2 | save << 1 | calib, bool(irq) << 7)
+        self._fcmd2("<BBBB", 0x7A, (irq is not None) << 2 | save << 1 | calib, bool(irq) << 7)
 
     def is_touched(self):
-        self._send(b'\x02T')
+        self._send(b"\x02T")
         b = self.buf[4]
         self._waitfor(3, b)
         return b[1] >> 7 != 0
 
     def get_touch(self):
-        self._send(b'\x02T') # implicit LCD output flush
+        self._send(b"\x02T")  # implicit LCD output flush
         b = self.buf[4]
         self._waitfor(3, b)
         return b[1] >> 7, b[2], b[3]
@@ -424,11 +430,13 @@ class LCD160CR:
     #### ADVANCED COMMANDS ####
 
     def set_spi_win(self, x, y, w, h):
-        pack_into('<BBBHHHHHHHH', self.buf19, 0, 2, 0x55, 10, x, y, x + w - 1, y + h - 1, 0, 0, 0, 0xffff)
+        pack_into(
+            "<BBBHHHHHHHH", self.buf19, 0, 2, 0x55, 10, x, y, x + w - 1, y + h - 1, 0, 0, 0, 0xFFFF
+        )
         self._send(self.buf19)
 
     def fast_spi(self, flush=True):
-        self._send(b'\x02\x12')
+        self._send(b"\x02\x12")
         if flush:
             self.oflush()
         return self.spi
@@ -437,27 +445,27 @@ class LCD160CR:
         self.fast_spi().write(buf)
 
     def set_scroll(self, on):
-        self._fcmd2('<BBB', 0x15, on)
+        self._fcmd2("<BBB", 0x15, on)
 
-    def set_scroll_win(self, win, x=-1, y=0, w=0, h=0, vec=0, pat=0, fill=0x07e0, color=0):
-        pack_into('<BBBHHHHHHHH', self.buf19, 0, 2, 0x55, win, x, y, w, h, vec, pat, fill, color)
+    def set_scroll_win(self, win, x=-1, y=0, w=0, h=0, vec=0, pat=0, fill=0x07E0, color=0):
+        pack_into("<BBBHHHHHHHH", self.buf19, 0, 2, 0x55, win, x, y, w, h, vec, pat, fill, color)
         self._send(self.buf19)
 
     def set_scroll_win_param(self, win, param, value):
-        self._fcmd2b('<BBBBH', 0x75, win, param, value)
+        self._fcmd2b("<BBBBH", 0x75, win, param, value)
 
     def set_scroll_buf(self, s):
         l = len(s)
         if l > 32:
-            raise ValueError('length must be 32 or less')
-        self._fcmd2('<BBB', 0x11, l)
+            raise ValueError("length must be 32 or less")
+        self._fcmd2("<BBB", 0x11, l)
         self._send(s)
 
     def jpeg_start(self, l):
-        if l > 0xffff:
-            raise ValueError('length must be 65535 or less')
+        if l > 0xFFFF:
+            raise ValueError("length must be 65535 or less")
         self.oflush()
-        self._fcmd2('<BBH', 0x6a, l)
+        self._fcmd2("<BBH", 0x6A, l)
 
     def jpeg_data(self, buf):
         self._send(buf)
@@ -467,8 +475,8 @@ class LCD160CR:
         self.jpeg_data(buf)
 
     def feed_wdt(self):
-        self._send(b'\x02\x17')
+        self._send(b"\x02\x17")
 
     def reset(self):
-        self._send(b'\x02Y\xef\xbe\xad\xde')
+        self._send(b"\x02Y\xef\xbe\xad\xde")
         sleep_ms(15)
diff --git a/drivers/display/lcd160cr_test.py b/drivers/display/lcd160cr_test.py
index 8b7ef4555..883c7d3b7 100644
--- a/drivers/display/lcd160cr_test.py
+++ b/drivers/display/lcd160cr_test.py
@@ -3,11 +3,13 @@
 
 import time, math, framebuf, lcd160cr
 
+
 def get_lcd(lcd):
     if type(lcd) is str:
         lcd = lcd160cr.LCD160CR(lcd)
     return lcd
 
+
 def show_adc(lcd, adc):
     data = [adc.read_core_temp(), adc.read_core_vbat(), 3.3]
     try:
@@ -21,24 +23,26 @@ def show_adc(lcd, adc):
             lcd.set_pos(0, 100 + i * 16)
         else:
             lcd.set_font(2, trans=1)
-            lcd.set_pos(0, lcd.h-60 + i * 16)
-        lcd.write('%4s: ' % ('TEMP', 'VBAT', 'VREF')[i])
+            lcd.set_pos(0, lcd.h - 60 + i * 16)
+        lcd.write("%4s: " % ("TEMP", "VBAT", "VREF")[i])
         if i > 0:
-            s = '%6.3fV' % data[i]
+            s = "%6.3fV" % data[i]
         else:
-            s = '%5.1f°C' % data[i]
+            s = "%5.1f°C" % data[i]
         if lcd.h == 160:
             lcd.set_font(1, bold=0, scale=1)
         else:
             lcd.set_font(1, bold=0, scale=1, trans=1)
-            lcd.set_pos(45, lcd.h-60 + i * 16)
+            lcd.set_pos(45, lcd.h - 60 + i * 16)
         lcd.write(s)
 
+
 def test_features(lcd, orient=lcd160cr.PORTRAIT):
     # if we run on pyboard then use ADC and RTC features
     try:
         import pyb
-        adc = pyb.ADCAll(12, 0xf0000)
+
+        adc = pyb.ADCAll(12, 0xF0000)
         rtc = pyb.RTC()
     except:
         adc = None
@@ -53,7 +57,7 @@ def test_features(lcd, orient=lcd160cr.PORTRAIT):
     # create M-logo
     mlogo = framebuf.FrameBuffer(bytearray(17 * 17 * 2), 17, 17, framebuf.RGB565)
     mlogo.fill(0)
-    mlogo.fill_rect(1, 1, 15, 15, 0xffffff)
+    mlogo.fill_rect(1, 1, 15, 15, 0xFFFFFF)
     mlogo.vline(4, 4, 12, 0)
     mlogo.vline(8, 1, 12, 0)
     mlogo.vline(12, 4, 12, 0)
@@ -80,15 +84,18 @@ def test_features(lcd, orient=lcd160cr.PORTRAIT):
             if tx2 >= 0 and ty2 >= 0 and tx2 < w and ty2 < h:
                 tx, ty = tx2, ty2
         else:
-             tx = (tx + 1) % w
-             ty = (ty + 1) % h
+            tx = (tx + 1) % w
+            ty = (ty + 1) % h
 
         # create and show the inline framebuf
         fbuf.fill(lcd.rgb(128 + int(64 * math.cos(0.1 * i)), 128, 192))
-        fbuf.line(w // 2, h // 2,
+        fbuf.line(
+            w // 2,
+            h // 2,
             w // 2 + int(40 * math.cos(0.2 * i)),
             h // 2 + int(40 * math.sin(0.2 * i)),
-            lcd.rgb(128, 255, 64))
+            lcd.rgb(128, 255, 64),
+        )
         fbuf.hline(0, ty, w, lcd.rgb(64, 64, 64))
         fbuf.vline(tx, 0, h, lcd.rgb(64, 64, 64))
         fbuf.rect(tx - 3, ty - 3, 7, 7, lcd.rgb(64, 64, 64))
@@ -97,9 +104,12 @@ def test_features(lcd, orient=lcd160cr.PORTRAIT):
             y = h // 2 - 8 + int(32 * math.sin(0.05 * i + phase))
             fbuf.blit(mlogo, x, y)
         for j in range(-3, 3):
-            fbuf.text('MicroPython',
-                5, h // 2 + 9 * j + int(20 * math.sin(0.1 * (i + j))),
-                lcd.rgb(128 + 10 * j, 0, 128 - 10 * j))
+            fbuf.text(
+                "MicroPython",
+                5,
+                h // 2 + 9 * j + int(20 * math.sin(0.1 * (i + j))),
+                lcd.rgb(128 + 10 * j, 0, 128 - 10 * j),
+            )
         lcd.show_framebuf(fbuf)
 
         # show results from the ADC
@@ -111,7 +121,10 @@ def test_features(lcd, orient=lcd160cr.PORTRAIT):
             lcd.set_pos(2, 0)
             lcd.set_font(1)
             t = rtc.datetime()
-            lcd.write('%4d-%02d-%02d %2d:%02d:%02d.%01d' % (t[0], t[1], t[2], t[4], t[5], t[6], t[7] // 100000))
+            lcd.write(
+                "%4d-%02d-%02d %2d:%02d:%02d.%01d"
+                % (t[0], t[1], t[2], t[4], t[5], t[6], t[7] // 100000)
+            )
 
         # compute the frame rate
         t1 = time.ticks_us()
@@ -120,13 +133,14 @@ def test_features(lcd, orient=lcd160cr.PORTRAIT):
 
         # show the frame rate
         lcd.set_pos(2, 9)
-        lcd.write('%.2f fps' % (1000000 / dt))
+        lcd.write("%.2f fps" % (1000000 / dt))
+
 
 def test_mandel(lcd, orient=lcd160cr.PORTRAIT):
     # set orientation and clear screen
     lcd = get_lcd(lcd)
     lcd.set_orient(orient)
-    lcd.set_pen(0, 0xffff)
+    lcd.set_pen(0, 0xFFFF)
     lcd.erase()
 
     # function to compute Mandelbrot pixels
@@ -148,24 +162,26 @@ def test_mandel(lcd, orient=lcd160cr.PORTRAIT):
     spi = lcd.fast_spi()
 
     # draw the Mandelbrot set line-by-line
-    hh = ((h - 1) / 3.2)
-    ww = ((w - 1) / 2.4)
+    hh = (h - 1) / 3.2
+    ww = (w - 1) / 2.4
     for v in range(h):
         for u in range(w):
             c = in_set((v / hh - 2.3) + (u / ww - 1.2) * 1j)
             if c < 16:
                 rgb = c << 12 | c << 6
             else:
-                rgb = 0xf800 | c << 6
+                rgb = 0xF800 | c << 6
             line[2 * u] = rgb
             line[2 * u + 1] = rgb >> 8
         spi.write(line)
 
+
 def test_all(lcd, orient=lcd160cr.PORTRAIT):
     lcd = get_lcd(lcd)
     test_features(lcd, orient)
     test_mandel(lcd, orient)
 
-print('To run all tests: test_all(<lcd>)')
-print('Individual tests are: test_features, test_mandel')
+
+print("To run all tests: test_all(<lcd>)")
+print("Individual tests are: test_features, test_mandel")
 print('<lcd> argument should be a connection, eg "X", or an LCD160CR object')
diff --git a/drivers/display/ssd1306.py b/drivers/display/ssd1306.py
index f93a451e8..4893b2045 100644
--- a/drivers/display/ssd1306.py
+++ b/drivers/display/ssd1306.py
@@ -5,23 +5,23 @@ import framebuf
 
 
 # register definitions
-SET_CONTRAST        = const(0x81)
-SET_ENTIRE_ON       = const(0xa4)
-SET_NORM_INV        = const(0xa6)
-SET_DISP            = const(0xae)
-SET_MEM_ADDR        = const(0x20)
-SET_COL_ADDR        = const(0x21)
-SET_PAGE_ADDR       = const(0x22)
+SET_CONTRAST = const(0x81)
+SET_ENTIRE_ON = const(0xA4)
+SET_NORM_INV = const(0xA6)
+SET_DISP = const(0xAE)
+SET_MEM_ADDR = const(0x20)
+SET_COL_ADDR = const(0x21)
+SET_PAGE_ADDR = const(0x22)
 SET_DISP_START_LINE = const(0x40)
-SET_SEG_REMAP       = const(0xa0)
-SET_MUX_RATIO       = const(0xa8)
-SET_COM_OUT_DIR     = const(0xc0)
-SET_DISP_OFFSET     = const(0xd3)
-SET_COM_PIN_CFG     = const(0xda)
-SET_DISP_CLK_DIV    = const(0xd5)
-SET_PRECHARGE       = const(0xd9)
-SET_VCOM_DESEL      = const(0xdb)
-SET_CHARGE_PUMP     = const(0x8d)
+SET_SEG_REMAP = const(0xA0)
+SET_MUX_RATIO = const(0xA8)
+SET_COM_OUT_DIR = const(0xC0)
+SET_DISP_OFFSET = const(0xD3)
+SET_COM_PIN_CFG = const(0xDA)
+SET_DISP_CLK_DIV = const(0xD5)
+SET_PRECHARGE = const(0xD9)
+SET_VCOM_DESEL = const(0xDB)
+SET_CHARGE_PUMP = const(0x8D)
 
 # Subclassing FrameBuffer provides support for graphics primitives
 # http://docs.micropython.org/en/latest/pyboard/library/framebuf.html
@@ -37,27 +37,37 @@ class SSD1306(framebuf.FrameBuffer):
 
     def init_display(self):
         for cmd in (
-            SET_DISP | 0x00, # off
+            SET_DISP | 0x00,  # off
             # address setting
-            SET_MEM_ADDR, 0x00, # horizontal
+            SET_MEM_ADDR,
+            0x00,  # horizontal
             # resolution and layout
             SET_DISP_START_LINE | 0x00,
-            SET_SEG_REMAP | 0x01, # column addr 127 mapped to SEG0
-            SET_MUX_RATIO, self.height - 1,
-            SET_COM_OUT_DIR | 0x08, # scan from COM[N] to COM0
-            SET_DISP_OFFSET, 0x00,
-            SET_COM_PIN_CFG, 0x02 if self.height == 32 else 0x12,
+            SET_SEG_REMAP | 0x01,  # column addr 127 mapped to SEG0
+            SET_MUX_RATIO,
+            self.height - 1,
+            SET_COM_OUT_DIR | 0x08,  # scan from COM[N] to COM0
+            SET_DISP_OFFSET,
+            0x00,
+            SET_COM_PIN_CFG,
+            0x02 if self.height == 32 else 0x12,
             # timing and driving scheme
-            SET_DISP_CLK_DIV, 0x80,
-            SET_PRECHARGE, 0x22 if self.external_vcc else 0xf1,
-            SET_VCOM_DESEL, 0x30, # 0.83*Vcc
+            SET_DISP_CLK_DIV,
+            0x80,
+            SET_PRECHARGE,
+            0x22 if self.external_vcc else 0xF1,
+            SET_VCOM_DESEL,
+            0x30,  # 0.83*Vcc
             # display
-            SET_CONTRAST, 0xff, # maximum
-            SET_ENTIRE_ON, # output follows RAM contents
-            SET_NORM_INV, # not inverted
+            SET_CONTRAST,
+            0xFF,  # maximum
+            SET_ENTIRE_ON,  # output follows RAM contents
+            SET_NORM_INV,  # not inverted
             # charge pump
-            SET_CHARGE_PUMP, 0x10 if self.external_vcc else 0x14,
-            SET_DISP | 0x01): # on
+            SET_CHARGE_PUMP,
+            0x10 if self.external_vcc else 0x14,
+            SET_DISP | 0x01,
+        ):  # on
             self.write_cmd(cmd)
         self.fill(0)
         self.show()
@@ -92,15 +102,15 @@ class SSD1306(framebuf.FrameBuffer):
 
 
 class SSD1306_I2C(SSD1306):
-    def __init__(self, width, height, i2c, addr=0x3c, external_vcc=False):
+    def __init__(self, width, height, i2c, addr=0x3C, external_vcc=False):
         self.i2c = i2c
         self.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):
-        self.temp[0] = 0x80 # Co=1, D/C#=0
+        self.temp[0] = 0x80  # Co=1, D/C#=0
         self.temp[1] = cmd
         self.i2c.writeto(self.addr, self.temp)
 
@@ -120,6 +130,7 @@ class SSD1306_SPI(SSD1306):
         self.res = res
         self.cs = cs
         import time
+
         self.res(1)
         time.sleep_ms(1)
         self.res(0)