support arbitrary blended text colors

include/lcd.h

     | (((g) >> 2) << 5)    \
     |  ((b) >> 3)          \
 )
+#define RGB_565_REV(c)            \
+    ((c & 0xF800) >> 8) / 255.0f, \
+    ((c & 0x07E0) >> 3) / 255.0f, \
+    ((c & 0x001F) << 3) / 255.0f
+uint32_t from_hsv(float h, float s, float v);
 
 void lcd_init(void);
 

include/text.h

     int width;
     int height;
     int margin;
+    int fg;
     int bg;
 
     struct text_font *font;

include/util.h

 
 void hexdump(uint8_t *buff, size_t len);
 
+float map(float value, float leftMin, float leftMax, float rightMin, float rightMax);
+
 #endif // __UTIL_H__

src/image.c

 #include "lcd.h"
 #include "text.h"
 #include "lipo.h"
+#include "util.h"
 #include "image.h"
 
 #pragma GCC diagnostic push
         .width = 240,
         .height = 240,
         .margin = 2,
+        .fg = RGB_565(0xFF, 0xFF, 0xFF),
         .bg = RGB_565(0x00, 0x00, 0x00),
         .font = &font_big,
     };
         .width = 240,
         .height = 240,
         .margin = 2,
+        .fg = RGB_565(0xFF, 0xFF, 0xFF),
         .bg = RGB_565(0x00, 0x00, 0x00),
         .font = &font_small,
     };
 }
 
 void draw_battery_indicator(void) {
-    float v = lipo_voltage();
+    static const float batt_warn_limit = 15.0f;
     static char s[30];
+    float v = lipo_voltage();
+    uint32_t c = RGB_565(0xFF, 0x00, 0x00);
     if (lipo_charging()) {
         //                     "Batt:   99.9%   (4.20V)"
         snprintf(s, sizeof(s), "Batt: Charging! (%.2fV)", v);
+        c = RGB_565(0xFF, 0xFF, 0x00);
     } else {
-        snprintf(s, sizeof(s), "Batt:   %02.1f%%   (%.2fV)", lipo_percentage(v), v);
+        float percentage = lipo_percentage(v);
+        snprintf(s, sizeof(s), "Batt:   %02.1f%%   (%.2fV)", percentage, v);
+
+        if (percentage > batt_warn_limit) {
+            float hue = map(percentage, batt_warn_limit, 100, 0.0, 0.333);
+            c = from_hsv(hue, 1.0, 1.0);
+        }
     }
 
     static struct text_font font = {
         .width = 240,
         .height = 240,
         .margin = 2,
+        .fg = c,
         .bg = RGB_565(0x00, 0x00, 0x00),
         .font = &font,
     };

src/lcd.c

  * See <http://www.gnu.org/licenses/>.
  */
 
+#include <math.h>
+
 #include "pico/stdlib.h"
 #include "hardware/spi.h"
 #include "hardware/pwm.h"
 void lcd_write_rect(uint16_t left, uint16_t top, uint16_t right, uint16_t bottom, uint32_t color) {
     st7789_fill_rect(&gs_handle, left, top, right, bottom, color);
 }
+
+uint32_t from_hsv(float h, float s, float v) {
+    float i = floorf(h * 6.0f);
+    float f = h * 6.0f - i;
+    v *= 255.0f;
+    float p = v * (1.0f - s);
+    float q = v * (1.0f - f * s);
+    float t = v * (1.0f - (1.0f - f) * s);
+
+    switch (((uint32_t)i) % 6) {
+    case 0:
+        return RGB_565((uint32_t)v, (uint32_t)t, (uint32_t)p);
+
+    case 1:
+        return RGB_565((uint32_t)q, (uint32_t)v, (uint32_t)p);
+
+    case 2:
+        return RGB_565((uint32_t)p, (uint32_t)v, (uint32_t)t);
+
+    case 3:
+        return RGB_565((uint32_t)p, (uint32_t)q, (uint32_t)v);
+
+    case 4:
+        return RGB_565((uint32_t)t, (uint32_t)p, (uint32_t)v);
+
+    case 5:
+        return RGB_565((uint32_t)v, (uint32_t)p, (uint32_t)q);
+
+    default:
+        return RGB_565(0, 0, 0);
+    }
+}

src/text.c

     uint16_t anchor;
 } state_t;
 
+static uint32_t blend(uint32_t fg_c, uint32_t bg_c, uint8_t alpha) {
+    float bg[4] = { RGB_565_REV(bg_c), 1.0f };
+    float fg[4] = { RGB_565_REV(fg_c), alpha / 255.0f };
+    float r[4];
+    r[3] = 1.0f - (1.0f - fg[3]) * (1.0f - bg[3]);
+    if (r[3] < 1.0e-6f) {
+        r[0] = 0.0f;
+        r[1] = 0.0f;
+        r[2] = 0.0f;
+    } else {
+        r[0] = fg[0] * fg[3] / r[3] + bg[0] * bg[3] * (1.0f - fg[3]) / r[3];
+        r[1] = fg[1] * fg[3] / r[3] + bg[1] * bg[3] * (1.0f - fg[3]) / r[3];
+        r[2] = fg[2] * fg[3] / r[3] + bg[2] * bg[3] * (1.0f - fg[3]) / r[3];
+    }
+
+    return RGB_565((uint32_t)(r[0] * 255.0f),
+                   (uint32_t)(r[1] * 255.0f),
+                   (uint32_t)(r[2] * 255.0f));
+}
+
 static void pixel_callback(int16_t x, int16_t y, uint8_t count, uint8_t alpha,
                            void *state) {
     state_t *s = (state_t*)state;
     if (x < 0 || x + count >= s->options->width) return;
 
     while (count--) {
-        uint32_t c = RGB_565(alpha, alpha, alpha);
-        lcd_write_point(240 - y - 1, x, c);
+        lcd_write_point(240 - y - 1, x,
+                        blend(s->options->fg, s->options->bg, alpha));
         x++;
     }
 }

src/util.c

         println();
     }
 }
+
+float map(float value, float leftMin, float leftMax, float rightMin, float rightMax) {
+    float leftSpan = leftMax - leftMin;
+    float rightSpan = rightMax - rightMin;
+    float valueScaled = (value - leftMin) / leftSpan;
+    return rightMin + (valueScaled * rightSpan);
+}