implement missing loop station features.

update pico-sdk.
other small improvements.
mark as release 1.0.

.gitignore

 docs/src/inc_*.md
 
 3dprint/stl
+compile_commands.json

docs/src/drummachine.md

 # Drum Machine
 
-**TODO**: work in progress
+The drum-machine runs through a sequence of a given length, set by the `Length` menu.
+The corresponding LED lights up at it's moment in the sequence.
+Change the speed the sequence is running at with the `BPM` setting.
+If you have selected a `Length` that is longer than the available number of buttons / LEDs, you can switch your "window" of the sequence using the `Bank` setting.
+Select the currently edited output channel with the `Channel` menu.
+Use the CLEAR button below the encoder to zero-out the currently selected channel.

docs/src/pcb2.md

 Revision 1 and 2 are missing diodes on the button matrix.
 So when holding down three or more buttons simultaneously you get ghosting on other buttons.
 
+Depending on the solenoids you may reach a situation where not all channels can be properly triggered simultaneously.
+
+**To Do**: try to improve this by adding more capacitance to the power rail or between the voltage regulators and the mosfets?
+
 ## Bill of Materials
 
 These are all the parts required to assemble the V2 PCB.

include/config.h

 /*
  * config.h
  *
- * Copyright (c) 2022 - 2024 Thomas Buck (thomas@xythobuz.de)
+ * Copyright (c) 2022 - 2025 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
 #ifndef __CONFIG_H__
 #define __CONFIG_H__
 
-#define VERSION_MAJOR 0
-#define VERSION_MINOR 1
+#define VERSION_MAJOR 1
+#define VERSION_MINOR 0
 
 #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
+#define ENTER_BOOTLOADER_MAGIC 0x18 // ASCII 0x18 = CAN (cancel)
+#define ENTER_BOOTLOADER_BAUD 1200 // support picotool-like magic baudrate reset
 
 //#define DISABLE_CDC_DTR_CHECK
 #define DEBOUNCE_DELAY_MS 5

include/sequence.h

 /*
  * sequence.h
  *
- * Copyright (c) 2024 Thomas Buck (thomas@xythobuz.de)
+ * Copyright (c) 2024 - 2025 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
 uint32_t sequence_get_beats(void);
 
 void sequence_set_bank(uint32_t new_bank);
+void sequence_copy_bank(uint32_t new_bank);
 uint32_t sequence_get_bank(void);
 
 void sequence_set_channel(uint32_t new_channel);

pico-sdk

-Subproject commit 6a7db34ff63345a7badec79ebea3aaef1712f374
+Subproject commit bddd20f928ce76142793bef434d4f75f4af6e433

src/adc.c

 /*
  * adc.c
  *
- * Copyright (c) 2024 Thomas Buck (thomas@xythobuz.de)
+ * Copyright (c) 2024 - 2025 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
 
 void bat_init(void) {
     adc_init();
-    adc_gpio_init( ADC_PIN);
-    adc_select_input( ADC_NUM);
+    adc_gpio_init(ADC_PIN);
+    adc_select_input(ADC_NUM);
     filtered = bat_read();
 }
 

src/lcd.c

 /*
  * lcd.c
  *
- * Copyright (c) 2024 Thomas Buck (thomas@xythobuz.de)
+ * Copyright (c) 2024 - 2025 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
  * See <http://www.gnu.org/licenses/>.
  */
 
+#include <pico/version.h>
 #include <stdio.h>
 #include <string.h>
 
     char hw_id_str[42] = {0};
     if (hw_type == HW_PROTOTYPE) {
         snprintf(hw_id_str, sizeof(hw_id_str) - 1,
-                 "HW Prototype");
+                 "LARS HW: Proto");
     } else if (hw_type == HW_V2) {
         snprintf(hw_id_str, sizeof(hw_id_str) - 1,
-                 "HW V2");
+                 "LARS HW: V2");
     } else {
         snprintf(hw_id_str, sizeof(hw_id_str) - 1,
-                 "HW unknown %X", hw_type);
+                 "LARS HW: ?? %X", hw_type);
     }
     ssd1306_draw_string(&disp, 0, FONT_HEIGHT * 2 + 1 + (FONT_HEIGHT + 1) * 3, 1,
                         hw_id_str);
 
+    ssd1306_draw_string(&disp, 0, FONT_HEIGHT * 2 + 1 + (FONT_HEIGHT + 1) * 4, 1,
+                        "Pico SDK: " PICO_SDK_VERSION_STRING);
+
     ssd1306_show(&disp);
 }

src/mem.c

 /*
  * mem.c
  *
- * Copyright (c) 2023 - 2024 Thomas Buck (thomas@xythobuz.de)
+ * Copyright (c) 2023 - 2025 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
 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 uint8_t page_buffer[FLASH_PAGE_SIZE] = {0};
 
-static_assert(sizeof(struct mem_contents) < FLASH_SECTOR_SIZE,
+#define MEM_DATA_SIZE sizeof(struct mem_contents)
+static_assert(MEM_DATA_SIZE < FLASH_SECTOR_SIZE,
               "Config needs to fit inside a flash sector");
 
 static uint32_t calc_checksum(const struct mem_contents *data) {
     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);
+        debug("found matching config (0x%02"PRIX8")", 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);
+            debug("invalid checksum (0x%08"PRIX32" != 0x%08"PRIX32")", 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);
+                debug("loading from flash (0x%08"PRIX32")", checksum);
                 data_ram = *flash_ptr;
             }
         }
     } else {
-        debug("invalid config (0x%02X != 0x%02X)", flash_ptr->version, MEM_VERSION);
+        debug("invalid config (0x%02"PRIX8" != 0x%02X)", flash_ptr->version, MEM_VERSION);
     }
 }
 
 static void mem_write_flash(void *param) {
+    // we erase a 4K sector (FLASH_SECTOR_SIZE), but...
     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);
+    // ...can write in 256 byte pages (FLASH_PAGE_SIZE)
+    for (uint32_t off = 0; off < MEM_DATA_SIZE; off += FLASH_PAGE_SIZE) {
+        memset(page_buffer, 0xFF, FLASH_PAGE_SIZE);
+        memcpy(page_buffer, param + off, MIN(FLASH_PAGE_SIZE, MEM_DATA_SIZE - off));
+        flash_range_program(EEPROM_FLASH_OFFSET + off, page_buffer, FLASH_PAGE_SIZE);
+    }
 }
 
 void mem_write(void) {
 
     data_ram.checksum = calc_checksum(&data_ram);
 
-    debug("writing new data (0x%08lX)", data_ram.checksum);
+    debug("writing new data (0x%08"PRIX32")", 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);

src/sequence.c

 /*
  * sequence.c
  *
- * Copyright (c) 2024 Thomas Buck (thomas@xythobuz.de)
+ * Copyright (c) 2024 - 2025 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
 static uint32_t channel = 0;
 static bool button_held[NUM_BTNS] = {0};
 
-static enum channels sequence[MAX_BEATS] = {0};
+/*
+ * 'bank' has a dual meaning here. this is a bit fugly.
+ *
+ * In drum-machine mode, the bank means which part of the sequence
+ * is shown on the available LEDs / buttons.
+ * This is always using sequence[0][n]
+ *
+ * In loop-station mode it actually means the sequence[bank][n].
+ */
+
+static enum channels sequence[MAX_BANKS][MAX_BEATS] = {0};
 
 void sequence_init(void) {
     us_per_beat = 0;
     last_i = 0;
     max_banks_currently = (beats + (NUM_BTNS - 1)) / NUM_BTNS;
 
-    for (uint i = 0; i < MAX_BEATS; i++) {
-        sequence[i] = 0;
+    for (uint b = 0; b < MAX_BANKS; b++) {
+        for (uint i = 0; i < MAX_BEATS; i++) {
+            sequence[b][i] = 0;
+        }
     }
 }
 
     bank = (b < max_banks_currently) ? b : 0;
 }
 
+void sequence_copy_bank(uint32_t new_bank) {
+    uint32_t prev = bank;
+    sequence_set_bank(new_bank);
+
+    for (uint i = 0; i < MAX_BEATS; i++) {
+        sequence[bank][i] = sequence[prev][i];
+    }
+}
+
 uint32_t sequence_get_bank(void) {
     return bank;
 }
     return us_per_beat;
 }
 
-static void sequence_set(uint32_t beat, enum channels ch, bool value) {
+static void sequence_set(uint32_t beat, enum channels ch, bool value, uint32_t sel_bank) {
     if (beat < MAX_BEATS) {
         if (value) {
-            sequence[beat] |= ch;
+            sequence[sel_bank][beat] |= ch;
         } else {
-            sequence[beat] &= ~ch;
+            sequence[sel_bank][beat] &= ~ch;
         }
     }
 }
 
-static bool sequence_get(uint32_t beat, enum channels ch) {
+static bool sequence_get(uint32_t beat, enum channels ch, uint32_t sel_bank) {
     if (beat < MAX_BEATS) {
-        return (sequence[beat] & ch) != 0;
+        return (sequence[sel_bank][beat] & ch) != 0;
     }
     return false;
 }
             }
 
             if (button_held[BTN_H]) {
-                // right REC: clear all loops in all banks
-                // TODO other banks
+                // right REC: clear all loops in all banks, including length
                 sequence_init();
             } else if (button_held[BTN_D]) {
                 // left REC: clear the current loop, including the length
-                sequence_init();
+                us_per_beat = 0;
+                for (uint i = 0; i < MAX_BEATS; i++) {
+                    sequence[bank][i] = 0;
+                }
             } else if (button_held[BTN_E] || button_held[BTN_F] || button_held[BTN_G]) {
                 // channel mute buttons: clear only this channel in the current loop
-                // TODO
+                enum channels to_del = 0;
+                if (button_held[BTN_E]) to_del |= CH1;
+                if (button_held[BTN_F]) to_del |= CH2;
+                if (button_held[BTN_G]) to_del |= CH3;
+                for (uint i = 0; i < MAX_BEATS; i++) {
+                    sequence_set(i, to_del, false, bank);
+                }
             } else {
                 // on its own: clear all channels of the current loop, keeping the set length
-                // TODO
+                for (uint i = 0; i < MAX_BEATS; i++) {
+                    sequence[bank][i] = 0;
+                }
             }
 
             ui_redraw();
     if ((button_held[BTN_D] || button_held[BTN_H]) && val) {
         switch (btn) {
             case BTN_A: {
-                sequence_set(last_i, CH_KICK, true);
+                sequence_set(last_i, CH_KICK, true, bank);
                 break;
             }
 
             case BTN_B: {
-                sequence_set(last_i, CH_SNARE, true);
+                sequence_set(last_i, CH_SNARE, true, bank);
                 break;
             }
 
             case BTN_C: {
-                sequence_set(last_i, CH_HIHAT, true);
+                sequence_set(last_i, CH_HIHAT, true, bank);
                 break;
             }
 
         case BTN_G:
         case BTN_H: {
             uint32_t beat = (btn - BTN_A) + bank * LED_COUNT;
-            bool val = !sequence_get(beat, 1 << channel);
-            sequence_set(beat, 1 << channel, val);
+            bool val = !sequence_get(beat, 1 << channel, 0);
+            sequence_set(beat, 1 << channel, val, 0);
+            break;
+        }
+
+        case BTN_CLEAR: {
+            // clear current channel
+            for (uint i = 0; i < MAX_BEATS; i++) {
+                sequence_set(i, 1 << channel, false, 0);
+            }
             break;
         }
 
                 continue;
             }
 
-            if (sequence[i] & (1 << ch)) {
+            uint32_t b = (ui_get_machinemode() == MODE_DRUMMACHINE) ? 0 : bank;
+            if (sequence[b][i] & (1 << ch)) {
                 // trigger channel solenoid
                 pulse_trigger_out(ch, mem_data()->ch_timings[ch]);
 
                     pulse_trigger_led(ch, mem_data()->ch_timings[ch]);
                     pulse_trigger_led(ch + 4, mem_data()->ch_timings[ch]);
                 }
+
+
             }
         }
 

src/ui.c

 /*
  * ui.c
  *
- * Copyright (c) 2024 Thomas Buck (thomas@xythobuz.de)
+ * Copyright (c) 2024 - 2025 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
 
     // loop station
     SETTING_SPEED,
+    SETTING_BANK_SELECT,
+    SETTING_BANK_COPY,
 
     // drum machine
     SETTING_BPM,
     // MODE_LOOPSTATION
     {
         true, // SETTING_MODE
-        true,
-        false, false, false, false,
-        false, false,
+        true, true, true, // SETTING_SPEED, SETTING_BANK_SELECT, SETTING_BANK_COPY
+        false, false, false, false, // SETTING_BPM, SETTING_LENGTH, SETTING_BANK, SETTING_CHANNEL
+        false, false, // SETTING_CH_RX, SETTING_CH_TX
     },
 
     // MODE_DRUMMACHINE
     {
         true, // SETTING_MODE
-        false,
-        true, true, true, true,
-        false, false,
+        false, false, false, // SETTING_SPEED, SETTING_BANK_SELECT, SETTING_BANK_COPY
+        true, true, true, true, // SETTING_BPM, SETTING_LENGTH, SETTING_BANK, SETTING_CHANNEL
+        false, false, // SETTING_CH_RX, SETTING_CH_TX
     },
 
     // MODE_MIDI
     {
         true, // SETTING_MODE
-        false,
-        false, false, false, false,
-        true, true,
+        false, false, false, // SETTING_SPEED, SETTING_BANK_SELECT, SETTING_BANK_COPY
+        false, false, false, false, // SETTING_BPM, SETTING_LENGTH, SETTING_BANK, SETTING_CHANNEL
+        true, true, // SETTING_CH_RX, SETTING_CH_TX
     },
 };
 
 static float last_voltage = 0.0f;
 static float last_percentage = 0.0f;
 static uint8_t midi_rx = 0, midi_tx = 0;
+static uint32_t bank_select_num = 0, bank_copy_num = 0;
 
 enum machine_modes ui_get_machinemode(void) {
     return machine_mode;
             break;
         }
 
+        case SETTING_BANK_SELECT: {
+            snprintf(mode, sizeof(mode) - 1, "Sel-Bnk:");
+            snprintf(val, sizeof(val) - 1, "%"PRIu32, bank_select_num);
+            break;
+        }
+
+        case SETTING_BANK_COPY: {
+            snprintf(mode, sizeof(mode) - 1, "Cpy-Bnk:");
+            snprintf(val, sizeof(val) - 1, "%"PRIu32, bank_copy_num);
+            break;
+        }
+
         case SETTING_CH_RX: {
             snprintf(mode, sizeof(mode) - 1, "Rx-Ch:");
             snprintf(val, sizeof(val) - 1, "%"PRIu8, midi_rx + 1);
     switch (btn) {
         case BTN_CLICK: {
             if (val) {
+                enum ui_settings prev_setting = ui_setting;
+
                 // only allow settings for this mode
                 do {
                     ui_setting = (ui_setting + 1) % SETTING_NUM_MODES;
                 } while (!allowed_settings[machine_mode][ui_setting]);
 
+                if (prev_setting == SETTING_BANK_COPY) {
+                    sequence_copy_bank(bank_copy_num);
+                } else if (prev_setting == SETTING_BANK_SELECT) {
+                    sequence_set_bank(bank_select_num);
+                }
+
+                if (ui_setting == SETTING_BANK_COPY) {
+                    bank_copy_num = sequence_get_bank();
+                } else if (ui_setting == SETTING_BANK_SELECT) {
+                    bank_select_num = sequence_get_bank();
+                }
+
                 ui_redraw();
             }
             break;
                 }
 
                 case MODE_MIDI: {
-                    if (val) {
+                    if (val && (btn != BTN_CLEAR)) {
                         usb_midi_tx(midi_tx, btn - BTN_A, 0x7F);
                         pulse_trigger_led(btn - BTN_A, mem_data()->ch_timings[0]);
                     }
             break;
         }
 
+        case SETTING_BANK_SELECT: {
+            int32_t tmp = bank_select_num + val;
+            KEEP_IN_RANGE(tmp, 0, (int32_t)sequence_get_max_banks());
+            break;
+        }
+
+        case SETTING_BANK_COPY: {
+            int32_t tmp = bank_copy_num + val;
+            KEEP_IN_RANGE(tmp, 0, (int32_t)sequence_get_max_banks());
+            break;
+            break;
+        }
+
         case SETTING_CH_RX: {
             int32_t tmp = midi_rx + val;
             KEEP_IN_RANGE(tmp, 0, MIDI_MAX_CH);

src/usb_cdc.c

 /*
  * Extended from TinyUSB example code.
  *
- * Copyright (c) 2022 - 2023 Thomas Buck (thomas@xythobuz.de)
+ * Copyright (c) 2022 - 2025 Thomas Buck (thomas@xythobuz.de)
  *
  * The MIT License (MIT)
  *
         char buf[cdc_buf_len + 1];
         uint32_t count = tud_cdc_read(buf, cdc_buf_len);
 
+#ifdef ENTER_BOOTLOADER_MAGIC
+        // TODO support magic byte in other places instead of offset 0?
         if ((count >= 1) && (buf[0] == ENTER_BOOTLOADER_MAGIC)) {
             reset_to_bootloader();
-        } else if (reroute_cdc_debug) {
+        } else
+#endif // ENTER_BOOTLOADER_MAGIC
+
+        if (reroute_cdc_debug) {
             debug_handle_input((const uint8_t *)buf, count);
         } else {
             cnsl_handle_input((const uint8_t *)buf, count);
     last_dtr = dtr;
 }
 
+#ifdef ENTER_BOOTLOADER_BAUD
+
+// Invoked when line coding is change via SET_LINE_CODING
+void tud_cdc_line_coding_cb(uint8_t itf, cdc_line_coding_t const* p_line_coding) {
+    (void) itf;
+    if (p_line_coding->bit_rate == ENTER_BOOTLOADER_BAUD) {
+        reset_to_bootloader();
+    }
+}
+
+#endif // ENTER_BOOTLOADER_BAUD
+
 // invoked when CDC interface received data from host
 void tud_cdc_rx_cb(uint8_t itf) {
     (void) itf;