custom picowota fork to show stuff on lcd and use flash wifi credentials

.gitmodules

 	url = https://github.com/hepingood/st7789
 [submodule "picowota"]
 	path = picowota
-	url = https://github.com/usedbytes/picowota
+	url = https://github.com/xythobuz/picowota

CMakeLists.txt

     CYW43_HOST_NAME="pico-volcano"
 )
 
+set(PICOWOTA_ADDITIONAL_SOURCES
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/wifi.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/lcd.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/log.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/mem.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/ring.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/textbox.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/text.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/ota_shim.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/workflow_default.c
+
+    ${CMAKE_CURRENT_SOURCE_DIR}/st7789/src/driver_st7789.c
+
+    ${CMAKE_CURRENT_SOURCE_DIR}/mcufont/decoder/mf_encoding.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/mcufont/decoder/mf_font.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/mcufont/decoder/mf_justify.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/mcufont/decoder/mf_kerning.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/mcufont/decoder/mf_rlefont.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/mcufont/decoder/mf_bwfont.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/mcufont/decoder/mf_scaledfont.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/mcufont/decoder/mf_wordwrap.c
+)
+set(PICOWOTA_ADDITIONAL_INCLUDES
+    ${CMAKE_CURRENT_SOURCE_DIR}/include
+    ${CMAKE_CURRENT_SOURCE_DIR}/conf
+    ${CMAKE_CURRENT_SOURCE_DIR}/data
+    ${CMAKE_CURRENT_SOURCE_DIR}/st7789/src
+    ${CMAKE_CURRENT_SOURCE_DIR}/st7789/interface
+    ${CMAKE_CURRENT_SOURCE_DIR}/mcufont/decoder
+    ${CMAKE_CURRENT_BINARY_DIR}/fatfs
+    ${CMAKE_CURRENT_SOURCE_DIR}/pico-sdk/src/rp2_common/pico_btstack/include
+    ${CMAKE_CURRENT_SOURCE_DIR}/pico-sdk/lib/btstack/platform/embedded
+)
+set(PICOWOTA_ADDITIONAL_LIBS
+    hardware_spi
+    hardware_pwm
+    hardware_flash
+    pico_flash
+)
+
 add_subdirectory(picowota)
 picowota_build_combined(gadget)

include/log.h

 
 // for output that is stored in the debug log.
 // will be re-played from buffer when terminal connects
+#ifndef PICOWOTA
 #define debug(fmt, ...) debug_log(true, \
         "%08lu %s: " fmt "\r\n", \
         to_ms_since_boot(get_absolute_time()), \
         __func__, \
         ##__VA_ARGS__)
+#else // PICOWOTA
+#define debug(fmt, ...) debug_log(true, \
+        fmt "\r\n", \
+        ##__VA_ARGS__)
+#endif // PICOWOTA
 
 // for interactive output. is not stored or re-played.
 #define print(fmt, ...) debug_log(false, fmt, ##__VA_ARGS__)
 void log_dump_to_usb(void);
 void log_dump_to_uart(void);
 void log_dump_to_disk(void);
+void log_dump_to_lcd(void);
 
 void debug_handle_input(const void *buff, size_t len);
 

include/ring.h

 #define rb_push(rb, v) rb_add(rb, v, 1)
 size_t rb_len(struct ring_buffer *rb);
 #define rb_space(rb) ((rb)->size - rb_len(rb))
-void rb_dump(struct ring_buffer *rb, void (*write)(const void *, size_t));
+void rb_dump(struct ring_buffer *rb, void (*write)(const void *, size_t), size_t skip);
 void rb_move(struct ring_buffer *rb, void (*write)(const void *, size_t));
 void rb_peek(struct ring_buffer *rb, void *buf);
 void rb_pop(struct ring_buffer *rb, void *buf);

include/wifi.h

 #ifndef __WIFI_H__
 #define __WIFI_H__
 
+#include <stdbool.h>
+
 #define WIFI_MAX_NET_COUNT 5
 #define WIFI_MAX_NAME_LEN 32
 #define WIFI_MAX_PASS_LEN 32
 void wifi_deinit(void);
 
 bool wifi_initialized(void);
+bool wifi_ready(void);
 const char *wifi_state(void);
 
 void wifi_run(void);

picowota

-Subproject commit ac8960b274f0f76013364a9b83325036cb52f030
+Subproject commit 4abdeee20f2dd8f813f322b61ce1afee7b502d12

src/log.c

  */
 
 #include <stdio.h>
+#include <string.h>
 
 #include "hardware/watchdog.h"
 #include "ff.h"
 
 #include "config.h"
 #include "main.h"
+#include "lcd.h"
+#include "textbox.h"
 #include "usb_cdc.h"
 #include "serial.h"
 #include "ring.h"
 
 static uint8_t line_buff[256] = {0};
 static volatile bool got_input = false;
+static int16_t lcd_off = 0;
+
+#ifndef PICOWOTA
 static FIL log_file_fat;
+#endif // PICOWOTA
 
 static void add_to_log(const void *buff, size_t len) {
     rb_add(&log, buff, len);
 }
 
+static void lcd_write(const void *buf, size_t len) {
+    char tmp[len + 1];
+    memcpy(tmp, buf, len);
+    tmp[len] = '\0';
+    lcd_off = text_box(tmp, false,
+                       "fixed_10x20",
+                       0, LCD_WIDTH,
+                       lcd_off, LCD_HEIGHT - lcd_off,
+                       0);
+}
+
+void log_dump_to_lcd(void) {
+    static size_t prev_len = 0;
+    size_t len = rb_len(&log);
+    if (len == prev_len) {
+        return;
+    }
+    prev_len = len;
+
+    lcd_off = 0;
+
+    const size_t todo = 120;
+    size_t text_off = 0;
+    if (len > todo) {
+        text_off = len - todo;
+    }
+
+    rb_dump(&log, lcd_write, text_off);
+}
+
+#ifndef PICOWOTA
 static void log_dump_to_x(void (*write)(const void *, size_t)) {
     if (rb_len(&log) == 0) {
         return;
         write(line_buff, l);
     }
 
-    rb_dump(&log, write);
+    rb_dump(&log, write, 0);
 
     l = snprintf((char *)line_buff, sizeof(line_buff), "\r\n\r\nlive log:\r\n");
     if ((l > 0) && (l <= (int)sizeof(line_buff))) {
 void log_dump_to_uart(void) {
 #ifndef NDEBUG
     log_dump_to_x(serial_write);
-#endif
+#endif // NDEBUG
 }
 
 static void log_file_write_callback(const void *data, size_t len) {
         return;
     }
 
-    rb_dump(&log, log_file_write_callback);
+    rb_dump(&log, log_file_write_callback, 0);
 
     res = f_close(&log_file_fat);
     if (res != FR_OK) {
     }
 }
 
+#endif // PICOWOTA
+
 void debug_log_va(bool log, const char *format, va_list args) {
     int l = vsnprintf((char *)line_buff, sizeof(line_buff), format, args);
 
         l = snprintf((char *)line_buff, sizeof(line_buff), "%s: message too long (%d)\r\n", __func__, l);
     }
     if ((l > 0) && (l <= (int)sizeof(line_buff))) {
+#ifndef PICOWOTA
         usb_cdc_write(line_buff, l);
 
 #ifndef NDEBUG
         serial_write(line_buff, l);
-#endif
+#endif // NDEBUG
+#endif // PICOWOTA
 
         if (log) {
             add_to_log(line_buff, l);
     va_end(args);
 }
 
+#ifndef PICOWOTA
 void debug_handle_input(const void *buff, size_t len) {
     (void)buff;
 
     usb_cdc_set_reroute(false);
     serial_set_reroute(false);
 }
+#endif // PICOWOTA

src/mem.c

     }
 
     // TODO better way to pre-define WiFi credentials
+#if defined(DEFAULT_WIFI_SSID) && defined(DEFAULT_WIFI_PASS)
     data_ram.data.net_count = 1;
     strcpy(data_ram.data.net[0].name, DEFAULT_WIFI_SSID);
     strcpy(data_ram.data.net[0].pass, DEFAULT_WIFI_PASS);
+#else
+    data_ram.data.net_count = 0;
+#endif
 }
 
 void mem_load(void) {
         } else {
             debug("loading from flash (0x%08lX)", checksum);
             data_ram = *flash_ptr;
+            debug("%s", data_ram.data.net[0].pass);
         }
     } else {
         debug("invalid config (0x%02X != 0x%02X)", flash_ptr->version, MEM_VERSION);
     }
 
+#if defined(DEFAULT_WIFI_SSID) && defined(DEFAULT_WIFI_PASS)
     // add default WiFi from #define to flash config, if it is not there yet
     bool found = false;
     for (uint16_t i = 0; i < data_ram.data.net_count; i++) {
         strcpy(data_ram.data.net[data_ram.data.net_count].pass, DEFAULT_WIFI_PASS);
         data_ram.data.net_count++;
     }
+#endif
 }
 
 static void mem_write_flash(void *param) {

src/ota_shim.c

+/*
+ * ota_shim.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 "pico/cyw43_arch.h"
+
+#include "config.h"
+#include "lcd.h"
+#include "log.h"
+#include "mem.h"
+#include "wifi.h"
+
+int picowota_network_init(void) {
+    debug("mem_load");
+    mem_load();
+
+    debug("lcd_init");
+    lcd_init();
+
+    lcd_set_backlight(mem_data()->backlight);
+    log_dump_to_lcd();
+
+    debug("cyw43_arch_init");
+    log_dump_to_lcd();
+
+    if (cyw43_arch_init_with_country(COUNTRY_CODE)) {
+        debug("failed to init cyw43");
+        log_dump_to_lcd();
+
+        return 1;
+    }
+
+    debug("wifi_init");
+    log_dump_to_lcd();
+
+    wifi_init();
+
+    const char *prev = NULL;
+    while (!wifi_ready()) {
+        cyw43_arch_poll();
+        wifi_run();
+
+        const char *state = wifi_state();
+        if (state != prev) {
+            prev = state;
+            debug("new state: %s", state);
+        }
+
+        log_dump_to_lcd();
+
+        // TODO open AP when timed out?
+    }
+
+    debug("wifi ready");
+    log_dump_to_lcd();
+
+    return 0;
+}
+
+void picowota_network_deinit(void) {
+    debug("wifi_deinit");
+    wifi_deinit();
+}

src/ring.c

  * See <http://www.gnu.org/licenses/>.
  */
 
+#define MIN(x, y) ((x < y) ? x : y)
+
 #include <string.h>
 
 #include "config.h"
     }
 }
 
-void rb_dump(struct ring_buffer *rb, void (*write)(const void *, size_t)) {
-    if (rb_len(rb) == 0) {
+void rb_dump(struct ring_buffer *rb, void (*write)(const void *, size_t), size_t skip) {
+    if (rb_len(rb) <= skip) {
         return;
     }
 
     if (rb->head > rb->tail) {
-        write(rb->buffer + rb->tail * rb->el_len, rb->head - rb->tail);
+        if ((rb->head - rb->tail) > skip) {
+            write(rb->buffer + ((rb->tail + skip) * rb->el_len), rb->head - rb->tail - skip);
+        }
     } else {
-        write(rb->buffer + rb->tail * rb->el_len, rb->size - rb->tail);
-        write(rb->buffer, rb->head);
+        if ((rb->size - rb->tail) > skip) {
+            write(rb->buffer + ((rb->tail + skip) * rb->el_len), rb->size - rb->tail - skip);
+        }
+
+        skip -= MIN(skip, rb->size - rb->tail);
+        if (rb->head > skip) {
+            write(rb->buffer + (skip + rb->el_len), rb->head - skip);
+        }
     }
 }
 
 void rb_move(struct ring_buffer *rb, void (*write)(const void *, size_t)) {
-    rb_dump(rb, write);
+    rb_dump(rb, write, 0);
     rb->head = 0;
     rb->tail = 0;
     rb->full = false;

src/wifi.c

     return (state != WS_IDLE);
 }
 
+bool wifi_ready(void) {
+    return (state == WS_READY);
+}
+
 const char *wifi_state(void) {
     switch (state) {
     case WS_IDLE: