wip lars v2 fw

include/buttons.h

     BTN_A = 0,
     BTN_B,
     BTN_C,
+
+    // only on LARS V2
+    BTN_D,
+    BTN_E,
+    BTN_F,
+    BTN_G,
+    BTN_H,
+
     BTN_REC,
     BTN_CLICK,
     NUM_BTNS // count

include/led.h

 #include <stdint.h>
 #include <stdbool.h>
 
+#if 0
 #define LED_COUNT 4
+#else
+#define LED_COUNT 8
+#endif
 
 void led_init(void);
 void led_set(uint32_t i, bool v);

include/main.h

 #ifndef __MAIN_H__
 #define __MAIN_H__
 
+enum hw_versions {
+    HW_UNKNOWN = 0,
+    HW_PROTOTYPE,
+    HW_V2,
+};
 
+extern enum hw_versions hw_type;
 
 #endif // __MAIN_H__

src/buttons.c

 #include <stdio.h>
 #include "pico/stdlib.h"
 
+#include "main.h"
 #include "buttons.h"
 
 #define DEBOUNCE_DELAY_MS 50
 
-static const uint gpio_num[NUM_BTNS] = {
+static const uint gpio_num_proto[NUM_BTNS] = {
     8, // BTN_A
     9, // BTN_B
     12, // BTN_C
+
+    // not existing on prototype
+    0xFF, // BTN_D
+    0xFF, // BTN_E
+    0xFF, // BTN_F
+    0xFF, // BTN_G
+    0xFF, // BTN_H
+
     14, // BTN_REC
     16, // BTN_CLICK
 };
 
+static const uint gpio_num_v2[NUM_BTNS] = {
+    1, // BTN_A / COL 0
+    4, // BTN_B / COL 1
+    5, // BTN_C / COL 2
+    0, // BTN_D / ROW 0
+    2, // BTN_E / ROW 1
+    3, // BTN_F / ROW 2
+    0xFF, // BTN_G
+    0xFF, // BTN_H
+    0xFF, // BTN_REC
+    20, // BTN_CLICK
+};
+
 struct button_state {
     uint32_t last_time;
     bool current_state, last_state;
 
 void buttons_init(void) {
     for (uint i = 0; i < NUM_BTNS; i++) {
-        gpio_init(gpio_num[i]);
-        gpio_set_dir(gpio_num[i], GPIO_IN);
-        gpio_pull_up(gpio_num[i]);
+        uint n = 0xFF;
+        if (hw_type == HW_PROTOTYPE) {
+            n = gpio_num_proto[i];
+        } else if (hw_type == HW_V2) {
+            n = gpio_num_v2[i];
+        }
+
+        if (n >= 0xFF) {
+            continue;
+        }
+
+        gpio_init(n);
+        gpio_set_dir(n, GPIO_IN);
+        gpio_pull_up(n);
 
         buttons[i].last_time = 0;
         buttons[i].current_state = false;
     callback = fp;
 }
 
-void buttons_run(void) {
-    for (uint i = 0; i < NUM_BTNS; i++) {
-        bool state = !gpio_get(gpio_num[i]);
-        uint32_t now = to_ms_since_boot(get_absolute_time());
+static void button_run_single(bool state, uint i) {
+    uint32_t now = to_ms_since_boot(get_absolute_time());
 
-        if (state != buttons[i].last_state) {
-            buttons[i].last_time = now;
-        }
+    if (state != buttons[i].last_state) {
+        buttons[i].last_time = now;
+    }
 
-        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");
+    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");
 
-                buttons[i].current_state = state;
-                if (callback) {
-                    callback(i, state);
-                }
+            buttons[i].current_state = state;
+            if (callback) {
+                callback(i, state);
             }
         }
+    }
+
+    buttons[i].last_state = state;
+}
+
+static void buttons_run_proto(void) {
+    for (uint i = 0; i < NUM_BTNS; i++) {
+        if (gpio_num_proto[i] >= 0xFF) {
+            continue;
+        }
+
+        bool state = !gpio_get(gpio_num_proto[i]);
+        button_run_single(state, i);
+    }
+}
+
+void buttons_run(void) {
+    if (hw_type == HW_PROTOTYPE) {
+        buttons_run_proto();
+    } else if (hw_type == HW_V2) {
+        // TODO read matrix
 
-        buttons[i].last_state = state;
+        button_run_single(!gpio_get(gpio_num_v2[BTN_CLICK]), BTN_CLICK);
     }
 }

src/encoder.c

 #include <stdio.h>
 #include "pico/stdlib.h"
 
+#include "main.h"
 #include "encoder.h"
 
 #define LATCH0 0
 
 #define ENCODER_MODE FOUR3
 
-static const uint gpio_num[2] = {
+static const uint gpio_num_proto[2] = {
     17, 18
 };
 
+static const uint gpio_num_v2[2] = {
+    19, 18
+};
+
 static const int8_t KNOBDIR[] = {
     0, -1, 1, 0,
     1, 0, 0, -1,
 
 void encoder_init(void) {
     for (uint i = 0; i < 2; i++) {
-        gpio_init(gpio_num[i]);
-        gpio_set_dir(gpio_num[i], GPIO_IN);
-        gpio_pull_up(gpio_num[i]);
+        if (hw_type == HW_PROTOTYPE) {
+            gpio_init(gpio_num_proto[i]);
+            gpio_set_dir(gpio_num_proto[i], GPIO_IN);
+            gpio_pull_up(gpio_num_proto[i]);
+        } else if (hw_type == HW_V2) {
+            gpio_init(gpio_num_v2[i]);
+            gpio_set_dir(gpio_num_v2[i], GPIO_IN);
+            gpio_pull_up(gpio_num_v2[i]);
+        }
+    }
+
+    if (hw_type == HW_PROTOTYPE) {
+        oldState = gpio_get(gpio_num_proto[0]) | (gpio_get(gpio_num_proto[1]) << 1);
+    } else if (hw_type == HW_V2) {
+        oldState = gpio_get(gpio_num_v2[0]) | (gpio_get(gpio_num_v2[1]) << 1);
     }
 
-    oldState = gpio_get(gpio_num[0]) | (gpio_get(gpio_num[1]) << 1);
     position = 0;
     positionExt = 0;
     positionExtPrev = 0;
 }
 
 void encoder_run(void) {
-    int8_t thisState = gpio_get(gpio_num[0]) | (gpio_get(gpio_num[1]) << 1);
+    int8_t thisState = 0;
+    if (hw_type == HW_PROTOTYPE) {
+        thisState = gpio_get(gpio_num_proto[0]) | (gpio_get(gpio_num_proto[1]) << 1);
+    } else if (hw_type == HW_V2) {
+        thisState = gpio_get(gpio_num_v2[0]) | (gpio_get(gpio_num_v2[1]) << 1);
+    }
 
     if (oldState != thisState) {
         position += KNOBDIR[thisState | (oldState << 2)];

src/lcd.c

 
 #include "ssd1306.h"
 #include "logo.h"
+#include "main.h"
 #include "lcd.h"
 
-#define LCD_I2C i2c0
-static const uint gpio_num[2] = { 0, 1 };
+static i2c_inst_t *gpio_i2c_proto = i2c0;
+static const uint gpio_num_proto[2] = { 0, 1 };
+
+static i2c_inst_t *gpio_i2c_v2 = i2c0;
+static const uint gpio_num_v2[2] = { 16, 17 };
+
 #define LCD_ADDR 0x3C
 
 static ssd1306_t disp;
 
 void lcd_init(void) {
-    i2c_init(LCD_I2C, 1000 * 1000);
-    for (uint i = 0; i < sizeof(gpio_num) / sizeof(gpio_num[0]); i++) {
-        gpio_set_function(gpio_num[i], GPIO_FUNC_I2C);
-        gpio_pull_up(gpio_num[i]);
-    }
+    if (hw_type == HW_PROTOTYPE) {
+        i2c_init(gpio_i2c_proto, 1000 * 1000);
+        for (uint i = 0; i < sizeof(gpio_num_proto) / sizeof(gpio_num_proto[0]); i++) {
+            gpio_set_function(gpio_num_proto[i], GPIO_FUNC_I2C);
+            gpio_pull_up(gpio_num_proto[i]);
+        }
 
-    disp.external_vcc = false;
-    ssd1306_init(&disp, LCD_WIDTH, LCD_HEIGHT, LCD_ADDR, LCD_I2C);
+        disp.external_vcc = false;
+        ssd1306_init(&disp, LCD_WIDTH, LCD_HEIGHT, LCD_ADDR, gpio_i2c_proto);
+    } else if (hw_type == HW_V2) {
+        i2c_init(gpio_i2c_v2, 1000 * 1000);
+        for (uint i = 0; i < sizeof(gpio_num_v2) / sizeof(gpio_num_v2[0]); i++) {
+            gpio_set_function(gpio_num_v2[i], GPIO_FUNC_I2C);
+            gpio_pull_up(gpio_num_v2[i]);
+        }
+
+        disp.external_vcc = false;
+        ssd1306_init(&disp, LCD_WIDTH, LCD_HEIGHT, LCD_ADDR, gpio_i2c_v2);
+    }
 
     ssd1306_clear(&disp);
     for (uint y = 0; y < LOGO_HEIGHT; y++) {
         for (uint x = 0; x < LOGO_WIDTH; x++) {
-            uint pos = y * LOGO_WIDTH + x;
-            if (logo_data[pos / 8] & (1 << (pos % 8))) {
+            const uint pos = y * LOGO_WIDTH + x;
+            const uint bit = 7 - (pos % 8);
+            if (logo_data[pos / 8] & (1 << bit)) {
                 ssd1306_draw_pixel(&disp, x, y);
             }
         }

src/led.c

 #include "sequence.h"
 #include "led.h"
 
+#if 0
 static const uint led_gpio_num[LED_COUNT] = {
     10, 11, 13, 15,
 };
+#else
+static const uint led_gpio_num[LED_COUNT] = {
+    6, 7, 8, 9, 10, 11, 12, 13,
+};
+#endif
 
 static const uint ch_gpio_num[NUM_CHANNELS] = {
     22, 26, 27,

src/main.c

 #include "main.h"
 
 #define WATCHDOG_PERIOD_MS 100
+#define LOGO_INIT_MS 1500
+
+static const uint gpio_hw_detect = 21;
+enum hw_versions hw_type = HW_UNKNOWN;
 
 static void reset_to_bootloader(void) {
 #ifdef PICO_DEFAULT_LED_PIN
 }
 
 int main(void) {
-    //watchdog_enable(WATCHDOG_PERIOD_MS, 1);
     stdio_init_all();
+
+    gpio_init(gpio_hw_detect);
+    gpio_set_dir(gpio_hw_detect, GPIO_IN);
+    gpio_pull_up(gpio_hw_detect);
+    if (gpio_get(gpio_hw_detect)) {
+        hw_type = HW_PROTOTYPE;
+    } else {
+        hw_type = HW_V2;
+    }
+
     bat_init();
     buttons_init();
     encoder_init();
     lcd_init();
     led_init();
 
-    // show splash for a bit
-    sleep_ms(500);
+    // show splash for a bit and animate LEDs
+    for (uint i = 0; i < LED_COUNT; i++) {
+        led_set(i, true);
+        sleep_ms(LOGO_INIT_MS / LED_COUNT);
+    }
+
+    // turn off LEDs at end of init
+    for (uint i = 0; i < LED_COUNT; i++) {
+        led_set(i, false);
+    }
 
     sequence_init();
     ui_init();
+
     printf("init done\n");
+    watchdog_enable(WATCHDOG_PERIOD_MS, 1);
 
     int32_t last_epos = 0;
 

src/ui.c

     }
 }
 
+
+#include "pulse.h"
+
+
 static void ui_buttons(enum buttons btn, bool val) {
     switch (btn) {
         case BTN_CLICK: {
             if (val) {
+
+
+
+                pulse_trigger_out(0, 42);
+                pulse_trigger_led(0, 42);
+
+
+
                 ui_mode = (ui_mode + 1) % UI_NUM_MODES;
 
                 // allow other ui mdoes only in drumkit mode