Improve debugging output

Author: sebromero

src/modulino/firmware_flasher.py

@@ -13,7 +13,8 @@
 CMD_GET_ID = const(0x02) # Get chip ID
 CMD_ERASE = const(0x44) # Erase memory
 CMD_GO = const(0x21) # Jumps to user application code located in the internal flash memory
-CMD_WRITE = const(0x32) # Write memory
+CMD_WRITE_NO_STRETCH = const(0x32) # Writes up to 256 bytes to the memory, starting from an address specified
+CHUNK_SIZE = const(128) # Size of the memory chunk to write
 
 # Define I2C pins and initialize I2C
 i2c = I2C(0, freq=100000)
@@ -29,9 +30,9 @@ def send_reset(address):
     buffer += b'\x00' * (8 - len(buffer)) # Pad buffer to 8 bytes
 
     try:
-        print(f"Sending reset command to address {hex(address)}")
+        print(f"🔄 Resetting device at address {hex(address)}")
         i2c.writeto(address, buffer, True)
-        print("Reset command sent successfully")
+        print("✅ Reset command sent successfully")
         time.sleep(0.25) # Wait for the device to reset
         return True
     except OSError as e:
@@ -55,13 +56,12 @@ def wait_for_ack():
         while res == BUSY:
             time.sleep(0.1)
             res = i2c.readfrom(BOOTLOADER_I2C_ADDRESS, 1)[0]
-            print("Waiting for device to be finish processing")
         if res != ACK:
-            print(f"Error processing command: {hex(res)}")
+            print(f"❌ Error processing command. Result code: {hex(res)}")
             return False
     return True
 
-def execute_command(opcode, command_data, response_length = 0, verbose=True):
+def execute_command(opcode, command_data, response_length = 0, verbose=False):
     """
     Execute an I2C command on the device.
 
@@ -72,34 +72,36 @@ def execute_command(opcode, command_data, response_length = 0, verbose=True):
     :return: The number of response bytes read, or -1 if an error occurred.
     """
     if verbose:
-        print(f"Executing command {hex(opcode)}")
+        print(f"🕵️ Executing command {hex(opcode)}")
 
     cmd = bytes([opcode, 0xFF ^ opcode]) # Send command code and complement (XOR = 0x00)
     i2c.writeto(BOOTLOADER_I2C_ADDRESS, cmd, True)
     if not wait_for_ack():
-        print(f"Command not acknowledged: {hex(opcode)}")
+        print(f"❌ Command not acknowledged: {hex(opcode)}")
         return None
 
     if command_data is not None:
         i2c.writeto(BOOTLOADER_I2C_ADDRESS, command_data, True)
         if not wait_for_ack():
-            print("Command failed")
+            print("❌ Command failed")
             return None
 
     if response_length == 0:
         return None
 
     data = i2c.readfrom(BOOTLOADER_I2C_ADDRESS, response_length)
     amount_of_bytes = data[0] + 1
-    print(f"Retrieved {amount_of_bytes} bytes") # TODO: Remove this line
+
+    if verbose:
+        print(f"📦 Received {amount_of_bytes} bytes")
 
     if not wait_for_ack():
-        print("Failed completing command")
+        print("❌ Failed completing command")
         return None
 
     return data[1 : amount_of_bytes + 1]
 
-def flash_firmware(firmware_path, verbose=True):
+def flash_firmware(firmware_path, verbose=False):
     """
     Flash the firmware to the I2C device.
 
@@ -110,87 +112,85 @@ def flash_firmware(firmware_path, verbose=True):
     """
     data = execute_command(CMD_GET, None, 20, verbose)
     if data is None:
-        print("Failed :(")
+        print("❌ Failed to get command list")
         return False
 
-    print(f"Bootloader version: {hex(data[0])}")
-    print("Supported commands:")
-    for byte in data[1:]:
-        print(hex(byte))
+    print(f"ℹ️ Bootloader version: {hex(data[0])}")
+    print("👀 Supported commands:")
+    print(", ".join([hex(byte) for byte in data[1:]]))
 
     data = execute_command(CMD_GET_ID, None, 3, verbose)
     if data is None:
-        print("Failed to get device ID")
+        print("❌ Failed to get device ID")
         return False
 
     chip_id = (data[0] << 8) | data[1] # Chip ID: Byte 1 = MSB, Byte 2 = LSB
-    print(f"Chip ID: {chip_id}")
+    print(f"ℹ️ Chip ID: {chip_id}")
 
-    print("Erasing memory...")
+    print("🗑️ Erasing memory...")
     erase_params = bytearray([0xFF, 0xFF, 0x0]) # Mass erase flash
     #execute_command(CMD_ERASE, erase_params, 0, verbose)
 
     with open(firmware_path, 'rb') as file:
         firmware_data = file.read()
     total_bytes = len(firmware_data)
 
-    print(f"Flashing {total_bytes} bytes of firmware")
-    for i in range(0, total_bytes, 128):
+    print(f"🔥 Flashing {total_bytes} bytes of firmware")
+    for i in range(0, total_bytes, CHUNK_SIZE):
         progress_bar(i, total_bytes)
-        write_buffer = bytearray([8, 0, i // 256, i % 256])
-        # if write_firmware_page(write_buffer, 5, firmware_data[i:i + 128], 128, verbose) < 0:
-        #     print(f"Failed to write page {hex(i)}")
-        #     return False
-        time.sleep(0.01)
+        start_address = bytearray([8, 0, i // 256, i % 256]) # 4-byte address: byte 1 = MSB, byte 4 = LSB
+        checksum = 0
+        for b in start_address:
+            checksum ^= b        
+        start_address.append(checksum)
+        data_slice = firmware_data[i:i + CHUNK_SIZE]
+        if not write_firmware_page(start_address, data_slice):
+            print(f"❌ Failed to write page {hex(i)}")
+            return False
+        time.sleep(0.01) # Give the device some time to process the data
 
     progress_bar(total_bytes, total_bytes)  # Complete the progress bar
 
-    print("Starting firmware")
+    print("🏃 Starting firmware")
     go_params = bytearray([0x8, 0x00, 0x00, 0x00, 0x8])
     #execute_command(CMD_GO, go_params, 0, verbose) # Jump to the application
 
     return True
 
-def write_firmware_page(command_buffer, command_length, firmware_buffer, firmware_length, verbose=True):
+def write_firmware_page(command_params, firmware_data):
     """
     Write a page of the firmware to the I2C device.
 
-    :param opcode: The command opcode.
-    :param command_buffer: The buffer containing the command data.
-    :param command_length: The length of the command data.
-    :param firmware_buffer: The buffer containing the firmware data.
-    :param firmware_length: The length of the firmware data.
+    :param command_params: The buffer containing the command data.
+    :param firmware_data: The buffer containing the firmware data.
     :param verbose: Whether to print debug information.
     :return: The number of bytes written, or -1 if an error occurred.
     """
-    cmd = bytes([CMD_WRITE, 0xFF ^ CMD_WRITE])
-    i2c.writeto(100, cmd)
-    
-    if command_length > 0:
-        command_buffer[command_length - 1] = 0
-        for i in range(command_length - 1):
-            command_buffer[command_length - 1] ^= command_buffer[i]
-        i2c.writeto(100, command_buffer)
+    cmd = bytes([CMD_WRITE_NO_STRETCH, 0xFF ^ CMD_WRITE_NO_STRETCH])
+    i2c.writeto(BOOTLOADER_I2C_ADDRESS, cmd)
+    if not wait_for_ack():
+        print("❌ Write command not acknowledged")
+        return False
 
-    ack = i2c.readfrom(100, 1)[0]
-    if ack != 0x79:
-        print(f"Error first ack: {hex(ack)}")
-        return -1
+    i2c.writeto(BOOTLOADER_I2C_ADDRESS, command_params)
+    if not wait_for_ack():
+        print("❌ Failed to write command parameters")
+        return False
 
-    tmp_buffer = bytearray(firmware_length + 2)
-    tmp_buffer[0] = firmware_length - 1
-    tmp_buffer[1:firmware_length + 1] = firmware_buffer
-    tmp_buffer[firmware_length + 1] = 0
-    for i in range(firmware_length + 1):
-        tmp_buffer[firmware_length + 1] ^= tmp_buffer[i]
+    data_size = len(firmware_data)
+    tmp_buffer = bytearray(data_size + 2) # Data plus size and checksum
+    tmp_buffer[0] = data_size - 1 # Size of the data # TODO Arduino code uses data_size - 1
+    tmp_buffer[1:data_size + 1] = firmware_data
+    tmp_buffer[-1] = 0 # Checksum placeholder
+    for i in range(data_size + 1): # Calculate checksum over size byte + data bytes
+        tmp_buffer[-1] ^= tmp_buffer[i]
 
-    i2c.writeto(100, tmp_buffer)
-    ack = i2c.readfrom(100, 1)[0]
-    if ack != 0x79:
-        print(f"Error: {hex(ack)}")
-        return -1
+    i2c.writeto(BOOTLOADER_I2C_ADDRESS, tmp_buffer)    
+    if not wait_for_ack():
+        print("❌ Failed to write firmware")
+        return False
 
-    return firmware_length
+    return True
 
 def progress_bar(current, total, bar_length=40):
     """
@@ -223,11 +223,11 @@ def select_file(bin_files):
     :return: The selected .bin file name.
     """
     if len(bin_files) == 1:
-        confirm = input(f"Found one bin file: {bin_files[0]}. Do you want to flash it? (yes/no) ")
+        confirm = input(f"👀 Found one bin file: {bin_files[0]}. Do you want to flash it? (yes/no) ")
         if confirm.lower() == 'yes':
             return bin_files[0]
     else:
-        print("Found bin files:")
+        print("👀 Found bin files:")
         for index, file in enumerate(bin_files):
             print(f"{index + 1}. {file}")
         choice = int(input("Select the file to flash (number): "))
@@ -240,7 +240,7 @@ def select_i2c_device():
     :return: The selected I2C device address.
     """
     devices = i2c.scan()
-    print("I2C devices found:")
+    print("👀 I2C devices found:")
     for index, device in enumerate(devices):
         print(f"{index + 1}. Address: {hex(device)}")
     choice = int(input("Select the I2C device to flash (number): "))
@@ -251,29 +251,27 @@ def setup():
     Setup function to initialize the flashing process.
     Finds .bin files, scans for I2C devices, and flashes the selected firmware.
     """
-    print("Starting setup")
 
     bin_files = find_bin_files()
     if not bin_files:
-        print("No .bin files found in the root directory.")
+        print("❌ No .bin files found in the root directory.")
         return
 
     bin_file = "node_base.bin" # select_file(bin_files)
 
-    device_address = 30 # select_i2c_device()
-    print(f"Resetting device at address {hex(device_address)}")
+    device_address = 30 # select_i2c_device()    
     if send_reset(device_address):
-        print("Device reset successfully")
+        print("✅ Device reset successfully")
     else:
-        print("Failed to reset device")
+        print("❌ Failed to reset device")
         return
 
-    print(f"Flashing {bin_file} to device at address {hex(BOOTLOADER_I2C_ADDRESS)}")
+    print(f"🕵️ Flashing {bin_file} to device at address {hex(BOOTLOADER_I2C_ADDRESS)}")
 
     if flash_firmware(bin_file):
-        print("Firmware flashed successfully")
+        print("✅ Firmware flashed successfully")
     else:
-        print("Failed to flash firmware")
+        print("❌ Failed to flash firmware")
 
 # Start the setup
 setup()