!deleteme: Add placeholder program that reads/writes persistent data.

This will let us test SPI read and write in full, even though program download is not yet implemented.

Author: laurensvalk

lib/pbio/drv/block_device/block_device_ev3.c

@@ -334,6 +334,113 @@ static spi_command_t cmd_data_read = {
     .operation = SPI_RECV,
 };
 
+// REVISIT: We are not supposed to include these. These are here just to have
+// some placeholder data to play with until read/write are implemented
+#include "genhdr/mpversion.h"
+#include <pbsys/storage.h>
+
+static pbio_error_t delete_me_load_placeholder_data(uint32_t offset, uint8_t *buffer, uint32_t size) {
+
+    // This is a compiled version of the following. It:
+    // - blinks the LED
+    // - increments a persistent counter each time you run it
+    //
+    // For now, it increases the count each time you press the center button.
+    // For now, it resets to 0 on shutdown and restart. If read and write are
+    // implemented, the value is persistent!
+    /*
+
+    from pybricks.hubs import EV3Brick
+    from pybricks.parameters import Color
+    from pybricks.tools import wait
+
+    hub = EV3Brick()
+
+    count = hub.system.storage(0, read=1)[0]
+    hub.system.storage(0, write=bytes([(count + 1) % 256]))
+
+    print("Persistent count:", count)
+
+    while True:
+        hub.light.on(Color.RED)
+        wait(500)
+        hub.light.on(Color.GREEN)
+        wait(500)
+    */
+
+
+    static const uint8_t _program_data[] = {
+        0x43, 0x01, 0x00, 0x00, 0x5F, 0x5F, 0x6D, 0x61,
+        0x69, 0x6E, 0x5F, 0x5F, 0x00, 0x4D, 0x06, 0x00,
+        0x1F, 0x14, 0x01, 0x0E, 0x74, 0x65, 0x73, 0x74,
+        0x2E, 0x70, 0x79, 0x00, 0x0F, 0x10, 0x45, 0x56,
+        0x33, 0x42, 0x72, 0x69, 0x63, 0x6B, 0x00, 0x1A,
+        0x70, 0x79, 0x62, 0x72, 0x69, 0x63, 0x6B, 0x73,
+        0x2E, 0x68, 0x75, 0x62, 0x73, 0x00, 0x0A, 0x43,
+        0x6F, 0x6C, 0x6F, 0x72, 0x00, 0x26, 0x70, 0x79,
+        0x62, 0x72, 0x69, 0x63, 0x6B, 0x73, 0x2E, 0x70,
+        0x61, 0x72, 0x61, 0x6D, 0x65, 0x74, 0x65, 0x72,
+        0x73, 0x00, 0x08, 0x77, 0x61, 0x69, 0x74, 0x00,
+        0x1C, 0x70, 0x79, 0x62, 0x72, 0x69, 0x63, 0x6B,
+        0x73, 0x2E, 0x74, 0x6F, 0x6F, 0x6C, 0x73, 0x00,
+        0x0C, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x00,
+        0x0E, 0x73, 0x74, 0x6F, 0x72, 0x61, 0x67, 0x65,
+        0x00, 0x81, 0x7B, 0x82, 0x49, 0x0A, 0x6C, 0x69,
+        0x67, 0x68, 0x74, 0x00, 0x04, 0x6F, 0x6E, 0x00,
+        0x06, 0x52, 0x45, 0x44, 0x00, 0x0A, 0x47, 0x52,
+        0x45, 0x45, 0x4E, 0x00, 0x06, 0x68, 0x75, 0x62,
+        0x00, 0x81, 0x15, 0x81, 0x05, 0x81, 0x77, 0x05,
+        0x11, 0x50, 0x65, 0x72, 0x73, 0x69, 0x73, 0x74,
+        0x65, 0x6E, 0x74, 0x20, 0x63, 0x6F, 0x75, 0x6E,
+        0x74, 0x3A, 0x00, 0x89, 0x58, 0x30, 0x18, 0x01,
+        0x2C, 0x2C, 0x4C, 0x46, 0x31, 0x5B, 0x49, 0x20,
+        0x2D, 0x28, 0x2D, 0x80, 0x10, 0x02, 0x2A, 0x01,
+        0x1B, 0x03, 0x1C, 0x02, 0x16, 0x02, 0x59, 0x80,
+        0x10, 0x04, 0x2A, 0x01, 0x1B, 0x05, 0x1C, 0x04,
+        0x16, 0x04, 0x59, 0x80, 0x10, 0x06, 0x2A, 0x01,
+        0x1B, 0x07, 0x1C, 0x06, 0x16, 0x06, 0x59, 0x11,
+        0x02, 0x34, 0x00, 0x16, 0x10, 0x11, 0x10, 0x13,
+        0x08, 0x14, 0x09, 0x80, 0x10, 0x0A, 0x81, 0x36,
+        0x82, 0x01, 0x80, 0x55, 0x16, 0x11, 0x11, 0x10,
+        0x13, 0x08, 0x14, 0x09, 0x80, 0x10, 0x0B, 0x11,
+        0x12, 0x11, 0x11, 0x81, 0xF2, 0x22, 0x82, 0x00,
+        0xF8, 0x2B, 0x01, 0x34, 0x01, 0x36, 0x82, 0x01,
+        0x59, 0x11, 0x13, 0x23, 0x00, 0x11, 0x11, 0x34,
+        0x02, 0x59, 0x11, 0x10, 0x13, 0x0C, 0x14, 0x0D,
+        0x11, 0x04, 0x13, 0x0E, 0x36, 0x01, 0x59, 0x11,
+        0x06, 0x22, 0x83, 0x74, 0x34, 0x01, 0x59, 0x11,
+        0x10, 0x13, 0x0C, 0x14, 0x0D, 0x11, 0x04, 0x13,
+        0x0F, 0x36, 0x01, 0x59, 0x11, 0x06, 0x22, 0x83,
+        0x74, 0x34, 0x01, 0x59, 0x42, 0x14, 0x51, 0x63,
+    };
+
+    // The block device normally doesn't need to be aware of this higher level
+    // data structure, but we use it here to mimic some working data into memory
+    // so we have something to test against.
+    static struct {
+        uint32_t write_size;
+        uint8_t user_data[PBSYS_CONFIG_STORAGE_USER_DATA_SIZE];
+        char stored_firmware_hash[8];
+        pbsys_storage_settings_t settings;
+        uint32_t program_offset;
+        uint32_t program_size;
+        uint8_t program_data[sizeof(_program_data)];
+    } disk = { 0 };
+
+    // Prepare fake disk data
+    disk.write_size = sizeof(disk) + sizeof(_program_data);
+    disk.program_size = sizeof(_program_data);
+    memcpy(&disk.stored_firmware_hash[0], MICROPY_GIT_HASH, sizeof(disk.stored_firmware_hash));
+    memcpy(&disk.program_data[0], _program_data, sizeof(_program_data));
+
+    // Initial value of that one user byte:
+    disk.user_data[0] = 123;
+
+    // Copy requested data to RAM.
+    memcpy(buffer, (uint8_t *)&disk + offset, size);
+    return PBIO_SUCCESS;
+}
+
 pbio_error_t pbdrv_block_device_read(pbio_os_state_t *state, uint32_t offset, uint8_t *buffer, uint32_t size) {
 
     static pbio_os_state_t sub;
@@ -343,6 +450,9 @@ pbio_error_t pbdrv_block_device_read(pbio_os_state_t *state, uint32_t offset, ui
 
     PBIO_OS_ASYNC_BEGIN(state);
 
+    // REVSISIT: DELETE ME!
+    return delete_me_load_placeholder_data(offset, buffer, size);
+
     // Exit on invalid size.
     if (size == 0 || offset + size > PBDRV_CONFIG_BLOCK_DEVICE_EV3_SIZE) {
         return PBIO_ERROR_INVALID_ARG;

lib/pbio/sys/main.c

@@ -92,7 +92,7 @@ int main(int argc, char **argv) {
     while (!pbsys_status_test(PBIO_PYBRICKS_STATUS_SHUTDOWN_REQUEST)) {
 
         #if PBSYS_CONFIG_USER_PROGRAM_AUTO_START
-        pbsys_main_program_request_start(PBIO_PYBRICKS_USER_PROGRAM_ID_REPL, PBSYS_MAIN_PROGRAM_START_REQUEST_TYPE_BOOT);
+        pbsys_main_program_request_start(PBIO_PYBRICKS_USER_PROGRAM_ID_FIRST_SLOT, PBSYS_MAIN_PROGRAM_START_REQUEST_TYPE_BOOT);
         #endif
 
         // Drives all processes while we wait for user input.