machine now basically working

CMakeLists.txt

     -Wextra
     -Werror
     -Wshadow
+    -O3
 )
 
 # suppress some warnings for borked 3rd party files in Pico SDK

README.md

 # Drumkit
 
+This is a simple drum machine / loopstation.
+It's made for three hand-wound solenoids mounted to a tambourine.
+It is controlled by a Raspberry Pi Pico.
+
 ## Quick Start
 
 Initialize your local repo and prepare the build:

include/sequence.h

 
 #define CH_GPIO_TIMINGS { 42, 42, 42 } // in milliseconds
 
-#define MAX_BEATS 32
+#define MAX_BEATS 128
 #define MAX_BANKS (MAX_BEATS / NUM_BTNS)
 
 void sequence_init(void);
 void sequence_set_bpm(uint32_t new_bpm);
 uint32_t sequence_get_bpm(void);
 
+uint32_t sequence_get_ms(void);
+
 void sequence_set_beats(uint32_t new_beats);
 uint32_t sequence_get_beats(void);
 
 void sequence_handle_button_loopstation(enum buttons btn, bool rec);
 void sequence_handle_button_drummachine(enum buttons btn);
 
+void sequence_looptime(bool fin);
+
 void sequence_run(void);
 
 #endif // __SEQUENCE_H__

include/ui.h

 #include <stdint.h>
 
 enum ui_modes {
-    UI_BPM = 0,
-    UI_MODE,
+    UI_MODE = 0,
+    UI_BPM,
     UI_BANK,
     UI_LENGTH,
 
 void ui_encoder(int32_t val);
 void ui_run(void);
 
+enum machine_modes ui_get_machinemode(void);
+
 #endif // __UI_H__

src/lcd.c

 
     disp.external_vcc = false;
     ssd1306_init(&disp, LCD_WIDTH, LCD_HEIGHT, LCD_ADDR, LCD_I2C);
+
     ssd1306_clear(&disp);
+    ssd1306_draw_string(&disp, 0, 5, 5, "LARS");
+    ssd1306_show(&disp);
 }
 
 void lcd_draw(const char *mode, const char *val, const char *bat) {

src/main.c

     encoder_init();
     lcd_init();
     led_init();
+
+    // show splash for a bit
+    sleep_ms(500);
+
     sequence_init();
     ui_init();
     printf("init done\n");

src/sequence.c

  */
 
 #include <stdio.h>
+#include <inttypes.h>
 #include "pico/stdlib.h"
 
 #include "led.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 = 500;
-static uint32_t beats = 16;
+static uint32_t ms_per_beat = 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 enum channels sequence[MAX_BEATS] = {0};
 
 void sequence_init(void) {
+    ms_per_beat = 0;
+    beats = MAX_BEATS;
     last_t = to_ms_since_boot(get_absolute_time());
     last_i = 0;
 
 }
 
 void sequence_set_bpm(uint32_t new_bpm) {
-    ms_per_beat = 60000 / 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;
+    return 60000 / (ms_per_beat * beats);
+}
+
+uint32_t sequence_get_ms(void) {
+    return ms_per_beat;
 }
 
 void sequence_set_beats(uint32_t new_beats) {
     }
 
     if (rec) {
-        uint32_t beat = 42; // TODO!!
-
         switch (btn) {
             case BTN_A: {
-                sequence_set(beat, CH_KICK, true);
+                sequence_set(last_i, CH_KICK, true);
                 break;
             }
 
             case BTN_B: {
-                sequence_set(beat, CH_SNARE, true);
+                sequence_set(last_i, CH_SNARE, true);
                 break;
             }
 
             case BTN_C: {
-                sequence_set(beat, CH_HIHAT, true);
+                sequence_set(last_i, CH_HIHAT, true);
                 break;
             }
 
     }
 }
 
+void sequence_looptime(bool fin) {
+    if (!fin) {
+        beattimer_start = to_ms_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);
+        }
+    }
+}
+
 void sequence_run(void) {
-    /*
     uint32_t now = to_ms_since_boot(get_absolute_time());
 
-    if ((last_t + ms_per_beat) >= now) {
+    if ((ms_per_beat > 0) && (now >= (last_t + ms_per_beat))) {
+        //printf("trigger\n");
+
         uint32_t i = last_i + 1;
         if (i >= beats) i = 0;
 
-        led_set(last_i, false);
-        led_set(i, true);
+        if (ui_get_machinemode() == MODE_DRUMMACHINE) {
+            led_set(last_i, false);
+            led_set(i, true);
+        }
 
         for (uint ch = 0; ch < NUM_CHANNELS; ch++) {
             if (sequence[i] & (1 << ch)) {
-                pulse_trigger_out(i, channel_times[ch]);
+                pulse_trigger_out(ch, channel_times[ch]);
+                if (ui_get_machinemode() == MODE_LOOPSTATION) {
+                    pulse_trigger_led(ch, channel_times[ch]);
+                }
             }
         }
 
         last_t = now;
         last_i = i;
     }
-    */
 }

src/ui.c

 static enum machine_modes machine_mode = 0;
 static uint32_t last_redraw = 0;
 
+enum machine_modes ui_get_machinemode(void) {
+    return machine_mode;
+}
+
 static void ui_redraw(void) {
     char mode[64] = {0};
     char val[64] = {0};
         }
 
         case UI_MODE: {
-            snprintf(mode, sizeof(mode) - 1, "Mode:");
+            if ((machine_mode == MODE_LOOPSTATION) && (sequence_get_ms() != 0)) {
+                snprintf(mode, sizeof(mode) - 1, "Mode: %"PRIu32"ms", sequence_get_ms());
+            }else {
+                snprintf(mode, sizeof(mode) - 1, "Mode:");
+            }
             switch (machine_mode) {
                 case MODE_LOOPSTATION: {
                     snprintf(val, sizeof(val) - 1, "Loop");
                 }
 
                 default: {
-                    printf("%s: invalid mode: %d\n", __func__, machine_mode);
+                    printf("%s: invalid machine mode: %d\n", __func__, machine_mode);
                     machine_mode = 0;
                     ui_redraw();
                     return;
 
         case BTN_REC: {
             rec_held_down = val;
+            sequence_looptime(!val);
             break;
         }
 
         case BTN_CLICK: {
             if (val) {
                 ui_mode = (ui_mode + 1) % UI_NUM_MODES;
+
+                // allow other ui mdoes only in drumkit mode
+                if (machine_mode == MODE_LOOPSTATION)
+                {
+                    ui_mode = 0;
+                }
+
                 ui_redraw();
             }
             break;
         }
 
         case UI_MODE: {
-            machine_mode = (machine_mode + val) % MACHINE_NUM_MODES;
+            int32_t tmp = machine_mode + val;
+            while (tmp < 0) {
+                tmp += MACHINE_NUM_MODES;
+            }
+            while (tmp >= MACHINE_NUM_MODES) {
+                tmp -= MACHINE_NUM_MODES;
+            }
+            machine_mode = tmp;
+
+            printf("mode add %"PRIi32" now %d\n", val, machine_mode);
+
+            // reset sequence
+            sequence_init();
             break;
         }