daplink_flash: Add config zone support and hardware test.

Add clear_config(), write_config() and read_config() methods for
the 1 KB persistent config zone in the F103 internal flash. Add
config_zone.py hardware test example with 10 test cases.

Author: nedseb

lib/daplink_flash/daplink_flash/const.py

@@ -13,6 +13,9 @@
 CMD_CLEAR_FLASH = const(0x10)
 CMD_WRITE_DATA = const(0x11)
 CMD_READ_SECTOR = const(0x20)
+CMD_WRITE_CONFIG = const(0x30)
+CMD_READ_CONFIG = const(0x31)
+CMD_CLEAR_CONFIG = const(0x32)
 
 # Registers
 REG_STATUS = const(0x80)
@@ -31,5 +34,6 @@
 MAX_WRITE_CHUNK = const(30)
 SECTOR_SIZE = const(256)
 MAX_SECTORS = const(32768)
+CONFIG_SIZE = const(1024)
 FILENAME_LEN = const(8)
 EXT_LEN = const(3)

lib/daplink_flash/daplink_flash/device.py

@@ -171,3 +171,65 @@ def read(self, length=None):
                     result.append(data[i])
             sector += 1
         return bytes(result)
+
+    # --------------------------------------------------
+    # Config zone (1 KB persistent storage in F103 internal flash)
+    # --------------------------------------------------
+
+    def clear_config(self):
+        """Erase the 1 KB config zone."""
+        self._wait_busy()
+        self._write_cmd(CMD_CLEAR_CONFIG)
+        sleep_ms(100)
+        self._wait_busy()
+
+    def write_config(self, data, offset=0):
+        """Write data to the config zone at the given offset.
+
+        The firmware performs a read-modify-write cycle so existing
+        data outside the written range is preserved.
+
+        Args:
+            data: bytes or str to store.
+            offset: byte offset within the config zone (0-1023).
+        """
+        if isinstance(data, str):
+            data = data.encode()
+        length = len(data)
+        buf = bytearray(MAX_WRITE_CHUNK + 2)
+        buf[0] = CMD_WRITE_CONFIG
+        pos = 0
+        while pos < length:
+            self._wait_busy()
+            chunk_len = min(MAX_WRITE_CHUNK - 3, length - pos)
+            cur_offset = offset + pos
+            buf[1] = (cur_offset >> 8) & 0xFF
+            buf[2] = cur_offset & 0xFF
+            buf[3] = chunk_len
+            buf[4 : 4 + chunk_len] = data[pos : pos + chunk_len]
+            for i in range(4 + chunk_len, len(buf)):
+                buf[i] = 0
+            self.i2c.writeto(self.address, buf)
+            sleep_ms(50)
+            pos += chunk_len
+        self._wait_busy()
+
+    def read_config(self):
+        """Read config zone content.
+
+        Returns:
+            bytes: config data up to first 0xFF, or b'' if empty.
+        """
+        result = bytearray()
+        for page_offset in range(0, CONFIG_SIZE, SECTOR_SIZE):
+            self._wait_busy()
+            hi = (page_offset >> 8) & 0xFF
+            lo = page_offset & 0xFF
+            self._write_reg(CMD_READ_CONFIG, bytes([hi, lo]))
+            sleep_ms(100)
+            data = self.i2c.readfrom(self.address, SECTOR_SIZE)
+            for i in range(SECTOR_SIZE):
+                if data[i] == 0xFF:
+                    return bytes(result)
+                result.append(data[i])
+        return bytes(result)

lib/daplink_flash/examples/config_zone.py

@@ -0,0 +1,183 @@
+"""Test suite for DAPLink internal flash config zone.
+
+The config zone is a 1 KB area in the STM32F103 internal flash (gap
+between bootloader and interface firmware at 0x0800BC00).  It survives
+interface firmware updates and clear_flash operations, making it
+suitable for factory data like board revision and sensor calibration.
+
+Commands:
+  - WRITE_CONFIG (0x30): offset(2) + len(1) + data(N)
+  - READ_CONFIG  (0x31): offset(2) -> 256 bytes
+  - CLEAR_CONFIG (0x32): erase the entire 1 KB zone
+"""
+
+from machine import I2C
+from time import sleep_ms
+
+i2c = I2C(1)
+addr = 0x3B
+passed = 0
+failed = 0
+
+
+def read_status():
+    return i2c.readfrom_mem(addr, 0x80, 1)[0]
+
+
+def read_error():
+    return i2c.readfrom_mem(addr, 0x81, 1)[0]
+
+
+def wait_busy():
+    for _ in range(200):
+        if not (read_status() & 0x80):
+            return
+        sleep_ms(10)
+    raise OSError("busy timeout")
+
+
+def check(name, condition):
+    global passed, failed
+    if condition:
+        passed += 1
+        print("  PASS:", name)
+    else:
+        failed += 1
+        print("  FAIL:", name)
+
+
+def read_config(offset=0):
+    wait_busy()
+    i2c.writeto_mem(addr, 0x31, bytes([offset >> 8, offset & 0xFF]))
+    sleep_ms(100)
+    return i2c.readfrom(addr, 256)
+
+
+def write_config(offset, data):
+    wait_busy()
+    payload = bytearray([0x30, offset >> 8, offset & 0xFF, len(data)]) + data
+    while len(payload) < 32:
+        payload.append(0x00)
+    i2c.writeto(addr, payload)
+    sleep_ms(100)
+    wait_busy()
+
+
+def clear_config():
+    wait_busy()
+    i2c.writeto(addr, bytearray([0x32]))
+    sleep_ms(100)
+    wait_busy()
+
+
+def clear_flash():
+    wait_busy()
+    i2c.writeto(addr, bytearray([0x10]))
+    sleep_ms(1000)
+    wait_busy()
+
+
+print("WHO_AM_I:", hex(i2c.readfrom_mem(addr, 0x01, 1)[0]))
+
+# --- Test 1: Clear config ---
+print("\n--- Test 1: Clear config ---")
+clear_config()
+check("no error", read_error() == 0)
+data = read_config()
+check("all 0xFF", all(b == 0xFF for b in data))
+
+# --- Test 2: Write and read back ---
+print("\n--- Test 2: Write and read back ---")
+config = b'{"rev":3,"name":"STeaMi-01"}'
+write_config(0, config)
+check("no error", read_error() == 0)
+data = read_config()
+end = 256
+for i in range(256):
+    if data[i] == 0xFF:
+        end = i
+        break
+check("content matches", bytes(data[:end]) == config)
+
+# --- Test 3: Write at offset ---
+print("\n--- Test 3: Write at offset ---")
+clear_config()
+write_config(100, b"HELLO")
+data = read_config()
+check("offset 0-99 is 0xFF", all(b == 0xFF for b in data[:100]))
+check("offset 100-104 is HELLO", bytes(data[100:105]) == b"HELLO")
+check("offset 105 is 0xFF", data[105] == 0xFF)
+
+# --- Test 4: Write preserves existing data ---
+print("\n--- Test 4: Write preserves existing data ---")
+clear_config()
+write_config(0, b"FIRST")
+write_config(10, b"SECOND")
+data = read_config()
+check("FIRST preserved", bytes(data[0:5]) == b"FIRST")
+check("SECOND written", bytes(data[10:16]) == b"SECOND")
+check("gap is 0xFF", all(b == 0xFF for b in data[5:10]))
+
+# --- Test 5: Clear flash does NOT erase config ---
+print("\n--- Test 5: Clear flash preserves config ---")
+clear_config()
+write_config(0, b"PERSIST")
+clear_flash()
+data = read_config()
+check("config survived clear_flash", bytes(data[:7]) == b"PERSIST")
+
+# --- Test 6: Write at second 256-byte page ---
+print("\n--- Test 6: Read second page ---")
+clear_config()
+write_config(256, b"PAGE2")
+data_p1 = read_config(0)
+check("page 1 empty", all(b == 0xFF for b in data_p1))
+data_p2 = read_config(256)
+check("page 2 has data", bytes(data_p2[:5]) == b"PAGE2")
+
+# --- Test 7: Large write (max single chunk) ---
+print("\n--- Test 7: Large write ---")
+clear_config()
+big = b"A" * 28
+write_config(0, big)
+data = read_config()
+check("28 bytes written", bytes(data[:28]) == big)
+check("byte 29 is 0xFF", data[28] == 0xFF)
+
+# --- Test 8: Multiple sequential writes ---
+print("\n--- Test 8: Multiple sequential writes ---")
+clear_config()
+for i in range(5):
+    write_config(i * 20, bytes([0x41 + i]) * 10)
+data = read_config()
+check("chunk 0 = AAAAAAAAAA", bytes(data[0:10]) == b"A" * 10)
+check("chunk 2 = CCCCCCCCCC", bytes(data[40:50]) == b"C" * 10)
+check("chunk 4 = EEEEEEEEEE", bytes(data[80:90]) == b"E" * 10)
+
+# --- Test 9: Existing flash operations still work ---
+print("\n--- Test 9: Flash operations still work ---")
+wait_busy()
+i2c.writeto_mem(addr, 0x20, bytes([0x00, 0x00]))
+sleep_ms(200)
+sector = i2c.readfrom(addr, 256)
+check("read_sector OK", len(sector) == 256)
+check("who_am_i OK", i2c.readfrom_mem(addr, 0x01, 1)[0] == 0x4C)
+
+# --- Test 10: USB stability after all operations ---
+print("\n--- Test 10: USB stability ---")
+for i in range(10):
+    write_config(0, b"STRESS" + bytes([0x30 + i]))
+    data = read_config()
+    if bytes(data[:7]) != b"STRESS" + bytes([0x30 + i]):
+        check("stress iteration %d" % i, False)
+        break
+else:
+    check("10 write/read cycles OK", True)
+
+# --- Summary ---
+print("\n" + "=" * 40)
+print("Results: %d passed, %d failed" % (passed, failed))
+if failed == 0:
+    print("ALL TESTS PASSED")
+else:
+    print("SOME TESTS FAILED")

tests/scenarios/daplink_flash.yaml

@@ -126,6 +126,40 @@ tests:
     expect_true: true
     mode: [mock]
 
+  - name: "Clear config sends command"
+    action: script
+    script: |
+      i2c.clear_write_log()
+      dev.clear_config()
+      log = i2c.get_write_log()
+      sent_clear = any(reg is None and 0x32 in data for reg, data in log)
+      result = sent_clear
+    expect_true: true
+    mode: [mock]
+
+  - name: "Write config sends command"
+    action: script
+    script: |
+      i2c.clear_write_log()
+      dev.write_config(b"test")
+      log = i2c.get_write_log()
+      sent_write = any(reg is None and data[0] == 0x30 for reg, data in log)
+      result = sent_write
+    expect_true: true
+    mode: [mock]
+
+  - name: "Write config sends clear then write"
+    action: script
+    script: |
+      i2c.clear_write_log()
+      dev.write_config(b"hi")
+      log = i2c.get_write_log()
+      sent_clear = any(reg is None and 0x32 in data for reg, data in log)
+      sent_write = any(reg is None and data[0] == 0x30 for reg, data in log)
+      result = sent_clear and sent_write
+    expect_true: true
+    mode: [mock]
+
   # ----- Hardware -----
 
   - name: "Status register readable"
@@ -261,3 +295,49 @@ tests:
       result = len(content) == 0
     expect_true: true
     mode: [hardware]
+
+  # ----- Config zone -----
+
+  - name: "Write and read config round-trip"
+    action: hardware_script
+    script: |
+      dev.clear_config()
+      dev.write_config('{"test": 42}')
+      content = dev.read_config()
+      result = content == b'{"test": 42}'
+    expect_true: true
+    mode: [hardware]
+
+  - name: "Clear config erases config zone"
+    action: hardware_script
+    script: |
+      dev.write_config("data")
+      dev.clear_config()
+      result = dev.read_config() == b""
+    expect_true: true
+    mode: [hardware]
+
+  - name: "Clear flash does not erase config"
+    action: hardware_script
+    script: |
+      from time import sleep_ms
+      dev.write_config("preserved")
+      dev.clear_flash()
+      sleep_ms(500)
+      result = dev.read_config() == b"preserved"
+    expect_true: true
+    mode: [hardware]
+
+  - name: "Config survives data file operations"
+    action: hardware_script
+    script: |
+      from time import sleep_ms
+      dev.write_config('{"cal": true}')
+      dev.set_filename("TEST", "CSV")
+      dev.clear_flash()
+      sleep_ms(500)
+      dev.write_line("row1")
+      sleep_ms(100)
+      result = dev.read_config() == b'{"cal": true}'
+    expect_true: true
+    mode: [hardware]