first text rendering test

CMakeLists.txt

@@ -57,6 +57,8 @@ target_sources(gadget PUBLIC
     src/lipo.c
     src/ble.c
     src/lcd.c
+    src/text.c
+    src/image.c
 
     ${CMAKE_CURRENT_BINARY_DIR}/fatfs/ff.c
     ${CMAKE_CURRENT_BINARY_DIR}/fatfs/ffunicode.c

debug.sh

@@ -15,4 +15,4 @@ echo Opening picocom terminal
 echo "[C-a] [C-x] to exit"
 echo
 
-picocom -q --omap crcrlf $SERIAL
+picocom -q --omap crcrlf --imap lfcrlf $SERIAL

include/image.h

@@ -0,0 +1,24 @@
+/*
+ * image.h
+ *
+ * Copyright (c) 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 __IMAGE_H__
+#define __IMAGE_H__
+
+void draw_splash(void);
+
+#endif // __IMAGE_H__

include/lcd.h

@@ -24,6 +24,7 @@ void lcd_init(void);
 uint16_t lcd_get_backlight(void);
 void lcd_set_backlight(uint16_t value);
 
+void lcd_clear(void);
 void lcd_write_point(uint16_t x, uint16_t y, uint32_t color);
 
 #endif // __LCD_H__

include/log.h

@@ -21,6 +21,7 @@
 
 #include <stdarg.h>
 #include <stdbool.h>
+#include "pico/stdlib.h"
 
 // for output that is stored in the debug log.
 // will be re-played from buffer when terminal connects

include/text.h

@@ -0,0 +1,47 @@
+/*
+ * text.h
+ *
+ * Copyright (c) 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 __TEXT_H__
+#define __TEXT_H__
+
+#include "mcufont.h"
+
+struct text_font {
+    const char *fontname;
+    //int scale; // TODO not supported - requires somewhere to store scaled versions
+
+    const struct mf_font_s *font;
+};
+
+struct text_conf {
+    const char *text;
+    int x;
+    int y;
+    bool justify;
+    enum mf_align_t alignment;
+    int width;
+    int height;
+    int margin;
+
+    struct text_font *font;
+};
+
+void text_prepare_font(struct text_font *tf);
+void text_draw(struct text_conf *tc);
+
+#endif // __TEXT_H__

src/console.c

@@ -30,6 +30,9 @@
 #include "console.h"
 #include "lipo.h"
 #include "ble.h"
+#include "text.h"
+#include "lcd.h"
+#include "image.h"
 
 #define CNSL_BUFF_SIZE 1024
 #define CNSL_REPEAT_MS 500
@@ -75,6 +78,10 @@ static void cnsl_interpret(const char *line) {
         println("  mount - make mass storage medium (un)available");
         println("  power - show Lipo battery status");
         println("   scan - start or stop BLE scan");
+        println("  clear - blank screen");
+        println(" splash - draw image on screen");
+        println("  fonts - show font list");
+        println("   text - draw text on screen");
         println("Press Enter with no input to repeat last command.");
         println("Use repeat to continuously execute last command.");
         println("Stop this by calling repeat again.");
@@ -93,6 +100,58 @@ static void cnsl_interpret(const char *line) {
                 lipo_charging() ? "charging" : "draining");
     } else if (strcmp(line, "scan") == 0) {
         ble_scan(2);
+    } else if (strcmp(line, "clear") == 0) {
+        lcd_clear();
+    } else if (strcmp(line, "splash") == 0) {
+        draw_splash();
+    } else if (strcmp(line, "fonts") == 0) {
+        const struct mf_font_list_s *f = mf_get_font_list();
+
+        debug("Font list:");
+        while (f) {
+            debug("full_name: %s", f->font->full_name);
+            debug("short_name: %s", f->font->short_name);
+            debug("size: %d %d", f->font->width, f->font->height);
+            debug("x_advance: %d %d", f->font->min_x_advance, f->font->max_x_advance);
+            debug("baseline: %d %d", f->font->baseline_x, f->font->baseline_y);
+            debug("line_height: %d", f->font->line_height);
+            debug("flags: %d", f->font->flags);
+            debug("fallback_character: %c", f->font->fallback_character);
+            debug("character_width: %p", f->font->character_width);
+            debug("render_character: %p", f->font->render_character);
+
+            f = f->next;
+            if (f) {
+                debug("");
+            }
+        }
+    } else if (strcmp(line, "text") == 0) {
+        uint16_t y_off = 0;
+        const struct mf_font_list_s *f = mf_get_font_list();
+        while (f) {
+            struct text_font font = {
+                .fontname = f->font->short_name,
+                //.scale = 1,
+                .font = f->font,
+            };
+            text_prepare_font(&font);
+
+            struct text_conf text = {
+                .text = font.fontname,
+                .x = 0,
+                .y = y_off,
+                .justify = false,
+                .alignment = MF_ALIGN_CENTER,
+                .width = 240,
+                .height = 240 - y_off,
+                .margin = 5,
+                .font = &font,
+            };
+            text_draw(&text);
+
+            y_off = text.y;
+            f = f->next;
+        }
     } else {
         println("unknown command \"%s\"", line);
     }

src/image.c

@@ -0,0 +1,43 @@
+/*
+ * image.c
+ *
+ * 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/>.
+ */
+
+#include "pico/stdlib.h"
+
+#include "config.h"
+#include "lcd.h"
+#include "image.h"
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wtrigraphs"
+#include "logo.h"
+#pragma GCC diagnostic pop
+
+void draw_splash(void) {
+    char *data = logo_rgb_data;
+    for (uint x = 0; x < logo_width; x++) {
+        for (uint y = 0; y < logo_height; y++) {
+            uint32_t pixel[3];
+            HEADER_PIXEL(data, pixel);
+
+            uint32_t color = (pixel[0] >> 3) << 11;
+            color |= (pixel[1] >> 2) << 5;
+            color |= pixel[2] >> 3;
+            lcd_write_point(240 - x - 1, y, color);
+        }
+    }
+}

src/lcd.c

@@ -262,8 +262,10 @@ void lcd_set_backlight(uint16_t value) {
     pwm_set_chan_level(bl_slice, bl_channel, bl_value);
 }
 
+void lcd_clear(void) {
+    st7789_clear(&gs_handle);
+}
+
 void lcd_write_point(uint16_t x, uint16_t y, uint32_t color) {
     st7789_draw_point(&gs_handle, x, y, color);
-
-    st7789_display_on(&gs_handle);
 }

src/log.c

@@ -18,7 +18,6 @@
 
 #include <stdio.h>
 
-#include "pico/stdlib.h"
 #include "hardware/watchdog.h"
 #include "ff.h"
 

src/main.c

@@ -30,43 +30,28 @@
 #include "buttons.h"
 #include "ble.h"
 #include "lcd.h"
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wtrigraphs"
-#include "logo.h"
-#pragma GCC diagnostic pop
-
-static void draw_splash(void) {
-    char *data = logo_rgb_data;
-    for (uint x = 0; x < logo_width; x++) {
-        for (uint y = 0; y < logo_height; y++) {
-            uint32_t pixel[3];
-            HEADER_PIXEL(data, pixel);
-
-            uint32_t color = (pixel[0] >> 3) << 11;
-            color |= (pixel[1] >> 2) << 5;
-            color |= pixel[2] >> 3;
-            lcd_write_point(240 - x, y, color);
-        }
-    }
-}
+#include "text.h"
+#include "image.h"
 
 int main(void) {
-    heartbeat_init();
-    buttons_init();
+    // required for debug console
     cnsl_init();
     usb_init();
 
     debug("lcd_init");
     lcd_init();
     draw_splash();
-    lcd_set_backlight(0x8000);
+    lcd_set_backlight(0x1000);
 
     if (watchdog_caused_reboot()) {
         debug("reset by watchdog");
     }
 
+    debug("buttons_init");
+    buttons_init();
+
     // required for LiPo voltage reading
+    debug("adc_init");
     adc_init();
 
     // required for BLE and LiPo voltage reading
@@ -75,6 +60,9 @@ int main(void) {
         debug("cyw43_arch_init failed");
     }
 
+    debug("heartbeat_init");
+    heartbeat_init();
+
     debug("ble_init");
     ble_init();
 
@@ -85,6 +73,7 @@ int main(void) {
     watchdog_enable(1000, 1);
 
     debug("init done");
+    lcd_set_backlight(0x8000);
 
     while (1) {
         watchdog_update();

src/text.c

@@ -0,0 +1,112 @@
+/*
+ * text.c
+ *
+ * Copyright (c) 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/>.
+ */
+
+#include "config.h"
+#include "log.h"
+#include "lcd.h"
+#include "text.h"
+
+typedef struct {
+    struct text_conf *options;
+    uint16_t anchor;
+} state_t;
+
+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 (y < 0 || y >= s->options->height) return;
+    if (x < 0 || x + count >= s->options->width) return;
+
+    while (count--) {
+        uint32_t c = (alpha >> 3) << 11;
+        c |= (alpha >> 2) << 5;
+        c |= alpha >> 3;
+        lcd_write_point(240 - y - 1, x, c);
+        x++;
+    }
+}
+
+static uint8_t character_callback(int16_t x, int16_t y, mf_char character,
+                                  void *state) {
+    state_t *s = (state_t*)state;
+    uint8_t w = mf_render_character(s->options->font->font, x, y, character, pixel_callback, state);
+    return w;
+}
+
+static bool line_callback(const char *line, uint16_t count, void *state) {
+    state_t *s = (state_t*)state;
+
+    if (s->options->justify) {
+        mf_render_justified(s->options->font->font, s->anchor + s->options->x, s->options->y,
+                            s->options->width - s->options->margin * 2,
+                            line, count, character_callback, state);
+    } else {
+        mf_render_aligned(s->options->font->font, s->anchor + s->options->x, s->options->y,
+                          s->options->alignment, line, count,
+                          character_callback, state);
+    }
+
+    s->options->y += s->options->font->font->line_height;
+    return true;
+}
+
+void text_prepare_font(struct text_font *tf) {
+    if (!tf) {
+        debug("invalid param");
+        return;
+    }
+
+    const struct mf_font_s *font = mf_find_font(tf->fontname);
+    if (!font) {
+        debug("No such font: %s", tf->fontname);
+        return;
+    }
+
+    tf->font = font;
+
+    // TODO
+    //struct mf_scaledfont_s scaledfont;
+    //if (tf->scale > 1) {
+    //    mf_scale_font(&scaledfont, font, tf->scale, tf->scale);
+    //    tf->font = scaledfont.font;
+    //}
+}
+
+void text_draw(struct text_conf *tc) {
+    if ((!tc) || (!tc->font) || (!tc->font->font)) {
+        debug("invalid param");
+        return;
+    }
+
+    debug("'%s' %d", tc->text, tc->y);
+
+    state_t state;
+    state.options = tc;
+
+    if (tc->alignment == MF_ALIGN_LEFT) {
+        state.anchor = tc->margin;
+    } else if (tc->alignment == MF_ALIGN_CENTER) {
+        state.anchor = tc->width / 2;
+    } else if (tc->alignment == MF_ALIGN_RIGHT) {
+        state.anchor = tc->width - tc->margin;
+    }
+
+    mf_wordwrap(tc->font->font, tc->width - 2 * tc->margin,
+                tc->text, line_callback, &state);
+}

src/util.c

@@ -37,6 +37,9 @@ void heartbeat_init(void) {
     gpio_set_dir(PICO_DEFAULT_LED_PIN, GPIO_OUT);
     gpio_put(PICO_DEFAULT_LED_PIN, 1);
 #endif // PICO_DEFAULT_LED_PIN
+#ifdef CYW43_WL_GPIO_LED_PIN
+    cyw43_arch_gpio_put(CYW43_WL_GPIO_LED_PIN, 1);
+#endif // CYW43_WL_GPIO_LED_PIN
 }
 
 void heartbeat_run(void) {