print bat percent

include/adc.h

 
 void bat_init(void);
 float bat_get(void);
+float bat_to_percent(float voltage);
 
 #endif // __ADC_H__

include/lcd.h

 #ifndef __LCD_H__
 #define __LCD_H__
 
+#include <stdint.h>
+
 #define LCD_WIDTH 128
 #define LCD_HEIGHT 64
 
 void lcd_init(void);
 void lcd_draw(const char *mode, const char *val, const char *bat);
 void lcd_draw_bye(void);
+void lcd_draw_bitmap(uint8_t *data, int width, int height, int x_off, int y_off);
 
 void lcd_debug_buttons(void);
 

src/adc.c

  */
 
 #include <stdio.h>
+#include <math.h>
 #include "pico/stdlib.h"
 #include "hardware/adc.h"
 
 #include "adc.h"
 
+#define LIPO_USE_PERCENTAGE_CURVE
+
 #define ADC_NUM 2
 #define ADC_PIN (26 + ADC_NUM)
 
 #define BAT_R1 10000.0f
 #define BAT_R2 18000.0f
 
-#define FILTER_OLD 0.75f
+#define FILTER_OLD 0.95f
 #define FILTER_NEW (1.0f - FILTER_OLD)
 
+#ifndef LIPO_USE_PERCENTAGE_CURVE
+static const float full_battery = 4.1f;
+static const float empty_battery = 3.2f;
+#endif // ! LIPO_USE_PERCENTAGE_CURVE
+
 static float filtered = 0.0f;
 
 static float bat_read(void) {
     filtered = (filtered * FILTER_OLD) + (bat_read() * FILTER_NEW);
     return filtered;
 }
+
+float bat_to_percent(float voltage) {
+    float percentage = 0.0f;
+
+#ifdef LIPO_USE_PERCENTAGE_CURVE
+    /*
+     * Try to linearize the LiPo discharge curve.
+     * https://electronics.stackexchange.com/a/551667
+     *
+     * Seems to work relatively well, although
+     * "stopping" at 3.5V feels a bit high to me.
+     */
+    percentage = 123.0f - (123.0f / powf(1.0f + powf(voltage / 3.7f, 80.0f), 0.165f));
+#else // LIPO_USE_PERCENTAGE_CURVE
+    percentage = 100.0f * ((voltage - empty_battery) / (full_battery - empty_battery));
+#endif // LIPO_USE_PERCENTAGE_CURVE
+
+    return MIN(MAX(percentage, 0.0f), 100.0f);
+}

src/lcd.c

  * See <http://www.gnu.org/licenses/>.
  */
 
-#include <stdio.h>
-#include <stdint.h>
-#include <string.h>
-#include "pico/stdlib.h"
 #include "hardware/i2c.h"
 
 #include "ssd1306.h"
 
 #include "buttons.h"
-#include "logo.h"
 #include "main.h"
 #include "lcd.h"
 
 
 #define LCD_ADDR 0x3C
 
-static ssd1306_t disp;
+static ssd1306_t disp = {0};
 static bool buttons[NUM_BTNS] = {0};
 static bool changed = true;
 
 
 void lcd_debug_buttons(void) {
     buttons_callback(lcd_debug_buttons_callback);
+
     while (1) {
         buttons_run();
         handle_serial_input();
+
         if (changed) {
             changed = false;
+
             ssd1306_clear(&disp);
             ssd1306_draw_string(&disp, 0, 0, 3, "Buttons");
+
             for (uint i = 0; i < NUM_BTNS; i++) {
+                if ((hw_type == HW_PROTOTYPE) && (i >= BTN_D) && (i <= BTN_H)) {
+                    continue;
+                }
+
                 ssd1306_draw_char(&disp,
-                                    i * 12, LCD_HEIGHT - 20 - 16 - 1,
-                                    2, '0' + i);
+                                  i * 12, LCD_HEIGHT - 20 - 16 - 1,
+                                  2, '0' + i);
+
                 if (buttons[i]) {
                     ssd1306_draw_square(&disp,
                                         i * 12, LCD_HEIGHT - 20 - 1,
                                         10, 20);
                 } else {
                     ssd1306_draw_empty_square(&disp,
-                                                i * 12, LCD_HEIGHT - 20 - 1,
-                                                10, 20);
+                                              i * 12, LCD_HEIGHT - 20 - 1,
+                                              10, 20);
                 }
             }
+
             ssd1306_show(&disp);
         }
     }
 }
 
+void lcd_draw_bitmap(uint8_t *data, int width, int height, int x_off, int y_off) {
+    ssd1306_clear(&disp);
+
+    for (int y = 0; y < height; y++) {
+        for (int x = 0; x < width; x++) {
+            const uint pos = y * width + x;
+            const uint bit = 7 - (pos % 8);
+            if (data[pos / 8] & (1 << bit)) {
+                ssd1306_draw_pixel(&disp, x + x_off, y + y_off);
+            }
+        }
+    }
+
+    ssd1306_show(&disp);
+}
+
 void lcd_init(void) {
     if (hw_type == HW_PROTOTYPE) {
-        i2c_init(gpio_i2c_proto, 1000 * 1000);
+        i2c_init(gpio_i2c_proto, 2UL * 1000UL * 1000UL);
+
         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, gpio_i2c_proto);
+        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);
+        i2c_init(gpio_i2c_v2, 2UL * 1000UL * 1000UL);
+
         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_init(&disp,
+                     LCD_WIDTH, LCD_HEIGHT,
+                     LCD_ADDR, gpio_i2c_v2);
     }
-
-    // show logo
-    ssd1306_clear(&disp);
-    for (uint y = 0; y < LOGO_HEIGHT; y++) {
-        for (uint x = 0; x < LOGO_WIDTH; x++) {
-            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);
-            }
-        }
-    }
-    ssd1306_show(&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_draw_string(&disp, 0, LCD_HEIGHT - 8, 1, bat);
     ssd1306_show(&disp);
 }
 

src/main.c

 #include "encoder.h"
 #include "lcd.h"
 #include "led.h"
+#include "logo.h"
 #include "pulse.h"
 #include "sequence.h"
 #include "ui.h"
     lcd_init();
     led_init();
 
+    // show logo
+    lcd_draw_bitmap(logo_data,
+                    LOGO_WIDTH, LOGO_HEIGHT,
+                    0, 0);
+
     // read out button state for debug options
     buttons_callback(debug_buttons_callback);
     for (uint i = 0; i < (DEBOUNCE_DELAY_MS + 5); i++) {
         sleep_ms(1);
     }
 
+    // handle special button combos on boot
     if (debug_buttons[BTN_REC] && debug_buttons[BTN_CLICK]) {
         lcd_debug_buttons();
     } else if (debug_buttons[BTN_REC] && (!debug_buttons[BTN_CLICK])) {

src/sequence.c

                 pulse_trigger_out(ch, channel_times[ch]);
                 if (ui_get_machinemode() == MODE_LOOPSTATION) {
                     pulse_trigger_led(ch, channel_times[ch]);
+                    pulse_trigger_led(ch + 4, channel_times[ch]);
                 }
             }
         }

src/ui.c

 static enum machine_modes machine_mode = 0;
 static uint32_t last_bat_fetch = 0;
 static float last_voltage = 0.0f;
+static float last_percentage = 0.0f;
 
 enum machine_modes ui_get_machinemode(void) {
     return machine_mode;
         }
     }
 
-    snprintf(bat, sizeof(bat) - 1, "Bat: %.2fV", last_voltage);
+    snprintf(bat, sizeof(bat) - 1, "Bat: %.1f%% (%.2fV)", last_percentage, last_voltage);
     lcd_draw(mode, val, bat);
 }
 
         last_bat_fetch = now;
 
         float volt = bat_get();
-        if (fabsf(volt - last_voltage) >= 0.01f) {
+        float percentage = bat_to_percent(volt);
+        if ((fabsf(volt - last_voltage) >= 0.01f)
+                || (fabsf(percentage - last_percentage) >= 0.1f)) {
             last_voltage = volt;
+            last_percentage = percentage;
             ui_redraw();
         }
     }