add channel muting in loop station

docs/src/loopstation.md

 # Loop Station
 
+[![LARS Loop Station controls](https://www.xythobuz.de/img/lars_loop_controls_small.jpg)](https://www.xythobuz.de/img/lars_loop_controls.jpg)
+
 In this mode the first three buttons play each corresponding output channel.
 
-The fourth button, with the LED always lit, is the record button.
+The fourth (and eighth) button, with the LED always lit, is the record button.
 Hold it down for a while and release it to set the length of the loop.
 
 Notes played while the record button is held will be looped.
 
+The fifth, sixth and seventh buttons are channel mute buttons.
+While holding these down the corresponding channel will not play any notes.
+
 The top-right button below the encoder clears the recorded loop in different ways:
 
  * Pressing it on its own will clear all channels of the current loop, keeping the set length.
- * Presssing it while holding down one of the channel mute buttons will clear only this channel in the current loop.
+ * Pressing it while holding down one of the channel mute buttons will clear only this channel in the current loop.
  * Pressing it while holding down the left REC button will clear the current loop, including the length.
  * Pressing it while holding down the right REC button will clear all loops in all banks.
 

docs/src/usage.md

 
 You can hold down some buttons while powering on the device to get different effects:
 
-* hold the `REC` button to enter the configuration menu
+* hold the `Clear` 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 both `Clear` and `Click` to enter the button test mode
 * hold any combination of three buttons to skip the boot animation

flash.sh

 then
     echo Resetting Raspberry Pi Pico
     echo -n -e "\\x18" > $SERIAL
-    echo -n -e "\\x18" > $SERIAL
 fi
 
 echo -n Waiting for disk to appear

include/buttons.h

     BTN_G,
     BTN_H,
 
-    BTN_REC,
+    BTN_CLEAR,
     BTN_CLICK,
     NUM_BTNS // count
 };

include/ui.h

 
 enum machine_modes ui_get_machinemode(void);
 
+void ui_redraw(void);
+
 #endif // __UI_H__

src/buttons.c

     0xFF, // BTN_G
     0xFF, // BTN_H
 
-    14, // BTN_REC
+    14, // BTN_CLEAR
     16, // BTN_CLICK
 };
 
     0xFF, // BTN_F
     0xFF, // BTN_G
     0xFF, // BTN_H
-    0xFF, // BTN_REC
+    0xFF, // BTN_CLEAR
 
     20, // BTN_CLICK
 };

src/main.c

     uint32_t cnt = debug_count_buttons();
 
     // handle special button combos on boot
-    if ((cnt == 2) && debug_buttons[BTN_REC] && debug_buttons[BTN_CLICK]) {
+    if ((cnt == 2) && debug_buttons[BTN_CLEAR] && debug_buttons[BTN_CLICK]) {
         lcd_debug_buttons();
-    } else if ((cnt == 1) && debug_buttons[BTN_REC]) {
+    } else if ((cnt == 1) && debug_buttons[BTN_CLEAR]) {
         // enter settings menu
         settings_init();
         settings_run();

src/sequence.c

 static uint32_t bank = 0;
 static uint32_t max_banks_currently = 0;
 static uint32_t channel = 0;
+static bool button_held[NUM_BTNS] = {0};
 
 static enum channels sequence[MAX_BEATS] = {0};
 
     return false;
 }
 
-void sequence_handle_button_loopstation(enum buttons btn, bool rec) {
+void sequence_handle_button_loopstation(enum buttons btn, bool val) {
+    button_held[btn] = val;
+
     switch (btn) {
         case BTN_A: {
+            // only react to button down events
+            if (!val) {
+                break;
+            }
+
+            // trigger outputs and LEDs
             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]);
         }
 
         case BTN_B: {
+            // only react to button down events
+            if (!val) {
+                break;
+            }
+
+            // trigger outputs and LEDs
             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]);
         }
 
         case BTN_C: {
+            // only react to button down events
+            if (!val) {
+                break;
+            }
+
+            // trigger outputs and LEDs
             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;
         }
 
-        case BTN_E: {
-            // TODO mute/unmute according to rec param
-            return; // not recording sequence!
+        case BTN_D:
+        case BTN_H: {
+            sequence_looptime(!val);
+            if (!val) {
+                ui_redraw();
+            }
+            break;
         }
 
-        case BTN_F: {
-            // TODO mute/unmute according to rec param
-            return; // not recording sequence!
-        }
+        case BTN_CLEAR: {
+            // only react to button down events
+            if (!val) {
+                break;
+            }
 
-        case BTN_G: {
-            // TODO mute/unmute according to rec param
-            return; // not recording sequence!
+            if (button_held[BTN_H]) {
+                // right REC: clear all loops in all banks
+                // TODO other banks
+                sequence_init();
+            } else if (button_held[BTN_D]) {
+                // left REC: clear the current loop, including the length
+                sequence_init();
+            } 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
+            } else {
+                // on its own: clear all channels of the current loop, keeping the set length
+                // TODO
+            }
+
+            ui_redraw();
+            break;
         }
 
         default: {
         }
     }
 
-    if (rec) {
+    // set marker in sequence when one of the REC buttons was held
+    if ((button_held[BTN_D] || button_held[BTN_H]) && val) {
         switch (btn) {
-            case BTN_A:
-            case BTN_E: {
+            case BTN_A: {
                 sequence_set(last_i, CH_KICK, true);
                 break;
             }
 
-            case BTN_B:
-            case BTN_F: {
+            case BTN_B: {
                 sequence_set(last_i, CH_SNARE, true);
                 break;
             }
 
-            case BTN_C:
-            case BTN_G: {
+            case BTN_C: {
                 sequence_set(last_i, CH_HIHAT, true);
                 break;
             }
         }
 
         for (uint ch = 0; ch < NUM_CHANNELS; ch++) {
+            // skip muted channels
+            if ((ui_get_machinemode() == MODE_LOOPSTATION) && button_held[BTN_E + ch]) {
+                continue;
+            }
+
             if (sequence[i] & (1 << ch)) {
+                // trigger channel solenoid
                 pulse_trigger_out(ch, mem_data()->ch_timings[ch]);
+
+                // flash LEDs in loopstation mode
                 if (ui_get_machinemode() == MODE_LOOPSTATION) {
                     pulse_trigger_led(ch, mem_data()->ch_timings[ch]);
                     pulse_trigger_led(ch + 4, mem_data()->ch_timings[ch]);

src/ui.c

     },
 };
 
-static bool rec_held_down = false;
 static enum ui_settings ui_setting = 0;
 static enum machine_modes machine_mode = 0;
 static uint32_t last_bat_fetch = 0;
     return machine_mode;
 }
 
-static void ui_redraw(void) {
+void ui_redraw(void) {
     char mode[64] = {0};
     char val[64] = {0};
     char bat[64] = {0};
     lcd_draw(mode, val, bat);
 }
 
-static void ui_buttons_loopstation(enum buttons btn, bool val) {
-    switch (btn) {
-        case BTN_A:
-        case BTN_B:
-        case BTN_C: {
-            if (val) {
-                sequence_handle_button_loopstation(btn, rec_held_down);
-            }
-            break;
-        }
-
-        case BTN_E:
-        case BTN_F:
-        case BTN_G: {
-            sequence_handle_button_loopstation(btn, val);
-            break;
-        }
-
-        case BTN_REC: {
-            // reset sequence
-            sequence_init();
-            ui_redraw();
-            break;
-        }
-
-        case BTN_D:
-        case BTN_H: {
-            rec_held_down = val;
-            sequence_looptime(!val);
-            if (!val) {
-                ui_redraw();
-            }
-            break;
-        }
-
-        default: {
-            debug("invalid btn: %d", btn);
-            break;
-        }
-    }
-}
-
-static void ui_buttons_drummachine(enum buttons btn, bool val) {
-    switch (btn) {
-        case BTN_A:
-        case BTN_B:
-        case BTN_C:
-        case BTN_D:
-        case BTN_E:
-        case BTN_F:
-        case BTN_G:
-        case BTN_H:
-        case BTN_REC: {
-            if (val) {
-                sequence_handle_button_drummachine(btn);
-            }
-            break;
-        }
-
-        default: {
-            debug("invalid btn: %d", btn);
-            break;
-        }
-    }
-}
-
-static void ui_buttons_midi(enum buttons btn, bool val) {
-    switch (btn) {
-        case BTN_A:
-        case BTN_B:
-        case BTN_C:
-        case BTN_D:
-        case BTN_E:
-        case BTN_F:
-        case BTN_G:
-        case BTN_H: {
-            if (val) {
-                usb_midi_tx(midi_tx, btn - BTN_A, 0x7F);
-                pulse_trigger_led(btn - BTN_A, mem_data()->ch_timings[0]);
-            }
-        }
-
-        default:
-            break;
-    }
-}
-
 static void ui_buttons(enum buttons btn, bool val) {
     switch (btn) {
         case BTN_CLICK: {
         default: {
             switch (machine_mode) {
                 case MODE_LOOPSTATION: {
-                    ui_buttons_loopstation(btn, val);
+                    sequence_handle_button_loopstation(btn, val);
                     break;
                 }
 
                 case MODE_DRUMMACHINE: {
-                    ui_buttons_drummachine(btn, val);
+                    if (val) {
+                        sequence_handle_button_drummachine(btn);
+                    }
                     break;
                 }
 
                 case MODE_MIDI: {
-                    ui_buttons_midi(btn, val);
+                    if (val) {
+                        usb_midi_tx(midi_tx, btn - BTN_A, 0x7F);
+                        pulse_trigger_led(btn - BTN_A, mem_data()->ch_timings[0]);
+                    }
                     break;
                 }