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

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

2 files changed, 82 insertions, 72 deletions

diff --git a/ports/stm32/mboot/fwupdate.py b/ports/stm32/mboot/fwupdate.py
index b2690e8cd..b44ed772c 100644
--- a/ports/stm32/mboot/fwupdate.py
+++ b/ports/stm32/mboot/fwupdate.py
@@ -6,7 +6,7 @@ import uzlib, machine, stm
 
 
 FLASH_KEY1 = 0x45670123
-FLASH_KEY2 = 0xcdef89ab
+FLASH_KEY2 = 0xCDEF89AB
 
 
 def check_mem_contains(addr, buf):
@@ -17,99 +17,100 @@ def check_mem_contains(addr, buf):
             return False
     return True
 
+
 def check_mem_erased(addr, size):
     mem16 = stm.mem16
     r = range(0, size, 2)
     for off in r:
-        if mem16[addr + off] != 0xffff:
+        if mem16[addr + off] != 0xFFFF:
             return False
     return True
 
+
 def dfu_read(filename):
-    f = open(filename, 'rb')
+    f = open(filename, "rb")
 
     hdr = f.read(3)
     f.seek(0)
-    if hdr == b'Dfu':
+    if hdr == b"Dfu":
         pass
-    elif hdr == b'\x1f\x8b\x08':
+    elif hdr == b"\x1f\x8b\x08":
         f = uzlib.DecompIO(f, 16 + 15)
     else:
-        print('Invalid firmware', filename)
+        print("Invalid firmware", filename)
         return None
 
     elems = []
 
     hdr = f.read(11)
-    sig, ver, size, num_targ = struct.unpack('<5sBIB', hdr)
+    sig, ver, size, num_targ = struct.unpack("<5sBIB", hdr)
 
     file_offset = 11
 
     for i in range(num_targ):
         hdr = f.read(274)
-        sig, alt, has_name, name, t_size, num_elem = struct.unpack('<6sBi255sII', hdr)
+        sig, alt, has_name, name, t_size, num_elem = struct.unpack("<6sBi255sII", hdr)
 
         file_offset += 274
         file_offset_t = file_offset
         for j in range(num_elem):
             hdr = f.read(8)
-            addr, e_size = struct.unpack('<II', hdr)
+            addr, e_size = struct.unpack("<II", hdr)
             data = f.read(e_size)
             elems.append((addr, data))
             file_offset += 8 + e_size
 
         if t_size != file_offset - file_offset_t:
-            print('corrupt DFU', t_size, file_offset - file_offset_t)
+            print("corrupt DFU", t_size, file_offset - file_offset_t)
             return None
 
     if size != file_offset:
-        print('corrupt DFU', size, file_offset)
+        print("corrupt DFU", size, file_offset)
         return None
 
     hdr = f.read(16)
-    hdr = struct.unpack('<HHHH3sBI', hdr)
+    hdr = struct.unpack("<HHHH3sBI", hdr)
 
     return elems
 
+
 def flash_wait_not_busy():
     while stm.mem32[stm.FLASH + stm.FLASH_SR] & 1 << 16:
         machine.idle()
 
+
 def flash_unlock():
     stm.mem32[stm.FLASH + stm.FLASH_KEYR] = FLASH_KEY1
     stm.mem32[stm.FLASH + stm.FLASH_KEYR] = FLASH_KEY2
 
+
 def flash_lock():
-    stm.mem32[stm.FLASH + stm.FLASH_CR] = 1 << 31 # LOCK
+    stm.mem32[stm.FLASH + stm.FLASH_CR] = 1 << 31  # LOCK
+
 
 def flash_erase_sector(sector):
-    assert 0 <= sector <= 7 # for F722
+    assert 0 <= sector <= 7  # for F722
     flash_wait_not_busy()
-    cr = (
-        2 << 8 # PSIZE = 32 bits
-        | sector << 3 # SNB
-        | 1 << 1 # SER
-    )
+    cr = 2 << 8 | sector << 3 | 1 << 1  # PSIZE = 32 bits  # SNB  # SER
     stm.mem32[stm.FLASH + stm.FLASH_CR] = cr
-    stm.mem32[stm.FLASH + stm.FLASH_CR] = cr | 1 << 16 # STRT
+    stm.mem32[stm.FLASH + stm.FLASH_CR] = cr | 1 << 16  # STRT
     flash_wait_not_busy()
     stm.mem32[stm.FLASH + stm.FLASH_CR] = 0
 
+
 def flash_write(addr, buf):
     assert len(buf) % 4 == 0
     flash_wait_not_busy()
-    cr = (
-        2 << 8 # PSIZE = 32 bits
-        | 1 << 0 # PG
-    )
+    cr = 2 << 8 | 1 << 0  # PSIZE = 32 bits  # PG
     stm.mem32[stm.FLASH + stm.FLASH_CR] = cr
     for off in range(0, len(buf), 4):
-        stm.mem32[addr + off] = struct.unpack_from('I', buf, off)[0]
+        stm.mem32[addr + off] = struct.unpack_from("I", buf, off)[0]
         flash_wait_not_busy()
     stm.mem32[stm.FLASH + stm.FLASH_CR] = 0
 
+
 def update_mboot(filename):
-    print('Loading file', filename)
+    print("Loading file", filename)
 
     mboot_fw = dfu_read(filename)
     if mboot_fw is None:
@@ -122,14 +123,14 @@ def update_mboot(filename):
 
     # TODO: Validate firmware in a simple way
 
-    print('Found Mboot data with size %u.' % len(mboot_fw))
+    print("Found Mboot data with size %u." % len(mboot_fw))
 
     chk = check_mem_contains(mboot_addr, mboot_fw)
     if chk:
-        print('Supplied version of Mboot is already on device.')
+        print("Supplied version of Mboot is already on device.")
         return
 
-    print('Programming Mboot, do not turn off!')
+    print("Programming Mboot, do not turn off!")
     time.sleep_ms(50)
 
     irq = machine.disable_irq()
@@ -141,24 +142,25 @@ def update_mboot(filename):
     flash_lock()
     machine.enable_irq(irq)
 
-    print('New Mboot programmed.')
+    print("New Mboot programmed.")
 
     if check_mem_contains(mboot_addr, mboot_fw):
-        print('Verification of new Mboot succeeded.')
+        print("Verification of new Mboot succeeded.")
     else:
-        print('Verification of new Mboot FAILED!  Try rerunning.')
+        print("Verification of new Mboot FAILED!  Try rerunning.")
+
+    print("Programming finished, can now reset or turn off.")
 
-    print('Programming finished, can now reset or turn off.')
 
 def update_mpy(filename, fs_base, fs_len):
     # Check firmware is of .dfu.gz type
     try:
-        with open(filename, 'rb') as f:
+        with open(filename, "rb") as f:
             hdr = uzlib.DecompIO(f, 16 + 15).read(6)
     except Exception:
         hdr = None
-    if hdr != b'DfuSe\x01':
-        print('Firmware must be a .dfu.gz file.')
+    if hdr != b"DfuSe\x01":
+        print("Firmware must be a .dfu.gz file.")
         return
 
     ELEM_TYPE_END = 1
@@ -166,7 +168,11 @@ def update_mpy(filename, fs_base, fs_len):
     ELEM_TYPE_FSLOAD = 3
     ELEM_MOUNT_FAT = 1
     mount_point = 1
-    mount = struct.pack('<BBBBLL', ELEM_TYPE_MOUNT, 10, mount_point, ELEM_MOUNT_FAT, fs_base, fs_len)
-    fsup = struct.pack('<BBB', ELEM_TYPE_FSLOAD, 1 + len(filename), mount_point) + bytes(filename, 'ascii')
-    end = struct.pack('<BB', ELEM_TYPE_END, 0)
+    mount = struct.pack(
+        "<BBBBLL", ELEM_TYPE_MOUNT, 10, mount_point, ELEM_MOUNT_FAT, fs_base, fs_len
+    )
+    fsup = struct.pack("<BBB", ELEM_TYPE_FSLOAD, 1 + len(filename), mount_point) + bytes(
+        filename, "ascii"
+    )
+    end = struct.pack("<BB", ELEM_TYPE_END, 0)
     machine.bootloader(mount + fsup + end)
diff --git a/ports/stm32/mboot/mboot.py b/ports/stm32/mboot/mboot.py
index 39ae0f6f2..e0dab163c 100644
--- a/ports/stm32/mboot/mboot.py
+++ b/ports/stm32/mboot/mboot.py
@@ -27,9 +27,9 @@ class Bootloader:
         self.addr = addr
         self.buf1 = bytearray(1)
         try:
-            self.i2c.writeto(addr, b'')
+            self.i2c.writeto(addr, b"")
         except OSError:
-            raise Exception('no I2C mboot device found')
+            raise Exception("no I2C mboot device found")
 
     def wait_response(self):
         start = time.ticks_ms()
@@ -41,47 +41,47 @@ class Bootloader:
             except OSError as er:
                 time.sleep_us(500)
             if time.ticks_diff(time.ticks_ms(), start) > 5000:
-                raise Exception('timeout')
+                raise Exception("timeout")
         if n >= 129:
             raise Exception(n)
         if n == 0:
-            return b''
+            return b""
         else:
             return self.i2c.readfrom(self.addr, n)
 
     def wait_empty_response(self):
         ret = self.wait_response()
         if ret:
-            raise Exception('expected empty response got %r' % ret)
+            raise Exception("expected empty response got %r" % ret)
         else:
             return None
 
     def echo(self, data):
-        self.i2c.writeto(self.addr, struct.pack('<B', I2C_CMD_ECHO) + data)
+        self.i2c.writeto(self.addr, struct.pack("<B", I2C_CMD_ECHO) + data)
         return self.wait_response()
 
     def getid(self):
-        self.i2c.writeto(self.addr, struct.pack('<B', I2C_CMD_GETID))
+        self.i2c.writeto(self.addr, struct.pack("<B", I2C_CMD_GETID))
         ret = self.wait_response()
         unique_id = ret[:12]
-        mcu_name, board_name = ret[12:].split(b'\x00')
-        return unique_id, str(mcu_name, 'ascii'), str(board_name, 'ascii')
+        mcu_name, board_name = ret[12:].split(b"\x00")
+        return unique_id, str(mcu_name, "ascii"), str(board_name, "ascii")
 
     def reset(self):
-        self.i2c.writeto(self.addr, struct.pack('<B', I2C_CMD_RESET))
+        self.i2c.writeto(self.addr, struct.pack("<B", I2C_CMD_RESET))
         # we don't expect any response
 
     def getlayout(self):
-        self.i2c.writeto(self.addr, struct.pack('<B', I2C_CMD_GETLAYOUT))
+        self.i2c.writeto(self.addr, struct.pack("<B", I2C_CMD_GETLAYOUT))
         layout = self.wait_response()
-        id, flash_addr, layout = layout.split(b'/')
-        assert id == b'@Internal Flash  '
+        id, flash_addr, layout = layout.split(b"/")
+        assert id == b"@Internal Flash  "
         flash_addr = int(flash_addr, 16)
         pages = []
-        for chunk in layout.split(b','):
-            n, sz = chunk.split(b'*')
+        for chunk in layout.split(b","):
+            n, sz = chunk.split(b"*")
             n = int(n)
-            assert sz.endswith(b'Kg')
+            assert sz.endswith(b"Kg")
             sz = int(sz[:-2]) * 1024
             for i in range(n):
                 pages.append((flash_addr, sz))
@@ -89,43 +89,43 @@ class Bootloader:
         return pages
 
     def pageerase(self, addr):
-        self.i2c.writeto(self.addr, struct.pack('<BI', I2C_CMD_PAGEERASE, addr))
+        self.i2c.writeto(self.addr, struct.pack("<BI", I2C_CMD_PAGEERASE, addr))
         self.wait_empty_response()
 
     def setrdaddr(self, addr):
-        self.i2c.writeto(self.addr, struct.pack('<BI', I2C_CMD_SETRDADDR, addr))
+        self.i2c.writeto(self.addr, struct.pack("<BI", I2C_CMD_SETRDADDR, addr))
         self.wait_empty_response()
 
     def setwraddr(self, addr):
-        self.i2c.writeto(self.addr, struct.pack('<BI', I2C_CMD_SETWRADDR, addr))
+        self.i2c.writeto(self.addr, struct.pack("<BI", I2C_CMD_SETWRADDR, addr))
         self.wait_empty_response()
 
     def read(self, n):
-        self.i2c.writeto(self.addr, struct.pack('<BB', I2C_CMD_READ, n))
+        self.i2c.writeto(self.addr, struct.pack("<BB", I2C_CMD_READ, n))
         return self.wait_response()
 
     def write(self, buf):
-        self.i2c.writeto(self.addr, struct.pack('<B', I2C_CMD_WRITE) + buf)
+        self.i2c.writeto(self.addr, struct.pack("<B", I2C_CMD_WRITE) + buf)
         self.wait_empty_response()
 
     def calchash(self, n):
-        self.i2c.writeto(self.addr, struct.pack('<BI', I2C_CMD_CALCHASH, n))
+        self.i2c.writeto(self.addr, struct.pack("<BI", I2C_CMD_CALCHASH, n))
         return self.wait_response()
 
     def markvalid(self):
-        self.i2c.writeto(self.addr, struct.pack('<B', I2C_CMD_MARKVALID))
+        self.i2c.writeto(self.addr, struct.pack("<B", I2C_CMD_MARKVALID))
         self.wait_empty_response()
 
     def deployfile(self, filename, addr):
         pages = self.getlayout()
         page_erased = [False] * len(pages)
-        buf = bytearray(128) # maximum payload supported by I2C protocol
+        buf = bytearray(128)  # maximum payload supported by I2C protocol
         start_addr = addr
         self.setwraddr(addr)
         fsize = os.stat(filename)[6]
         local_sha = hashlib.sha256()
-        print('Deploying %s to location 0x%08x' % (filename, addr))
-        with open(filename, 'rb') as f:
+        print("Deploying %s to location 0x%08x" % (filename, addr))
+        with open(filename, "rb") as f:
             t0 = time.ticks_ms()
             while True:
                 n = f.readinto(buf)
@@ -137,12 +137,16 @@ class Bootloader:
                     if p[0] <= addr < p[0] + p[1]:
                         # found page
                         if not page_erased[i]:
-                            print('\r% 3u%% erase 0x%08x' % (100 * (addr - start_addr) // fsize, addr), end='')
+                            print(
+                                "\r% 3u%% erase 0x%08x"
+                                % (100 * (addr - start_addr) // fsize, addr),
+                                end="",
+                            )
                             self.pageerase(addr)
                             page_erased[i] = True
                         break
                 else:
-                    raise Exception('address 0x%08x not valid' % addr)
+                    raise Exception("address 0x%08x not valid" % addr)
 
                 # write the data
                 self.write(buf)
@@ -158,20 +162,20 @@ class Bootloader:
                 addr += n
                 ntotal = addr - start_addr
                 if ntotal % 2048 == 0 or ntotal == fsize:
-                    print('\r% 3u%% % 7u bytes   ' % (100 * ntotal // fsize, ntotal), end='')
+                    print("\r% 3u%% % 7u bytes   " % (100 * ntotal // fsize, ntotal), end="")
             t1 = time.ticks_ms()
         print()
-        print('rate: %.2f KiB/sec' % (1024 * ntotal / (t1 - t0) / 1000))
+        print("rate: %.2f KiB/sec" % (1024 * ntotal / (t1 - t0) / 1000))
 
         local_sha = local_sha.digest()
-        print('Local SHA256: ', ''.join('%02x' % x for x in local_sha))
+        print("Local SHA256: ", "".join("%02x" % x for x in local_sha))
 
         self.setrdaddr(start_addr)
         remote_sha = self.calchash(ntotal)
-        print('Remote SHA256:', ''.join('%02x' % x for x in remote_sha))
+        print("Remote SHA256:", "".join("%02x" % x for x in remote_sha))
 
         if local_sha == remote_sha:
-            print('Marking app firmware as valid')
+            print("Marking app firmware as valid")
             self.markvalid()
 
         self.reset()