fix some ui bugs

include/config.h

 //#define DISABLE_CDC_DTR_CHECK
 #define DEBOUNCE_DELAY_MS 5
 
+#define BAT_FETCH_MS 66
+
+#define MAX_BPM 360
+
 // ----------------------------------------------------------------------------
 
 #define STR_HELPER(x) #x

include/sequence.h

 void sequence_set_bpm(uint32_t new_bpm);
 uint32_t sequence_get_bpm(void);
 
-void sequence_set_ms(uint32_t new_ms);
-uint32_t sequence_get_ms(void);
-
 void sequence_set_beats(uint32_t new_beats);
 uint32_t sequence_get_beats(void);
 
 void sequence_set_bank(uint32_t new_bank);
 uint32_t sequence_get_bank(void);
 
+uint32_t sequence_get_max_banks(void);
+uint64_t sequence_get_us(void);
+
 void sequence_handle_button_loopstation(enum buttons btn, bool rec);
 void sequence_handle_button_drummachine(enum buttons btn);
 

src/buttons.c

 #include "pico/stdlib.h"
 
 #include "config.h"
+#include "log.h"
 #include "main.h"
 #include "buttons.h"
 
 
     if ((now - buttons[i].last_time) > DEBOUNCE_DELAY_MS) {
         if (state != buttons[i].current_state) {
-            printf("btn %d now %s\n", i, state ? "pressed" : "released");
+            //debug("btn %d now %s", i, state ? "pressed" : "released");
 
             buttons[i].current_state = state;
             if (callback) {

src/led.c

 #include "pico/stdlib.h"
 
 #include "sequence.h"
+#include "log.h"
 #include "led.h"
 
 #if 0
 void led_set(uint32_t i, bool v) {
     i %= LED_COUNT;
     gpio_put(led_gpio_num[i], v);
-    //printf("led %"PRIu32" now %d\n", i, v);
+    //debug("led %"PRIu32" now %d", i, v);
 }
 
 void ch_set(uint32_t i, bool v) {
     i %= NUM_CHANNELS;
     gpio_put(ch_gpio_num[i], v);
-    //printf("ch %"PRIu32" now %d\n", i, v);
+    //debug("ch %"PRIu32" now %d", i, v);
 }

src/pulse.c

 #include "pico/stdlib.h"
 
 #include "led.h"
+#include "log.h"
 #include "sequence.h"
 #include "pulse.h"
 
         if (out_time[i % NUM_CHANNELS] == 0) {
             out_time[i % NUM_CHANNELS] = off_t;
         } else {
-            printf("%s: skip retrigger out %"PRIu32"\n", __func__, i);
+            debug("skip retrigger out %"PRIu32, i);
         }
     } else {
         led_set(i, true);
         if (led_time[i % LED_COUNT] == 0) {
             led_time[i % LED_COUNT] = off_t;
         } else {
-            printf("%s: skip retrigger led %"PRIu32"\n", __func__, i);
+            debug("skip retrigger led %"PRIu32, i);
         }
     }
 }

src/sequence.c

 #include "pico/stdlib.h"
 
 #include "led.h"
+#include "log.h"
 #include "pulse.h"
 #include "ui.h"
 #include "sequence.h"
 
 static const uint32_t channel_times[NUM_CHANNELS] = CH_GPIO_TIMINGS;
 
-static uint32_t ms_per_beat = 0;
+static uint64_t us_per_beat = 0;
+static uint64_t last_t = 0;
+static uint64_t beattimer_start = 0;
+
 static uint32_t beats = MAX_BEATS;
-static uint32_t last_t = 0;
 static uint32_t last_i = 0;
 static uint32_t bank = 0;
-static uint32_t beattimer_start = 0;
+static uint32_t max_banks_currently = 0;
 
 static enum channels sequence[MAX_BEATS] = {0};
 
 void sequence_init(void) {
-    ms_per_beat = 0;
+    us_per_beat = 0;
     beats = MAX_BEATS;
     last_t = to_ms_since_boot(get_absolute_time());
     last_i = 0;
+    max_banks_currently = (beats + (NUM_BTNS - 1)) / NUM_BTNS;
 
     for (uint i = 0; i < MAX_BEATS; i++) {
         sequence[i] = 0;
     }
 }
 
-void sequence_set_bpm(uint32_t new_bpm) {
-    ms_per_beat = 60000 / new_bpm / beats;
-    printf("bpm now %"PRIu32" = %"PRIu32"ms\n", new_bpm, ms_per_beat);
-}
-
-uint32_t sequence_get_bpm(void) {
-    return 60000 / (ms_per_beat * beats);
+uint32_t sequence_get_max_banks(void) {
+    return max_banks_currently;
 }
 
-void sequence_set_ms(uint32_t new_ms) {
-    ms_per_beat = new_ms;
+void sequence_set_bpm(uint32_t new_bpm) {
+    us_per_beat = (60UL * 1000UL * 1000UL) / new_bpm;
+    debug("bpm @ %"PRIu64"us = %"PRIu64"us", us_per_beat, us_per_beat / beats);
 }
 
-uint32_t sequence_get_ms(void) {
-    return ms_per_beat;
+uint32_t sequence_get_bpm(void) {
+    if (us_per_beat == 0) {
+        return 0;
+    }
+    return (60UL * 1000UL * 1000UL) / us_per_beat;
 }
 
 void sequence_set_beats(uint32_t new_beats) {
     beats = (new_beats <= MAX_BEATS) ? new_beats : MAX_BEATS;
+    debug("beats @ %"PRIu64"us = %"PRIu64"us", us_per_beat, us_per_beat / beats);
 
-    uint32_t max_banks_currently = (beats + (NUM_BTNS - 1)) / NUM_BTNS;
-    bank = (bank < max_banks_currently) ? bank : max_banks_currently;
+    max_banks_currently = (beats + (NUM_BTNS - 1)) / NUM_BTNS;
+    bank = (bank < max_banks_currently) ? bank : 0;
 }
 
 uint32_t sequence_get_beats(void) {
 
 void sequence_set_bank(uint32_t new_bank) {
     uint32_t b = (new_bank < MAX_BANKS) ? new_bank : MAX_BANKS;
-
-    uint32_t max_banks_currently = (beats + (NUM_BTNS - 1)) / NUM_BTNS;
-    bank = (b < max_banks_currently) ? b : max_banks_currently;
+    bank = (b < max_banks_currently) ? b : 0;
 }
 
 uint32_t sequence_get_bank(void) {
     return bank;
 }
 
+uint64_t sequence_get_us(void) {
+    return us_per_beat;
+}
+
 static void sequence_set(uint32_t beat, enum channels ch, bool value) {
     if (beat < MAX_BEATS) {
         if (value) {
 
 void sequence_looptime(bool fin) {
     if (!fin) {
-        beattimer_start = to_ms_since_boot(get_absolute_time());
+        beattimer_start = to_us_since_boot(get_absolute_time());
     } else {
-        if (ms_per_beat == 0) {
-            uint32_t now = to_ms_since_boot(get_absolute_time());
-            uint32_t diff = now - beattimer_start;
-            ms_per_beat = diff / beats;
-            printf("looptime: diff=%"PRIu32"ms per_beat=%"PRIu32"ms\n", diff, ms_per_beat);
+        if (us_per_beat == 0) {
+            uint64_t now = to_us_since_boot(get_absolute_time());
+            uint64_t diff = now - beattimer_start;
+            us_per_beat = diff;
+            debug("looptime @ %"PRIu64"us = %"PRIu64"us", us_per_beat, us_per_beat / beats);
         }
     }
 }
 
 void sequence_run(void) {
-    uint32_t now = to_ms_since_boot(get_absolute_time());
+    uint64_t now = to_us_since_boot(get_absolute_time());
+    uint64_t us = us_per_beat / beats;
 
-    if ((ms_per_beat > 0) && (now >= (last_t + ms_per_beat))) {
-        //printf("trigger\n");
+    if ((us > 0) && (now >= (last_t + us))) {
+        //debug("trigger");
 
         uint32_t i = last_i + 1;
         if (i >= beats) i = 0;

src/ui.c

 #include <math.h>
 #include "pico/stdlib.h"
 
+#include "config.h"
 #include "adc.h"
 #include "buttons.h"
 #include "lcd.h"
 #include "led.h"
+#include "log.h"
 #include "pulse.h"
 #include "sequence.h"
 #include "usb.h"
 #include "usb_midi.h"
 #include "ui.h"
 
-#define BAT_FETCH_MS 66
+#define KEEP_IN_RANGE(val, min, len) { \
+    while (val > (len - min)) {        \
+        val -= len;                    \
+    }                                  \
+    while (val < min) {                \
+        val += len;                    \
+    }                                  \
+}
 
 enum ui_settings {
     SETTING_MODE = 0,
 
     // drum machine
     SETTING_BPM,
-    SETTING_BANK,
     SETTING_LENGTH,
+    SETTING_BANK,
+    SETTING_CHANNEL,
 
     // midi
     SETTING_CH_RX,
 static bool allowed_settings[MACHINE_NUM_MODES][SETTING_NUM_MODES] = {
     // MODE_LOOPSTATION
     {
-        true, true,
-        false, false, false,
+        true, // SETTING_MODE
+        true,
+        false, false, false, false,
         false, false,
     },
 
     // MODE_DRUMMACHINE
     {
-        true, false,
-        true, true, true,
+        true, // SETTING_MODE
+        false,
+        true, true, true, true,
         false, false,
     },
 
     // MODE_MIDI
     {
-        true, false,
-        false, false, false,
+        true, // SETTING_MODE
+        false,
+        false, false, false, false,
         true, true,
     },
 };
     char bat[64] = {0};
 
     switch (ui_setting) {
-        case SETTING_BPM: {
-            snprintf(mode, sizeof(mode) - 1, "BPM:");
-            snprintf(val, sizeof(val) - 1, "%"PRIu32, sequence_get_bpm());
-            break;
-        }
-
         case SETTING_MODE: {
-            if ((machine_mode == MODE_LOOPSTATION) && (sequence_get_ms() != 0)) {
-                snprintf(mode, sizeof(mode) - 1, "Mode: %"PRIu32"ms", sequence_get_ms());
+            if ((machine_mode == MODE_LOOPSTATION) && (sequence_get_us() != 0)) {
+                snprintf(mode, sizeof(mode) - 1, "Mode: %"PRIu64"ms", sequence_get_us() / 1000);
             } else {
                 snprintf(mode, sizeof(mode) - 1, "Mode:");
             }
             break;
         }
 
+        case SETTING_SPEED:
+        case SETTING_BPM: {
+            if ((machine_mode == MODE_LOOPSTATION) && (sequence_get_us() != 0)) {
+                snprintf(mode, sizeof(mode) - 1, "BPM: %"PRIu64"ms", sequence_get_us() / 1000);
+            } else {
+                snprintf(mode, sizeof(mode) - 1, "BPM:");
+            }
+            snprintf(val, sizeof(val) - 1, "%"PRIu32, sequence_get_bpm());
+            break;
+        }
+
         case SETTING_LENGTH: {
             snprintf(mode, sizeof(mode) - 1, "Length:");
             snprintf(val, sizeof(val) - 1, "%"PRIu32, sequence_get_beats());
 
         case SETTING_BANK: {
             snprintf(mode, sizeof(mode) - 1, "Bank:");
-            snprintf(val, sizeof(val) - 1, "%"PRIu32, sequence_get_bank());
-            break;
-        }
-
-        case SETTING_SPEED: {
-            snprintf(mode, sizeof(mode) - 1, "Speed:");
-            snprintf(val, sizeof(val) - 1, "%"PRIu32, sequence_get_ms());
+            snprintf(val, sizeof(val) - 1, "%"PRIu32, sequence_get_bank() + 1);
             break;
         }
 
             break;
         }
 
+        case SETTING_CHANNEL: {
+            snprintf(mode, sizeof(mode) - 1, "Channel:");
+            snprintf(val, sizeof(val) - 1, "todo");
+            break;
+        }
+
         default: {
-            printf("%s: invalid setting: %d\n", __func__, ui_setting);
+            debug("invalid setting: %d", ui_setting);
             ui_setting = 0;
             ui_redraw();
             return;
         }
 
         default: {
-            printf("%s: invalid btn: %d\n", __func__, btn);
+            debug("invalid btn: %d", btn);
             break;
         }
     }
         }
 
         default: {
-            printf("%s: invalid btn: %d\n", __func__, btn);
+            debug("invalid btn: %d", btn);
             break;
         }
     }
                 }
 
                 default: {
-                    printf("%s: invalid mode: %d\n", __func__, machine_mode);
+                    debug("invalid mode: %d", machine_mode);
                     machine_mode = 0;
                     ui_buttons(btn, val);
                     break;
     }
 
     switch (ui_setting) {
-        case SETTING_BPM: {
-            sequence_set_bpm(sequence_get_bpm() + val);
-            break;
-        }
-
         case SETTING_MODE: {
             int32_t tmp = machine_mode + val;
-
-            while (tmp < 0) {
-                tmp += MACHINE_NUM_MODES;
-            }
-            while (tmp >= MACHINE_NUM_MODES) {
-                tmp -= MACHINE_NUM_MODES;
-            }
+            KEEP_IN_RANGE(tmp, 0, MACHINE_NUM_MODES);
 
             // midi only when connected to pc
             if ((tmp == MODE_MIDI) && !usb_is_connected()) {
             enum machine_modes prev_mode = machine_mode;
             machine_mode = tmp;
 
-            printf("mode add %"PRIi32" now %d\n", val, machine_mode);
-
             if (prev_mode != machine_mode) {
                 // reset sequence
                 sequence_init();
                     led_set(NUM_CHANNELS + 4, true);
                 } else if (machine_mode == MODE_DRUMMACHINE) {
                     sequence_set_beats(LED_COUNT);
+                    sequence_set_bpm(120);
                 }
             }
             break;
         }
 
-        case SETTING_LENGTH: {
-            sequence_set_beats(sequence_get_beats() + val);
+        case SETTING_SPEED:
+        case SETTING_BPM: {
+            int32_t tmp = sequence_get_bpm() + val;
+            KEEP_IN_RANGE(tmp, 1, MAX_BPM);
+            sequence_set_bpm(tmp);
             break;
         }
 
-        case SETTING_BANK: {
-            sequence_set_bank(sequence_get_bank() + val);
+        case SETTING_LENGTH: {
+            int32_t tmp = sequence_get_beats() + val;
+            KEEP_IN_RANGE(tmp, 1, MAX_BEATS);
+            sequence_set_beats(tmp);
             break;
         }
 
-        case SETTING_SPEED: {
-            sequence_set_ms(sequence_get_ms() + val);
+        case SETTING_BANK: {
+            int32_t tmp = sequence_get_bank() + val;
+            KEEP_IN_RANGE(tmp, 0, (int32_t)sequence_get_max_banks());
+            sequence_set_bank(tmp);
             break;
         }
 
         case SETTING_CH_RX: {
-            midi_rx = (uint8_t)(midi_rx + val) % MIDI_MAX_CH;
+            int32_t tmp = midi_rx + val;
+            KEEP_IN_RANGE(tmp, 0, MIDI_MAX_CH);
+            midi_rx = tmp;
             break;
         }
 
         case SETTING_CH_TX: {
-            midi_tx = (uint8_t)(midi_tx + val) % MIDI_MAX_CH;
+            int32_t tmp = midi_tx + val;
+            KEEP_IN_RANGE(tmp, 0, MIDI_MAX_CH);
+            midi_tx = tmp;
+            break;
+        }
+
+        case SETTING_CHANNEL: {
+            // TODO
             break;
         }
 
         default: {
-            printf("%s: invalid setting: %d\n", __func__, ui_setting);
+            debug("invalid setting: %d", ui_setting);
             ui_setting = 0;
             ui_encoder(val);
             return;