add configuration storage in flash

CMakeLists.txt

     src/usb_cdc.c
     src/usb_descriptors.c
     src/usb_midi.c
+    src/settings.c
+    src/mem.c
 
     pico-ssd1306/ssd1306.c
 )
     tinyusb_device
     tinyusb_board
     cmake_git_version_tracking
+    hardware_flash
+    pico_flash
+    hardware_exception
 )
 
-# enable usb output, disable uart output
-pico_enable_stdio_usb(drumkit 1)
-pico_enable_stdio_uart(drumkit 0)
+pico_set_linker_script(drumkit ${CMAKE_CURRENT_LIST_DIR}/src/memmap_custom.ld)
 
 # fix for Errata RP2040-E5 (the fix requires use of GPIO 15)
 target_compile_definitions(drumkit PUBLIC PICO_RP2040_USB_DEVICE_ENUMERATION_FIX=1)

docs/src/usage.md

 
 You can hold down some buttons while powering on the device to get different effects:
 
-* hold the `REC` button to skip the boot animation
+* hold the `REC` button to enter the configuration menu
 * hold the encoder `Click` button to show version information of the firmware
 * hold both `REC` and `Click` to enter the button test mode
+* hold any combination of three buttons to skip the boot animation

include/config.h

 
 #define WATCHDOG_PERIOD_MS 100
 #define LOGO_INIT_MS 1000
+#define FLASH_LOCK_TIMEOUT_MS 500
+#define CH_GPIO_DEFAULT_MS 42
 
 // ASCII 0x18 = CAN (cancel)
 #define ENTER_BOOTLOADER_MAGIC 0x18

include/encoder.h

 #include <stdint.h>
 
 void encoder_init(void);
-int32_t encoder_pos(void);
 void encoder_run(void);
 
+int32_t encoder_pos(void);
+int32_t encoder_get_diff(void);
+
 #endif // __ENCODER_H__

include/mem.h

+/*
+ * mem.h
+ *
+ * Copyright (c) 2023 - 2024 Thomas Buck (thomas@xythobuz.de)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * See <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __MEM_H__
+#define __MEM_H__
+
+#include "hardware/flash.h"
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#include "sequence.h"
+
+/*
+ * We use the last flash page for our persistent storage.
+ * This is kept clear by our custom linker script.
+ */
+#define EEPROM_FLASH_OFFSET (PICO_FLASH_SIZE_BYTES - FLASH_SECTOR_SIZE)
+
+// to migrate settings when struct changes between releases
+#define MEM_VERSION 0
+
+struct mem_data {
+    uint32_t boot_anim_ms;
+
+    uint32_t ch_timings[NUM_CHANNELS];
+    uint32_t ch_count; // to invalidate if number of channels changes
+};
+
+// .ch_timings is assigned in mem_load_defaults
+#define MEM_DATA_INIT {           \
+    .boot_anim_ms = LOGO_INIT_MS, \
+    .ch_count = NUM_CHANNELS,     \
+}
+
+void mem_load(void);
+void mem_write(void);
+struct mem_data *mem_data(void);
+void mem_load_defaults(void);
+
+#endif // __MEM_H__

include/sequence.h

     NUM_CHANNELS = 3
 };
 
-#define CH_GPIO_TIMINGS { 42, 42, 42 } // in milliseconds
-
 #define MAX_BEATS 128
 #define MAX_BANKS (MAX_BEATS / NUM_BTNS)
 

include/settings.h

+/*
+ * settings.h
+ *
+ * Copyright (c) 2024 Thomas Buck (thomas@xythobuz.de)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * See <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __SETTINGS_H__
+#define __SETTINGS_H__
+
+void settings_init(void);
+void settings_run(void);
+
+#endif // __SETTINGS_H__

include/ui.h

 
 #include <stdint.h>
 
+#define KEEP_IN_RANGE(val, min, len) { \
+    while (val > (len - min)) {        \
+        val -= len;                    \
+    }                                  \
+    while (val < min) {                \
+        val += len;                    \
+    }                                  \
+}
+
 enum machine_modes {
     MODE_LOOPSTATION = 0,
     MODE_DRUMMACHINE,

src/encoder.c

     positionExtPrev = 0;
 }
 
-int32_t encoder_pos(void)
-{
+int32_t encoder_pos(void) {
     return positionExt;
 }
 
+int32_t encoder_get_diff(void) {
+    static int32_t last_epos = 0;
+    int32_t epos = encoder_pos();
+    int32_t diff = epos - last_epos;
+    last_epos = epos;
+    return diff;
+}
+
 void encoder_run(void) {
     int8_t thisState = 0;
     if (hw_type == HW_PROTOTYPE) {

src/main.c

 #include "led.h"
 #include "log.h"
 #include "logo.h"
+#include "mem.h"
 #include "pulse.h"
 #include "sequence.h"
+#include "settings.h"
 #include "ui.h"
 #include "usb.h"
 #include "main.h"
     debug_buttons[btn] = v;
 }
 
+static uint32_t debug_count_buttons(void) {
+    uint32_t cnt = 0;
+    for (uint32_t i = 0; i < NUM_BTNS; i++) {
+        if (debug_buttons[i]) {
+            cnt++;
+        }
+    }
+    return cnt;
+}
+
 void reset_to_bootloader(void) {
     lcd_draw_bye();
 
     while (1);
 }
 
-static void encoder_handle(void) {
-    static int32_t last_epos = 0;
-    int32_t epos = encoder_pos();
-    if (epos != last_epos) {
-        ui_encoder(epos - last_epos);
-        last_epos = epos;
-    }
-}
-
 static void sleep_ms_wd(uint32_t ms) {
     for (uint32_t i = 0; i < ms; i++) {
         watchdog_update();
     }
 }
 
-void main_loop_hw(void) {
-    watchdog_update();
-
-    usb_run();
-    cnsl_run();
-    buttons_run();
-    encoder_run();
-    sequence_run();
-    pulse_run();
-    ui_run();
-
-    encoder_handle();
-}
-
-int main(void) {
-    watchdog_enable(WATCHDOG_PERIOD_MS, 1);
-
-    cnsl_init();
-    usb_init();
-
+static void hw_type_detection(void) {
     gpio_init(gpio_hw_detect);
     gpio_set_dir(gpio_hw_detect, GPIO_IN);
     gpio_pull_up(gpio_hw_detect);
+
     if (gpio_get(gpio_hw_detect)) {
         hw_type = HW_PROTOTYPE;
     } else {
         hw_type = HW_V2;
     }
+}
 
-    bat_init();
-    buttons_init();
-    encoder_init();
-    lcd_init();
-    led_init();
-
-    // show logo
-    lcd_draw_bitmap(logo_data,
-                    LOGO_WIDTH, LOGO_HEIGHT,
-                    0, 0);
-
+static void animate_boot_combos(void) {
     // read out button state for debug options
     buttons_callback(debug_buttons_callback);
     for (uint i = 0; i < (DEBOUNCE_DELAY_MS + 5); i++) {
         sleep_ms_wd(1);
     }
 
+    uint32_t cnt = debug_count_buttons();
+
     // handle special button combos on boot
-    if (debug_buttons[BTN_REC] && debug_buttons[BTN_CLICK]) {
+    if ((cnt == 2) && debug_buttons[BTN_REC] && debug_buttons[BTN_CLICK]) {
         lcd_debug_buttons();
-    } else if (debug_buttons[BTN_REC] && (!debug_buttons[BTN_CLICK])) {
+    } else if ((cnt == 1) && debug_buttons[BTN_REC]) {
+        // enter settings menu
+        settings_init();
+        settings_run();
+        sleep_ms_wd(mem_data()->boot_anim_ms);
+    } else if (cnt == 3) {
         // skip splash screen
-    } else if ((!debug_buttons[BTN_REC]) && debug_buttons[BTN_CLICK]) {
+    } else if ((cnt == 1) && debug_buttons[BTN_CLICK]) {
         // show version info
         lcd_draw_version();
 
             usb_run();
             cnsl_run();
             led_set(i, true);
-            sleep_ms_wd(LOGO_INIT_MS / LED_COUNT);
+            sleep_ms_wd(mem_data()->boot_anim_ms / LED_COUNT);
         }
     }
 
     for (uint i = 0; i < LED_COUNT; i++) {
         led_set(i, false);
     }
+}
+
+void main_loop_hw(void) {
+    watchdog_update();
+
+    usb_run();
+    cnsl_run();
+    buttons_run();
+    encoder_run();
+    sequence_run();
+    pulse_run();
+    ui_run();
+
+    ui_encoder(encoder_get_diff());
+}
+
+int main(void) {
+    watchdog_enable(WATCHDOG_PERIOD_MS, 1);
+
+    cnsl_init();
+    usb_init();
+    mem_load();
+
+    hw_type_detection();
+
+    bat_init();
+    buttons_init();
+    encoder_init();
+    lcd_init();
+    led_init();
+
+    // show logo
+    lcd_draw_bitmap(logo_data,
+                    LOGO_WIDTH, LOGO_HEIGHT,
+                    0, 0);
+
+    animate_boot_combos();
 
     sequence_init();
     ui_init();

src/mem.c

+/*
+ * mem.c
+ *
+ * Copyright (c) 2023 - 2024 Thomas Buck (thomas@xythobuz.de)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * See <http://www.gnu.org/licenses/>.
+ */
+
+#include <string.h>
+
+#include "pico/flash.h"
+
+#include "config.h"
+#include "log.h"
+#include "sequence.h"
+#include "mem.h"
+
+struct mem_contents {
+    uint8_t version;
+    uint32_t checksum;
+
+    struct mem_data data;
+};
+
+#define MEM_CONTENTS_INIT { \
+    .version = MEM_VERSION, \
+    .checksum = 0,          \
+    .data = MEM_DATA_INIT,  \
+}
+
+static const struct mem_contents data_defaults = MEM_CONTENTS_INIT;
+static struct mem_contents data_ram = data_defaults;
+static const uint8_t *data_flash = (const uint8_t *)(XIP_BASE + EEPROM_FLASH_OFFSET);
+
+static_assert(sizeof(struct mem_contents) < FLASH_SECTOR_SIZE,
+              "Config needs to fit inside a flash sector");
+
+static uint32_t calc_checksum(const struct mem_contents *data) {
+    uint32_t c = 0xFFFFFFFF;
+    const uint8_t *d = (const uint8_t *)data;
+
+    const size_t offset_checksum = offsetof(struct mem_contents, checksum);
+    const size_t size_checksum = sizeof(data->checksum);
+
+    for (size_t i = 0; i < sizeof(struct mem_contents); i++) {
+        if ((i >= offset_checksum) && (i < (offset_checksum + size_checksum))) {
+            continue;
+        }
+
+        // adapted from "Hacker's Delight"
+        c ^= d[i];
+        for (size_t j = 0; j < 8; j++) {
+            uint32_t mask = -(c & 1);
+            c = (c >> 1) ^ (0xEDB88320 & mask);
+        }
+    }
+
+    return ~c;
+}
+
+void mem_load_defaults(void) {
+    data_ram = data_defaults;
+
+    for (uint32_t i = 0; i < NUM_CHANNELS; i++) {
+        data_ram.data.ch_timings[i] = CH_GPIO_DEFAULT_MS;
+    }
+}
+
+void mem_load(void) {
+    mem_load_defaults();
+
+    if (!flash_safe_execute_core_init()) {
+        debug("error calling flash_safe_execute_core_init");
+    }
+
+    const struct mem_contents *flash_ptr = (const struct mem_contents *)data_flash;
+
+    if (flash_ptr->version == MEM_VERSION) {
+        debug("found matching config (0x%02X)", flash_ptr->version);
+
+        uint32_t checksum = calc_checksum(flash_ptr);
+        if (checksum != flash_ptr->checksum) {
+            debug("invalid checksum (0x%08lX != 0x%08lX)", flash_ptr->checksum, checksum);
+        } else {
+            if (flash_ptr->data.ch_count != NUM_CHANNELS) {
+                debug("invalid channel count (0x%"PRIu32" != 0x%d)", flash_ptr->data.ch_count, NUM_CHANNELS);
+            } else {
+                debug("loading from flash (0x%08lX)", checksum);
+                data_ram = *flash_ptr;
+            }
+        }
+    } else {
+        debug("invalid config (0x%02X != 0x%02X)", flash_ptr->version, MEM_VERSION);
+    }
+}
+
+static void mem_write_flash(void *param) {
+    flash_range_erase(EEPROM_FLASH_OFFSET, FLASH_SECTOR_SIZE);
+
+    // TODO only need to write with length multiple of FLASH_PAGE_SIZE
+    flash_range_program(EEPROM_FLASH_OFFSET, param, FLASH_SECTOR_SIZE);
+}
+
+void mem_write(void) {
+    if (memcmp(&data_ram, data_flash, sizeof(struct mem_contents)) == 0) {
+        debug("no change, skip write");
+        return;
+    }
+
+    data_ram.checksum = calc_checksum(&data_ram);
+
+    debug("writing new data (0x%08lX)", data_ram.checksum);
+    int r = flash_safe_execute(mem_write_flash, &data_ram, FLASH_LOCK_TIMEOUT_MS);
+    if (r != PICO_OK) {
+        debug("error calling mem_write_flash: %d", r);
+    }
+}
+
+struct mem_data *mem_data(void) {
+    return &data_ram.data;
+}

src/memmap_custom.ld

+/*
+ * Based on Pico SDK memmap_default.ld
+ * https://community.element14.com/products/raspberry-pi/b/blog/posts/raspberry-pico-c-sdk-reserve-a-flash-memory-block-for-persistent-storage
+ */
+
+/*
+ * TODO hard-coded
+ */
+__PERSISTENT_STORAGE_LEN = 4k;
+
+MEMORY
+{
+    FLASH(rx) : ORIGIN = 0x10000000, LENGTH = 2048k - __PERSISTENT_STORAGE_LEN
+    FLASH_PERSISTENT(r) : ORIGIN = 0x10000000 + (2048k - __PERSISTENT_STORAGE_LEN) , LENGTH = __PERSISTENT_STORAGE_LEN
+    RAM(rwx) : ORIGIN =  0x20000000, LENGTH = 256k
+    SCRATCH_X(rwx) : ORIGIN = 0x20040000, LENGTH = 4k
+    SCRATCH_Y(rwx) : ORIGIN = 0x20041000, LENGTH = 4k
+}
+
+ENTRY(_entry_point)
+
+SECTIONS
+{
+    /* Second stage bootloader is prepended to the image. It must be 256 bytes big
+       and checksummed. It is usually built by the boot_stage2 target
+       in the Raspberry Pi Pico SDK
+    */
+
+    .flash_begin : {
+        __flash_binary_start = .;
+    } > FLASH
+
+    .boot2 : {
+        __boot2_start__ = .;
+        KEEP (*(.boot2))
+        __boot2_end__ = .;
+    } > FLASH
+
+    ASSERT(__boot2_end__ - __boot2_start__ == 256,
+        "ERROR: Pico second stage bootloader must be 256 bytes in size")
+
+    /* The second stage will always enter the image at the start of .text.
+       The debugger will use the ELF entry point, which is the _entry_point
+       symbol if present, otherwise defaults to start of .text.
+       This can be used to transfer control back to the bootrom on debugger
+       launches only, to perform proper flash setup.
+    */
+
+    .text : {
+        __logical_binary_start = .;
+        KEEP (*(.vectors))
+        KEEP (*(.binary_info_header))
+        __binary_info_header_end = .;
+        KEEP (*(.reset))
+        /* TODO revisit this now memset/memcpy/float in ROM */
+        /* bit of a hack right now to exclude all floating point and time critical (e.g. memset, memcpy) code from
+         * FLASH ... we will include any thing excluded here in .data below by default */
+        *(.init)
+        *(EXCLUDE_FILE(*libgcc.a: *libc.a:*lib_a-mem*.o *libm.a:) .text*)
+        *(.fini)
+        /* Pull all c'tors into .text */
+        *crtbegin.o(.ctors)
+        *crtbegin?.o(.ctors)
+        *(EXCLUDE_FILE(*crtend?.o *crtend.o) .ctors)
+        *(SORT(.ctors.*))
+        *(.ctors)
+        /* Followed by destructors */
+        *crtbegin.o(.dtors)
+        *crtbegin?.o(.dtors)
+        *(EXCLUDE_FILE(*crtend?.o *crtend.o) .dtors)
+        *(SORT(.dtors.*))
+        *(.dtors)
+
+        *(.eh_frame*)
+        . = ALIGN(4);
+    } > FLASH
+
+    .rodata : {
+        *(EXCLUDE_FILE(*libgcc.a: *libc.a:*lib_a-mem*.o *libm.a:) .rodata*)
+        . = ALIGN(4);
+        *(SORT_BY_ALIGNMENT(SORT_BY_NAME(.flashdata*)))
+        . = ALIGN(4);
+    } > FLASH
+
+    .ARM.extab :
+    {
+        *(.ARM.extab* .gnu.linkonce.armextab.*)
+    } > FLASH
+
+    __exidx_start = .;
+    .ARM.exidx :
+    {
+        *(.ARM.exidx* .gnu.linkonce.armexidx.*)
+    } > FLASH
+    __exidx_end = .;
+
+    /* Machine inspectable binary information */
+    . = ALIGN(4);
+    __binary_info_start = .;
+    .binary_info :
+    {
+        KEEP(*(.binary_info.keep.*))
+        *(.binary_info.*)
+    } > FLASH
+    __binary_info_end = .;
+    . = ALIGN(4);
+
+   .ram_vector_table (NOLOAD): {
+        *(.ram_vector_table)
+    } > RAM
+
+    .data : {
+        __data_start__ = .;
+        *(vtable)
+
+        *(.time_critical*)
+
+        /* remaining .text and .rodata; i.e. stuff we exclude above because we want it in RAM */
+        *(.text*)
+        . = ALIGN(4);
+        *(.rodata*)
+        . = ALIGN(4);
+
+        *(.data*)
+
+        . = ALIGN(4);
+        *(.after_data.*)
+        . = ALIGN(4);
+        /* preinit data */
+        PROVIDE_HIDDEN (__mutex_array_start = .);
+        KEEP(*(SORT(.mutex_array.*)))
+        KEEP(*(.mutex_array))
+        PROVIDE_HIDDEN (__mutex_array_end = .);
+
+        . = ALIGN(4);
+        /* preinit data */
+        PROVIDE_HIDDEN (__preinit_array_start = .);
+        KEEP(*(SORT(.preinit_array.*)))
+        KEEP(*(.preinit_array))
+        PROVIDE_HIDDEN (__preinit_array_end = .);
+
+        . = ALIGN(4);
+        /* init data */
+        PROVIDE_HIDDEN (__init_array_start = .);
+        KEEP(*(SORT(.init_array.*)))
+        KEEP(*(.init_array))
+        PROVIDE_HIDDEN (__init_array_end = .);
+
+        . = ALIGN(4);
+        /* finit data */
+        PROVIDE_HIDDEN (__fini_array_start = .);
+        *(SORT(.fini_array.*))
+        *(.fini_array)
+        PROVIDE_HIDDEN (__fini_array_end = .);
+
+        *(.jcr)
+        . = ALIGN(4);
+        /* All data end */
+        __data_end__ = .;
+    } > RAM AT> FLASH
+    /* __etext is (for backwards compatibility) the name of the .data init source pointer (...) */
+    __etext = LOADADDR(.data);
+
+    .uninitialized_data (NOLOAD): {
+        . = ALIGN(4);
+        *(.uninitialized_data*)
+    } > RAM
+
+    /* Start and end symbols must be word-aligned */
+    .scratch_x : {
+        __scratch_x_start__ = .;
+        *(.scratch_x.*)
+        . = ALIGN(4);
+        __scratch_x_end__ = .;
+    } > SCRATCH_X AT > FLASH
+    __scratch_x_source__ = LOADADDR(.scratch_x);
+
+    .scratch_y : {
+        __scratch_y_start__ = .;
+        *(.scratch_y.*)
+        . = ALIGN(4);
+        __scratch_y_end__ = .;
+    } > SCRATCH_Y AT > FLASH
+    __scratch_y_source__ = LOADADDR(.scratch_y);
+
+    .bss  : {
+        . = ALIGN(4);
+        __bss_start__ = .;
+        *(SORT_BY_ALIGNMENT(SORT_BY_NAME(.bss*)))
+        *(COMMON)
+        . = ALIGN(4);
+        __bss_end__ = .;
+    } > RAM
+
+    .heap (NOLOAD):
+    {
+        __end__ = .;
+        end = __end__;
+        KEEP(*(.heap*))
+        __HeapLimit = .;
+    } > RAM
+
+    /* .stack*_dummy section doesn't contains any symbols. It is only
+     * used for linker to calculate size of stack sections, and assign
+     * values to stack symbols later
+     *
+     * stack1 section may be empty/missing if platform_launch_core1 is not used */
+
+    /* by default we put core 0 stack at the end of scratch Y, so that if core 1
+     * stack is not used then all of SCRATCH_X is free.
+     */
+    .stack1_dummy (NOLOAD):
+    {
+        *(.stack1*)
+    } > SCRATCH_X
+    .stack_dummy (NOLOAD):
+    {
+        KEEP(*(.stack*))
+    } > SCRATCH_Y
+
+    .flash_end : {
+        PROVIDE(__flash_binary_end = .);
+    } > FLASH
+
+    /* stack limit is poorly named, but historically is maximum heap ptr */
+    __StackLimit = ORIGIN(RAM) + LENGTH(RAM);
+    __StackOneTop = ORIGIN(SCRATCH_X) + LENGTH(SCRATCH_X);
+    __StackTop = ORIGIN(SCRATCH_Y) + LENGTH(SCRATCH_Y);
+    __StackOneBottom = __StackOneTop - SIZEOF(.stack1_dummy);
+    __StackBottom = __StackTop - SIZEOF(.stack_dummy);
+    PROVIDE(__stack = __StackTop);
+
+    /* Check if data + heap + stack exceeds RAM limit */
+    ASSERT(__StackLimit >= __HeapLimit, "region RAM overflowed")
+
+    ASSERT( __binary_info_header_end - __logical_binary_start <= 256, "Binary info must be in first 256 bytes of the binary")
+    /* todo assert on extra code */
+}
+

src/sequence.c

 
 #include "led.h"
 #include "log.h"
+#include "mem.h"
 #include "pulse.h"
 #include "ui.h"
 #include "sequence.h"
 
-static const uint32_t channel_times[NUM_CHANNELS] = CH_GPIO_TIMINGS;
-
 static uint64_t us_per_beat = 0;
 static uint64_t last_t = 0;
 static uint64_t beattimer_start = 0;
     switch (btn) {
         case BTN_A:
         case BTN_E: {
-            pulse_trigger_out(0, channel_times[0]);
-            pulse_trigger_led(0, channel_times[0]);
-            pulse_trigger_led(4, channel_times[0]);
+            pulse_trigger_out(0, mem_data()->ch_timings[0]);
+            pulse_trigger_led(0, mem_data()->ch_timings[0]);
+            pulse_trigger_led(4, mem_data()->ch_timings[0]);
             break;
         }
 
         case BTN_B:
         case BTN_F: {
-            pulse_trigger_out(1, channel_times[1]);
-            pulse_trigger_led(1, channel_times[1]);
-            pulse_trigger_led(5, channel_times[1]);
+            pulse_trigger_out(1, mem_data()->ch_timings[1]);
+            pulse_trigger_led(1, mem_data()->ch_timings[1]);
+            pulse_trigger_led(5, mem_data()->ch_timings[1]);
             break;
         }
 
         case BTN_C:
         case BTN_G: {
-            pulse_trigger_out(2, channel_times[2]);
-            pulse_trigger_led(2, channel_times[2]);
-            pulse_trigger_led(6, channel_times[2]);
+            pulse_trigger_out(2, mem_data()->ch_timings[2]);
+            pulse_trigger_led(2, mem_data()->ch_timings[2]);
+            pulse_trigger_led(6, mem_data()->ch_timings[2]);
             break;
         }
 
 
         for (uint ch = 0; ch < NUM_CHANNELS; ch++) {
             if (sequence[i] & (1 << ch)) {
-                pulse_trigger_out(ch, channel_times[ch]);
+                pulse_trigger_out(ch, mem_data()->ch_timings[ch]);
                 if (ui_get_machinemode() == MODE_LOOPSTATION) {
-                    pulse_trigger_led(ch, channel_times[ch]);
-                    pulse_trigger_led(ch + 4, channel_times[ch]);
+                    pulse_trigger_led(ch, mem_data()->ch_timings[ch]);
+                    pulse_trigger_led(ch + 4, mem_data()->ch_timings[ch]);
                 }
             }
         }

src/settings.c

+/*
+ * settings.c
+ *
+ * Copyright (c) 2024 Thomas Buck (thomas@xythobuz.de)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * See <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdio.h>
+#include <inttypes.h>
+
+#include "pico/stdlib.h"
+#include "hardware/watchdog.h"
+
+#include "config.h"
+#include "buttons.h"
+#include "console.h"
+#include "encoder.h"
+#include "lcd.h"
+#include "log.h"
+#include "mem.h"
+#include "sequence.h"
+#include "ui.h"
+#include "usb.h"
+#include "settings.h"
+
+static uint32_t setting = 0;
+
+static void settings_redraw(void) {
+    char mode[64] = {0};
+    char val[64] = {0};
+    char bat[64] = {0};
+
+    if (setting >= (NUM_CHANNELS + 1)) {
+        snprintf(mode, sizeof(mode) - 1, "Memory");
+        snprintf(val, sizeof(val) - 1, "Save");
+    } else if (setting == NUM_CHANNELS) {
+        snprintf(mode, sizeof(mode) - 1, "Boot Anim");
+        snprintf(val, sizeof(val) - 1, "%"PRIu32"ms", mem_data()->boot_anim_ms);
+    } else {
+        snprintf(mode, sizeof(mode) - 1, "Channel %"PRIu32, setting);
+        snprintf(val, sizeof(val) - 1, "%"PRIu32"ms", mem_data()->ch_timings[setting]);
+    }
+
+    lcd_draw(mode, val, bat);
+}
+
+static void settings_buttons(enum buttons btn, bool val) {
+    switch (btn) {
+        case BTN_CLICK: {
+            if (val) {
+                setting = (setting + 1) % (NUM_CHANNELS + 2);
+                settings_redraw();
+            }
+            break;
+        }
+
+        default: {
+            break;
+        }
+    }
+}
+
+static bool settings_encoder(int32_t val) {
+    if (val == 0) {
+        return false;
+    }
+
+    if (setting >= (NUM_CHANNELS + 1)) {
+        mem_write();
+        lcd_draw("Save", "Ok!", "");
+        return true;
+    } else if (setting == NUM_CHANNELS) {
+        int32_t tmp = mem_data()->boot_anim_ms + val;
+        KEEP_IN_RANGE(tmp, 0, 10000);
+        mem_data()->boot_anim_ms = tmp;
+    } else {
+        int32_t tmp = mem_data()->ch_timings[setting] + val;
+        KEEP_IN_RANGE(tmp, 1, 100);
+        mem_data()->ch_timings[setting] = tmp;
+    }
+
+    settings_redraw();
+    return false;
+}
+
+void settings_init(void) {
+    buttons_callback(settings_buttons);
+    settings_redraw();
+}
+
+void settings_run(void) {
+    while (1) {
+        watchdog_update();
+        buttons_run();
+        encoder_run();
+        usb_run();
+        cnsl_run();
+
+        if (settings_encoder(encoder_get_diff())) {
+            break;
+        }
+    }
+}

src/ui.c

 #include "lcd.h"
 #include "led.h"
 #include "log.h"
+#include "mem.h"
 #include "pulse.h"
 #include "sequence.h"
 #include "usb.h"
 #include "usb_midi.h"
 #include "ui.h"
 
-#define KEEP_IN_RANGE(val, min, len) { \
-    while (val > (len - min)) {        \
-        val -= len;                    \
-    }                                  \
-    while (val < min) {                \
-        val += len;                    \
-    }                                  \
-}
-
 enum ui_settings {
     SETTING_MODE = 0,
 
 static float last_percentage = 0.0f;
 static uint8_t midi_rx = 0, midi_tx = 0;
 
-static const uint32_t channel_times[NUM_CHANNELS] = CH_GPIO_TIMINGS;
-
 enum machine_modes ui_get_machinemode(void) {
     return machine_mode;
 }
         case BTN_H: {
             if (val) {
                 usb_midi_tx(midi_tx, btn - BTN_A, 0x7F);
-                pulse_trigger_led(btn - BTN_A, channel_times[0]);
+                pulse_trigger_led(btn - BTN_A, mem_data()->ch_timings[0]);
             }
         }
 
 
     note = note % NUM_CHANNELS;
     if (velocity > 0) {
-        pulse_trigger_out(note, channel_times[note]);
+        pulse_trigger_out(note, mem_data()->ch_timings[note]);
     }
 }