work on firmware

CMakeLists.txt

 add_executable(drumkit)
 
 target_sources(drumkit PUBLIC
+    src/adc.c
     src/buttons.c
     src/encoder.c
     src/lcd.c

README.md

 
 The code in `src/encoder.c` is derived from [mathertel/RotaryEncoder](https://github.com/mathertel/RotaryEncoder) and therefore licensed as BSD 3-clause.
 
-The PCB design uses `Mini360_step_down_converter` library from [rayvburn/KiCad](https://github.com/rayvburn/KiCad/tree/master/Mini360_step_down_converter).
+~~The PCB design uses `Mini360_step_down_converter` library from [rayvburn/KiCad](https://github.com/rayvburn/KiCad/tree/master/Mini360_step_down_converter).~~
 
     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/adc.h

+/*
+ * adc.h
+ *
+ * Copyright (c) 2022 - 2023 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
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * See <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __ADC_H__
+#define __ADC_H__
+
+void bat_init(void);
+float bat_get(void);
+
+#endif // __ADC_H__

include/buttons.h

 void buttons_run(void);
 
 #endif // __BUTTONS_H__
-

include/encoder.h

 void encoder_run(void);
 
 #endif // __ENCODER_H__
-

include/lcd.h

 #define LCD_HEIGHT 64
 
 void lcd_init(void);
+void lcd_draw(const char *mode, const char *val, const char *bat);
 
 #endif // __LCD_H__

include/sequence.h

 
 #define CH_GPIO_TIMINGS { 42, 42, 42 } // in milliseconds
 
+#define MAX_BEATS 32
+#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);
+
 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);
+
 void sequence_handle_button_loopstation(enum buttons btn, bool rec);
 void sequence_handle_button_drummachine(enum buttons btn);
+
 void sequence_run(void);
 
 #endif // __SEQUENCE_H__

include/ui.h

 
 void ui_init(void);
 void ui_encoder(int32_t val);
+void ui_run(void);
 
 #endif // __UI_H__

src/adc.c

+/*
+ * adc.c
+ *
+ * Copyright (c) 2024 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
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * See <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdio.h>
+#include "pico/stdlib.h"
+#include "hardware/adc.h"
+
+#include "adc.h"
+
+#define ADC_NUM 2
+#define ADC_PIN (26 + ADC_NUM)
+
+#define ADC_VREF 3.3
+#define ADC_RANGE (1 << 12)
+#define ADC_CONVERT (ADC_VREF / (ADC_RANGE - 1))
+
+#define BAT_R1 10000.0f
+#define BAT_R2 18000.0f
+
+void bat_init(void) {
+    adc_init();
+    adc_gpio_init( ADC_PIN);
+    adc_select_input( ADC_NUM);
+}
+
+float bat_get(void) {
+    float v_adc = adc_read() * ADC_CONVERT;
+
+    // Vadc = Vbat * R2 / (R1 + R2)
+    float v_bat = v_adc / (BAT_R2 / (BAT_R1 + BAT_R2));
+    return v_bat;
+}

src/encoder.c

 #define FOUR0 2 // 4 steps, Latch at position 0 (reverse wirings)
 #define TWO03 3 // 2 steps, Latch at position 0 and 3
 
-#define ENCODER_MODE TWO03
+#define ENCODER_MODE FOUR3
 
 static const uint gpio_num[2] = {
     17, 18
             if (thisState == LATCH3) {
                 // The hardware has 4 steps with a latch on the input state 3
                 positionExt = position >> 2;
+                positionExt = -positionExt;
             }
             break;
 
             if (thisState == LATCH0) {
                 // The hardware has 4 steps with a latch on the input state 0
                 positionExt = position >> 2;
+                positionExt = -positionExt;
             }
             break;
 
             if ((thisState == LATCH0) || (thisState == LATCH3)) {
                 // The hardware has 2 steps with a latch on the input state 0 and 3
                 positionExt = position >> 1;
+                positionExt = -positionExt;
             }
             break;
         }

src/lcd.c

 
     disp.external_vcc = false;
     ssd1306_init(&disp, LCD_WIDTH, LCD_HEIGHT, LCD_ADDR, LCD_I2C);
+    ssd1306_clear(&disp);
+}
+
+void lcd_draw(const char *mode, const char *val, const char *bat) {
+    ssd1306_clear(&disp);
+    ssd1306_draw_string(&disp, 0, 0, 2, mode);
+    ssd1306_draw_string(&disp, 0, 20, 4, val);
+    ssd1306_draw_string(&disp, 0, LCD_HEIGHT - 1 - 10, 1, bat);
+
+    ssd1306_show(&disp);
 }

src/main.c

 #include "pico/stdlib.h"
 #include "hardware/watchdog.h"
 
+#include "adc.h"
 #include "buttons.h"
 #include "encoder.h"
 #include "lcd.h"
 int main(void) {
     watchdog_enable(WATCHDOG_PERIOD_MS, 1);
     stdio_init_all();
+    bat_init();
     buttons_init();
     encoder_init();
     lcd_init();
         encoder_run();
         sequence_run();
         pulse_run();
+        ui_run();
 
         int32_t epos = encoder_pos();
         if (epos != last_epos) {

src/sequence.c

 #include "pulse.h"
 #include "sequence.h"
 
-#define MAX_BEATS 32
 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 last_t = 0;
 static uint32_t last_i = 0;
+static uint32_t bank = 0;
 
 static enum channels sequence[MAX_BEATS] = {0};
 
     ms_per_beat = 60000 / new_bpm;
 }
 
+uint32_t sequence_get_bpm(void) {
+    return 60000 / ms_per_beat;
+}
+
 void sequence_set_beats(uint32_t new_beats) {
     beats = (new_beats <= MAX_BEATS) ? new_beats : MAX_BEATS;
+
+    uint32_t max_banks_currently = (beats + (NUM_BTNS - 1)) / NUM_BTNS;
+    bank = (bank < max_banks_currently) ? bank : max_banks_currently;
+}
+
+uint32_t sequence_get_beats(void) {
+    return beats;
+}
+
+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;
+}
+
+uint32_t sequence_get_bank(void) {
+    return bank;
 }
 
 static void sequence_set(uint32_t beat, enum channels ch, bool value) {
 
     switch (btn) {
         case BTN_A: {
+            // TODO kick is wrong here
             bool val = !sequence_get(beat, CH_KICK);
             sequence_set(beat, CH_KICK, val);
             break;
         }
 
         case BTN_B: {
+            // TODO snare is wrong here
             bool val = !sequence_get(beat, CH_SNARE);
             sequence_set(beat, CH_SNARE, val);
             break;
         }
 
         case BTN_C: {
+            // TODO hihat is wrong here
             bool val = !sequence_get(beat, CH_HIHAT);
             sequence_set(beat, CH_HIHAT, val);
             break;

src/ui.c

  */
 
 #include <stdio.h>
+#include <inttypes.h>
 #include "pico/stdlib.h"
 
+#include "adc.h"
 #include "buttons.h"
+#include "lcd.h"
 #include "sequence.h"
 #include "ui.h"
 
+#define REDRAW_MS 2000
+
 static bool rec_held_down = false;
 static enum ui_modes ui_mode = 0;
 static enum machine_modes machine_mode = 0;
+static uint32_t last_redraw = 0;
 
 static void ui_redraw(void) {
+    char mode[64] = {0};
+    char val[64] = {0};
+    char bat[64] = {0};
+
     switch (ui_mode) {
         case UI_BPM: {
-            // TODO
+            snprintf(mode, sizeof(mode) - 1, "BPM:");
+            snprintf(val, sizeof(val) - 1, "%"PRIu32, sequence_get_bpm());
             break;
         }
 
         case UI_MODE: {
-            // TODO
+            snprintf(mode, sizeof(mode) - 1, "Mode:");
+            switch (machine_mode) {
+                case MODE_LOOPSTATION: {
+                    snprintf(val, sizeof(val) - 1, "Loop");
+                    break;
+                }
+
+                case MODE_DRUMMACHINE: {
+                    snprintf(val, sizeof(val) - 1, "Drum");
+                    break;
+                }
+
+                default: {
+                    printf("%s: invalid mode: %d\n", __func__, machine_mode);
+                    machine_mode = 0;
+                    ui_redraw();
+                    return;
+                }
+            }
             break;
         }
 
         case UI_LENGTH: {
-            // TODO
+            snprintf(mode, sizeof(mode) - 1, "Length:");
+            snprintf(val, sizeof(val) - 1, "%"PRIu32, sequence_get_beats());
             break;
         }
 
         case UI_BANK: {
-            // TODO
+            snprintf(mode, sizeof(mode) - 1, "Bank:");
+            snprintf(val, sizeof(val) - 1, "%"PRIu32, sequence_get_bank());
             break;
         }
 
             printf("%s: invalid mode: %d\n", __func__, ui_mode);
             ui_mode = 0;
             ui_redraw();
-            break;
+            return;
         }
     }
+
+    snprintf(bat, sizeof(bat) - 1, "Bat: %.2fV", bat_get());
+    lcd_draw(mode, val, bat);
 }
 
 static void ui_buttons_loopstation(enum buttons btn, bool val) {
 static void ui_buttons(enum buttons btn, bool val) {
     switch (btn) {
         case BTN_CLICK: {
-            ui_mode = (ui_mode + 1) % UI_NUM_MODES;
-            ui_redraw();
+            if (val) {
+                ui_mode = (ui_mode + 1) % UI_NUM_MODES;
+                ui_redraw();
+            }
             break;
         }
 
 
     switch (ui_mode) {
         case UI_BPM: {
-            // TODO
+            sequence_set_bpm(sequence_get_bpm() + val);
             break;
         }
 
         case UI_MODE: {
-            // TODO
+            machine_mode = (machine_mode + val) % MACHINE_NUM_MODES;
             break;
         }
 
         case UI_LENGTH: {
-            // TODO
+            sequence_set_beats(sequence_get_beats() + val);
             break;
         }
 
         case UI_BANK: {
-            // TODO
+            sequence_set_bank(sequence_get_bank() + val);
             break;
         }
 
             printf("%s: invalid mode: %d\n", __func__, ui_mode);
             ui_mode = 0;
             ui_encoder(val);
-            break;
+            return;
         }
     }
+
+    ui_redraw();
 }
 
 void ui_init(void) {
     buttons_callback(ui_buttons);
     ui_redraw();
 }
+
+void ui_run(void) {
+    uint32_t now = to_ms_since_boot(get_absolute_time());
+    if (now >= (last_redraw + REDRAW_MS)) {
+        ui_redraw();
+        last_redraw = now;
+    }
+}