add pwm led brightness control. fix led pins for prototype hardware.

docs/src/drummachine.md

 # Drum Machine
 
 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.
+The currently active "step" is fully bright while enabled ones are lit dimly.
+
 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.

include/config.h

 #define __CONFIG_H__
 
 #define VERSION_MAJOR 1
-#define VERSION_MINOR 0
+#define VERSION_MINOR 1
 
 #define WATCHDOG_PERIOD_MS 100
 #define LOGO_INIT_MS 1000

include/led.h

 /*
  * led.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
 #include <stdint.h>
 #include <stdbool.h>
 
-#if 0
-#define LED_COUNT 4
-#else
-#define LED_COUNT 8
-#endif
+#define MAX_LED_COUNT 8
 
 void led_init(void);
+uint8_t led_count(void);
+
 void led_set(uint32_t i, bool v);
+void led_dim(uint32_t i, uint8_t v);
+
 void ch_set(uint32_t i, bool v);
 
 #endif // __LED_H__

src/led.c

 /*
  * led.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 <stdint.h>
 #include <stdio.h>
 #include "pico/stdlib.h"
+#include "hardware/pwm.h"
 
-#include "sequence.h"
 #include "log.h"
+#include "main.h"
+#include "sequence.h"
 #include "led.h"
 
-#if 0
-static const uint led_gpio_num[LED_COUNT] = {
+/*
+ * Beware:
+ * PWM driving the LED outputs assumes that the pins are not on
+ * shared PWM slices / channels!
+ * For RP2040: all GPIO numbers < 16 are safe
+ *
+ * Unfortunately the output channels on 26 and 27 are in conflict
+ * with the LEDs on pins 10 and 11, in both hardware revisions.
+ * So we only use PWM for the LEDs.
+ */
+
+static const uint led_gpio_num_proto[MAX_LED_COUNT] = {
     10, 11, 13, 15,
 };
-#else
-static const uint led_gpio_num[LED_COUNT] = {
+
+static const uint led_gpio_num_v2[MAX_LED_COUNT] = {
     6, 7, 8, 9, 10, 11, 12, 13,
 };
-#endif
 
 static const uint ch_gpio_num[NUM_CHANNELS] = {
     22, 26, 27,
 };
 
+uint8_t led_count(void) {
+    if (hw_type == HW_PROTOTYPE) {
+        return 4;
+    }
+    return MAX_LED_COUNT;
+}
+
 void led_init(void) {
-    for (uint i = 0; i < LED_COUNT; i++) {
-        gpio_init(led_gpio_num[i]);
-        gpio_set_dir(led_gpio_num[i], GPIO_OUT);
+    for (uint i = 0; i < led_count(); i++) {
+        uint p = 0xFF;
+        if (hw_type == HW_PROTOTYPE) {
+            p = led_gpio_num_proto[i];
+        } else if (hw_type == HW_V2) {
+            p = led_gpio_num_v2[i];
+        }
+        if (p >= 0xFF) {
+            continue;
+        }
+
+        gpio_init(p);
+        gpio_set_dir(p, GPIO_OUT);
+        gpio_set_function(p, GPIO_FUNC_PWM);
+
+        uint slice_num = pwm_gpio_to_slice_num(p);
+        pwm_set_wrap(slice_num, UINT8_MAX);
+        pwm_set_chan_level(slice_num, pwm_gpio_to_channel(p), 0);
+        pwm_set_enabled(slice_num, true);
     }
+
     for (uint i = 0; i < NUM_CHANNELS; i++) {
         gpio_init(ch_gpio_num[i]);
         gpio_set_dir(ch_gpio_num[i], GPIO_OUT);
 }
 
 void led_set(uint32_t i, bool v) {
-    i %= LED_COUNT;
-    gpio_put(led_gpio_num[i], v);
+    led_dim(i, v ? UINT8_MAX : 0);
+}
+
+void led_dim(uint32_t i, uint8_t v) {
+    i %= led_count();
+
+    uint p = 0xFF;
+    if (hw_type == HW_PROTOTYPE) {
+        p = led_gpio_num_proto[i];
+    } else if (hw_type == HW_V2) {
+        p = led_gpio_num_v2[i];
+    }
+    if (p >= 0xFF) {
+        return;
+    }
+
+    pwm_set_chan_level(pwm_gpio_to_slice_num(p), pwm_gpio_to_channel(p), v);
     //debug("led %"PRIu32" now %d", i, v);
 }
 

src/main.c

         led_set(0, false);
     } else {
         // show splash for a bit and animate LEDs
-        for (uint i = 0; i < LED_COUNT; i++) {
+        for (uint i = 0; i < led_count(); i++) {
             watchdog_update();
             usb_run();
             cnsl_run();
             led_set(i, true);
-            sleep_ms_wd(mem_data()->boot_anim_ms / LED_COUNT);
+            sleep_ms_wd(mem_data()->boot_anim_ms / led_count());
         }
     }
 
     // turn off LEDs at end of init
-    for (uint i = 0; i < LED_COUNT; i++) {
+    for (uint i = 0; i < led_count(); i++) {
         led_set(i, false);
     }
 }

src/pulse.c

 /*
  * pulse.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
 #include "pulse.h"
 
 static uint32_t out_time[NUM_CHANNELS] = {0};
-static uint32_t led_time[LED_COUNT] = {0};
+static uint32_t led_time[MAX_LED_COUNT] = {0};
 
 static void pulse_trigger(uint32_t i, uint32_t t_ms, bool out) {
     uint32_t off_t = t_ms + to_ms_since_boot(get_absolute_time());
         }
     } else {
         led_set(i, true);
-        if (led_time[i % LED_COUNT] == 0) {
-            led_time[i % LED_COUNT] = off_t;
+        if (led_time[i % MAX_LED_COUNT] == 0) {
+            led_time[i % MAX_LED_COUNT] = off_t;
         } else {
             debug("skip retrigger led %"PRIu32, i);
         }
         }
     }
 
-    for (uint i = 0; i < LED_COUNT; i++) {
+    for (uint i = 0; i < MAX_LED_COUNT; i++) {
         if (led_time[i] != 0) {
             if (led_time[i] <= now) {
                 led_set(i, false);

src/sequence.c

 static uint32_t channel = 0;
 static bool button_held[NUM_BTNS] = {0};
 
+// LED PWM brightness
+enum led_dimmer_types {
+    DIM_HIGH = 255, // currently active beat
+    DIM_MID = 80, // beat active in current channel
+    DIM_LOW = 16, // beat active in another channel
+    DIM_OFF = 0, // beat inactive
+};
+
 /*
  * 'bank' has a dual meaning here. this is a bit fugly.
  *
         case BTN_F:
         case BTN_G:
         case BTN_H: {
-            uint32_t beat = (btn - BTN_A) + bank * LED_COUNT;
+            uint32_t beat = (btn - BTN_A) + bank * led_count();
             bool val = !sequence_get(beat, 1 << channel, 0);
             sequence_set(beat, 1 << channel, val, 0);
             break;
         if (i >= beats) i = 0;
 
         if (ui_get_machinemode() == MODE_DRUMMACHINE) {
-            led_set(last_i, false);
-            led_set(i, true);
+            // turn off "previous" led, or dim it, if it is set in another bank
+            enum led_dimmer_types dim = DIM_OFF;
+            for (uint b = 0; b < (MAX_BEATS / led_count()); b++) {
+                uint n = b * led_count();
+                for (uint ch = 0; ch < NUM_CHANNELS; ch++) {
+                    if (sequence_get(n + (last_i % led_count()), (1 << ch), 0)) {
+                        if (ch == channel) {
+                            dim = DIM_MID;
+                            break;
+                        }
+                        dim = DIM_LOW;
+                    }
+                }
+            }
+            led_dim(last_i, dim);
+
+            // always turn on "currrent" led
+            led_dim(i, DIM_HIGH);
         }
 
         for (uint ch = 0; ch < NUM_CHANNELS; ch++) {

src/ui.c

                 sequence_init();
 
                 // turn off all LEDs
-                for (uint i = 0; i < LED_COUNT; i++) {
+                for (uint i = 0; i < led_count(); i++) {
                     led_set(i, false);
                 }
 
                     led_set(NUM_CHANNELS, true);
                     led_set(NUM_CHANNELS + 4, true);
                 } else if (machine_mode == MODE_DRUMMACHINE) {
-                    sequence_set_beats(LED_COUNT);
+                    sequence_set_beats(led_count());
                     sequence_set_bpm(120);
                     sequence_set_bank(0);
                     sequence_set_channel(0);