add Bitty HTTP server and some other tweaks

.gitmodules

 [submodule "picowota"]
 	path = picowota
 	url = https://github.com/usedbytes/picowota
+[submodule "BittyHTTP"]
+	path = BittyHTTP
+	url = https://github.com/TheBeef/BittyHTTP

BittyHTTP

+Subproject commit 0c531a062fe44ce9ee372361e14906924737ced1

CMakeLists.txt

     WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/mcufont/fonts
 )
 
+# remove Options.h from BittyHTTP so we can use our own (TODO ugly)
+execute_process(COMMAND rm Options.h
+    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/BittyHTTP/src
+)
+
 # initialize pico-sdk from submodule
 include(pico-sdk/pico_sdk_init.cmake)
 
     src/state_wifi.c
     src/state_wifi_edit.c
     src/state_string.c
+    src/http.c
+    src/http_socket.c
+    src/http_files.c
 
     ${CMAKE_CURRENT_BINARY_DIR}/fatfs/ff.c
     ${CMAKE_CURRENT_BINARY_DIR}/fatfs/ffunicode.c
     mcufont/decoder/mf_bwfont.c
     mcufont/decoder/mf_scaledfont.c
     mcufont/decoder/mf_wordwrap.c
+
+    BittyHTTP/src/WebServer.c
 )
 
 # external dependency include directories
+target_include_directories(gadget PUBLIC ${CMAKE_CURRENT_LIST_DIR}/conf)
 target_include_directories(gadget PUBLIC ${CMAKE_CURRENT_LIST_DIR}/include)
 target_include_directories(gadget PUBLIC ${CMAKE_CURRENT_BINARY_DIR}/fatfs)
 target_include_directories(gadget PUBLIC ${CMAKE_CURRENT_LIST_DIR}/st7789/src)
 target_include_directories(gadget PUBLIC ${CMAKE_CURRENT_LIST_DIR}/mcufont/decoder)
 target_include_directories(gadget PUBLIC ${CMAKE_CURRENT_LIST_DIR}/data)
 target_include_directories(gadget PUBLIC ${CMAKE_CURRENT_LIST_DIR}/build)
+target_include_directories(gadget PUBLIC ${CMAKE_CURRENT_LIST_DIR}/BittyHTTP/src)
 
 # compress source code and stuff we want to include
 add_custom_target(pack bash -c "./pack_data.sh"
 set_source_files_properties(pico-sdk/lib/btstack/src/classic/goep_client.c PROPERTIES COMPILE_FLAGS -Wno-unused-parameter)
 set_source_files_properties(pico-sdk/lib/btstack/src/classic/goep_server.c PROPERTIES COMPILE_FLAGS -Wno-unused-parameter)
 
+# suppress warnings for BittyHTTP
+set_source_files_properties(BittyHTTP/src/WebServer.c PROPERTIES COMPILE_FLAGS "-Wno-sign-compare -Wno-unused-parameter -Wno-maybe-uninitialized")
+
 # pull in common dependencies
 target_link_libraries(gadget
     pico_stdlib
     picowota_reboot
 )
 
-pico_set_linker_script(gadget ${CMAKE_CURRENT_SOURCE_DIR}/src/memmap_custom.ld)
+pico_set_linker_script(gadget ${CMAKE_CURRENT_SOURCE_DIR}/conf/memmap_custom.ld)
 
 # fix for Errata RP2040-E5 (the fix requires use of GPIO 15)
 target_compile_definitions(gadget PUBLIC PICO_RP2040_USB_DEVICE_ENUMERATION_FIX=1)
 set(PICOWOTA_WIFI_PASS "WIFI_PASS_HERE")
 set(PICOWOTA_WIFI_AP 0)
 
+# TODO set DOCVER to hash of static http files?
+
 target_compile_definitions(gadget PUBLIC
     RUNNING_AS_CLIENT=1
     DEFAULT_WIFI_SSID="${PICOWOTA_WIFI_SSID}"
     DEFAULT_WIFI_PASS="${PICOWOTA_WIFI_PASS}"
+    DOCVER="1.0.0.0"
 )
 
 add_subdirectory(picowota)

conf/Options.h

+/*
+ * Options.h
+ *
+ * Copyright (c) 2023 Thomas Buck (thomas@xythobuz.de)
+ * Copyright (c) 2019 Paul Hutchinson
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef __OPTIONS_H_
+#define __OPTIONS_H_
+
+#ifndef DOCVER
+#define DOCVER "1.0.0.0"
+#endif
+
+// The max number of connections we can handle at the same time
+// (this will include buffers needed for each connection)
+#define WS_OPT_MAX_CONNECTIONS              2
+
+// The memory block to use to store the cookies, get args, and post args
+#define WS_OPT_ARG_MEMORY_SIZE              100
+
+// How many seconds to wait after a connection stops sending to us before we hang up
+#define WS_SECONDS_UNTIL_CONNECTION_RELEASE 5
+
+// The max number of bytes we can handle a single header line can be (including the GET line).
+// This is normally in the order of 16K - 128K (we default to a lot less)
+#define WS_LINE_BUFFER_SIZE                 256
+
+#endif // __OPTIONS_H_

include/console.h

 
 void cnsl_init(void);
 void cnsl_run(void);
-void cnsl_handle_input(const uint8_t *buf, size_t len);
+void cnsl_handle_input(const void *buf, size_t len);
 
 #endif // __CONSOLE_H__

include/http.h

+/*
+ * http.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 __HTTP_H__
+#define __HTTP_H__
+
+void http_init(void);
+void http_deinit(void);
+void http_run(void);
+
+#endif // __HTTP_H__

include/log.h

 void log_dump_to_uart(void);
 void log_dump_to_disk(void);
 
-void debug_handle_input(const uint8_t *buff, size_t len);
+void debug_handle_input(const void *buff, size_t len);
 
 #endif // __LOG_H__

include/main.h

 
 void main_loop_hw(void);
 
+void networking_init(void);
+void networking_deinit(void);
+void networking_run(void);
+
 #endif // __MAIN_H__

include/ring.h

 #include <stdbool.h>
 
 struct ring_buffer {
-    uint8_t *buffer;
+    void *buffer;
     size_t size;
+    size_t el_len;
     size_t head, tail;
     bool full;
 };
-#define RB_INIT(b, s) { .buffer = b, .size = s, .head = 0, .tail = 0, .full = false }
+#define RB_INIT(b, s, e) { .buffer = b, .size = s, .el_len = e, .head = 0, .tail = 0, .full = false }
 
-void rb_add(struct ring_buffer *rb, const uint8_t *data, size_t length);
-#define rb_push(rb, v) rb_add(rb, &v, 1)
+void rb_add(struct ring_buffer *rb, const void *data, size_t length);
+#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 uint8_t *, size_t));
-void rb_move(struct ring_buffer *rb, void (*write)(const uint8_t *, size_t));
-uint8_t rb_peek(struct ring_buffer *rb);
-uint8_t rb_pop(struct ring_buffer *rb);
+void rb_dump(struct ring_buffer *rb, void (*write)(const void *, size_t));
+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);
+size_t rb_get(struct ring_buffer *rb, void *data, size_t length);
 
 #endif // __RING_BUFFER_H__

include/serial.h

 #include <stdbool.h>
 
 void serial_init(void);
-void serial_write(const uint8_t *buf, size_t count);
+void serial_write(const void *buf, size_t count);
 void serial_set_reroute(bool reroute);
 void serial_run(void);
 

include/usb_cdc.h

 #include <stdint.h>
 #include <stdbool.h>
 
-void usb_cdc_write(const uint8_t *buf, size_t count);
+void usb_cdc_write(const void *buf, size_t count);
 void usb_cdc_set_reroute(bool reroute);
 
 #endif // __USB_CDC_H__

include/venty.h

 int8_t venty_set_heater_state(bool value);
 int8_t venty_set_eco_current(bool value);
 int8_t venty_set_eco_voltage(bool value);
+int8_t venty_set_vibration(bool value);
+
+// v from 1 to 9, returns < 0 on error
+int8_t venty_set_brightness(uint8_t value);
 
 // in percent, or < 0 on error
 int8_t venty_get_battery_state(void);
 
 // bool, or < 0 on error
+int8_t venty_get_heater_state(void);
 int8_t venty_get_eco_current(void);
 int8_t venty_get_eco_voltage(void);
+int8_t venty_get_vibration(void);
+
+// returns 1 to 9, or < 0 on error
+int8_t venty_get_brightness(void);
 
 #endif // __VENTY_H__

pack_data.sh

 cp CMakeLists.txt build/src
 cp .gitmodules build/src/gitmodules
 cp -r include build/src
+cp -r conf build/src
 cp -r src build/src
 
 cd build

src/console.c

     }
 }
 
-void cnsl_handle_input(const uint8_t *buf, size_t len) {
+void cnsl_handle_input(const void *buf, size_t len) {
     if ((cnsl_buff_pos + len) > CNSL_BUFF_SIZE) {
         debug("error: console input buffer overflow! %lu > %u", cnsl_buff_pos + len, CNSL_BUFF_SIZE);
         cnsl_init();

src/http.c

+/*
+ * http.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 "WebServer.h"
+
+#include "config.h"
+#include "log.h"
+#include "http.h"
+
+void http_init(void) {
+    SocketsCon_InitSocketConSystem();
+    WS_Init();
+
+    if (!WS_Start(80)) {
+        debug("failed to start web server");
+    } else {
+        debug("listening on :80");
+    }
+}
+
+void http_deinit(void) {
+    WS_Shutdown();
+    SocketsCon_ShutdownSocketConSystem();
+}
+
+void http_run(void) {
+    WS_Tick();
+}

src/http_files.c

+/*
+ * http_files.c
+ *
+ * Based on BittyHTTP example.
+ *
+ * Copyright (c) 2023 Thomas Buck (thomas@xythobuz.de)
+ * Copyright (c) 2019 Paul Hutchinson
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include <string.h>
+
+#include "WebServer.h"
+
+#include "config.h"
+#include "log.h"
+#include "http.h"
+
+struct FileInfo {
+    const char *Filename; // With Path
+    bool Dynamic;
+    const char **Cookies;
+    const char **Gets;
+    const char **Posts;
+    void (*WriteFile)(struct WebServer *Web);
+};
+
+void File_Root(struct WebServer *Web);
+
+static struct FileInfo m_Files[] =  {
+    // Filename, Dynamic, Cookies, Gets, Posts, Callback
+    {       "/",   false,    NULL, NULL,  NULL, File_Root },
+};
+
+bool FS_GetFileProperties(const char *Filename, struct WSPageProp *PageProp) {
+    PageProp->FileID = 0;
+
+    for (size_t r = 0; r < sizeof(m_Files) / sizeof(struct FileInfo); r++) {
+        if (strcmp(Filename, m_Files[r].Filename) != 0) {
+            continue;
+        }
+
+        PageProp->FileID = (uintptr_t)&m_Files[r];
+        PageProp->DynamicFile = m_Files[r].Dynamic;
+        PageProp->Cookies = m_Files[r].Cookies;
+        PageProp->Gets = m_Files[r].Gets;
+        PageProp->Posts = m_Files[r].Posts;
+
+        debug("serving '%s'", Filename);
+        return true;
+    }
+
+    debug("unknown file '%s'", Filename);
+    return false;
+}
+
+void FS_SendFile(struct WebServer *Web, uintptr_t FileID) {
+    struct FileInfo *File = (struct FileInfo *)FileID;
+    if ((Web == NULL) || (File == NULL)) {
+        debug("invalid param");
+        return;
+    }
+
+    File->WriteFile(Web);
+}
+
+t_ElapsedTime ReadElapsedClock(void) {
+    return to_ms_since_boot(get_absolute_time()) / 1000;
+}
+
+const char RootHTML[]=
+"<!DOCTYPE html>"
+"<html>"
+"<head>"
+    "<title>Volcano Remote</title>"
+"</head>"
+"<body>"
+    "<h1>Hello World</h1>"
+"</body>"
+"</html>";
+
+void File_Root(struct WebServer *Web) {
+    WS_WriteWhole(Web,RootHTML, sizeof(RootHTML) - 1);
+}

src/http_socket.c

+/*
+ * http_socket.c
+ *
+ * Based on BittyHTTP example socket interface.
+ *
+ * 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 <string.h>
+
+#include "lwip/tcp.h"
+#include "lwip/dns.h"
+#include "SocketsCon.h"
+
+#include "config.h"
+#include "log.h"
+#include "main.h"
+#include "ring.h"
+#include "http.h"
+
+#define MAX_SOCK 4
+#define SOCK_RECV_BUFF 512
+
+#define HTTP_DNS_TIMEOUT_MS 5000
+#define HTTP_CONNECT_TIMEOUT_MS 5000
+
+struct tcp_sock {
+    bool set;
+    struct tcp_pcb *pcb;
+
+    // TODO listening server socket has unused buffer
+    uint8_t rx_buf[SOCK_RECV_BUFF];
+    struct ring_buffer rx_rb;
+
+    struct tcp_pcb *child_buf[MAX_SOCK];
+    struct ring_buffer child_rb;
+};
+
+static struct tcp_sock sock[MAX_SOCK] = {0};
+
+bool SocketsCon_InitSocketConSystem(void) {
+    return true;
+}
+
+void SocketsCon_ShutdownSocketConSystem(void) { }
+
+static void tcp_server_err(void *arg, err_t err) {
+    debug("tcp error %d", err);
+
+    struct SocketCon *Con = arg;
+    Con->ErrorCode = e_ConnectErrorMAX;
+    Con->State = e_ConnectState_Error;
+}
+
+static err_t tcp_server_recv(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err) {
+    (void)tpcb;
+    debug("tcp recv %d %d", p->len, err);
+
+    struct SocketCon *Con = arg;
+    size_t idx = Con->SocketFD;
+
+    if (rb_space(&sock[idx].rx_rb) < p->len) {
+        debug("not enough space (%d < %d)", rb_space(&sock[idx].rx_rb), p->len);
+        tcp_abort(sock[idx].pcb);
+        Con->ErrorCode = e_ConnectErrorMAX;
+        Con->State = e_ConnectState_Error;
+        return ERR_ABRT;
+    }
+
+    rb_add(&sock[idx].rx_rb, p->payload, p->len);
+    return ERR_OK;
+}
+
+bool SocketsCon_InitSockCon(struct SocketCon *Con) {
+    if (!Con) {
+        debug("invalid param");
+        return false;
+    }
+
+    ssize_t next = -1;
+    for (size_t i = 0; i < MAX_SOCK; i++) {
+        if (!sock[i].set) {
+            next = i;
+            break;
+        }
+    }
+
+    if (next < 0) {
+        debug("error: too many sockets");
+        return false;
+    }
+
+    debug("new socket at %d", next);
+
+    sock[next].pcb = tcp_new_ip_type(IPADDR_TYPE_ANY);
+    if (sock[next].pcb == NULL) {
+        debug("error allocating new socket");
+        return false;
+    }
+
+    tcp_arg(sock[next].pcb, Con);
+    tcp_err(sock[next].pcb, tcp_server_err);
+    tcp_recv(sock[next].pcb, tcp_server_recv);
+
+    Con->SocketFD = next;
+    sock[next].set = true;
+
+    struct ring_buffer tmp = RB_INIT(sock[next].rx_buf, SOCK_RECV_BUFF, sizeof(uint8_t));
+    sock[next].rx_rb = tmp;
+
+    struct ring_buffer tmp2 = RB_INIT(sock[next].child_buf, MAX_SOCK, sizeof(struct tcp_pcb *));
+    sock[next].child_rb = tmp2;
+
+    Con->ErrorCode = e_ConnectError_AllOk;
+    Con->State = e_ConnectState_Idle;
+    Con->ReadInProgress = false;
+
+    return true;
+}
+
+static err_t tcp_server_connected(void *arg, struct tcp_pcb *tpcb, err_t err) {
+    (void)tpcb;
+    debug("tcp connected");
+
+    struct SocketCon *Con = arg;
+    Con->State = (err == ERR_OK) ? e_ConnectState_Connected : e_ConnectState_Idle;
+    return ERR_OK;
+}
+
+bool SocketsCon_Connect(struct SocketCon *Con,
+                        const char *ServerName, int portNo) {
+    if ((!Con) || (!ServerName)) {
+        debug("invalid param");
+        return false;
+    }
+
+    ip_addr_t ipaddr;
+    err_t err;
+    uint32_t start_time = to_ms_since_boot(get_absolute_time());
+    do {
+        err = dns_gethostbyname(ServerName, &ipaddr, NULL, NULL);
+        main_loop_hw();
+
+        uint32_t now = to_ms_since_boot(get_absolute_time());
+        if ((now - start_time) >= HTTP_DNS_TIMEOUT_MS) {
+            break;
+        }
+    } while (err == ERR_INPROGRESS);
+    if (err != ERR_OK) {
+        debug("error getting IP for '%s'", ServerName);
+        return false;
+    } else {
+        debug("IP %s for '%s'", ip4addr_ntoa(&ipaddr), ServerName);
+    }
+
+    Con->State = e_ConnectState_Connecting;
+
+    size_t idx = Con->SocketFD;
+    err = tcp_connect(sock[idx].pcb,
+                            &ipaddr, portNo,
+                            tcp_server_connected);
+    if (err != ERR_OK) {
+        debug("error connecting (%d)", err);
+        Con->State = e_ConnectState_Idle;
+        return false;
+    }
+
+    start_time = to_ms_since_boot(get_absolute_time());
+    while (Con->State == e_ConnectState_Connecting) {
+        main_loop_hw();
+
+        uint32_t now = to_ms_since_boot(get_absolute_time());
+        if ((now - start_time) >= HTTP_CONNECT_TIMEOUT_MS) {
+            break;
+        }
+    }
+
+    // TODO ?
+    //if (Con->State == e_ConnectState_Error) {
+    //    Con->State = e_ConnectState_Idle;
+    //}
+
+    return (Con->State == e_ConnectState_Connected);
+}
+
+bool SocketsCon_EnableAddressReuse(struct SocketCon *Con, bool Enable) {
+    (void)Con;
+    (void)Enable;
+    return true;
+}
+
+void SocketsCon_Tick(struct SocketCon *Con) { (void)Con; }
+
+bool SocketsCon_Write(struct SocketCon *Con, const void *buf, int num) {
+    if ((!Con) || (!buf) || (num <= 0)) {
+        debug("invalid param");
+        return false;
+    }
+
+    size_t idx = Con->SocketFD;
+    err_t err = tcp_write(sock[idx].pcb,
+                          buf, num, TCP_WRITE_FLAG_COPY);
+    if (err != ERR_OK) {
+        debug("error writing to socket");
+        return false;
+    }
+
+    return true;
+}
+
+int SocketsCon_Read(struct SocketCon *Con, void *buf, int num) {
+    if ((!Con) || (!buf) || (num <= 0)) {
+        debug("invalid param");
+        return false;
+    }
+
+    // TODO irq disable?
+
+    size_t idx = Con->SocketFD;
+    size_t len = rb_get(&sock[idx].rx_rb, buf, num);
+
+    // TODO irq enable?
+
+    return len;
+}
+
+void SocketsCon_Close(struct SocketCon *Con) {
+    if (!Con) {
+        debug("invalid param");
+        return;
+    }
+
+    size_t idx = Con->SocketFD;
+    sock[idx].set = false;
+
+    err_t err = tcp_close(sock[idx].pcb);
+    if (err != ERR_OK) {
+        debug("error closing socket (%d)", err);
+        // TODO retry?
+    }
+}
+
+static err_t tcp_server_accept(void *arg, struct tcp_pcb *newpcb, err_t err) {
+    (void)err; // TODO?
+
+    struct SocketCon *Con = arg;
+    size_t idx = Con->SocketFD;
+    if (rb_space(&sock[idx].child_rb) <= 0) {
+        debug("no space for new connection");
+        tcp_abort(newpcb);
+        return ERR_ABRT;
+    }
+
+    debug("new connection");
+
+    rb_push(&sock[idx].child_rb, &newpcb);
+    return ERR_OK;
+}
+
+bool SocketsCon_Listen(struct SocketCon *Con, const char *bindadd, int PortNo) {
+    if (!Con) {
+        debug("invalid param");
+        return false;
+    }
+
+    ip_addr_t ipaddr;
+    err_t err;
+    if (bindadd) {
+        uint32_t start_time = to_ms_since_boot(get_absolute_time());
+        do {
+            err = dns_gethostbyname(bindadd, &ipaddr, NULL, NULL);
+            main_loop_hw();
+
+            uint32_t now = to_ms_since_boot(get_absolute_time());
+            if ((now - start_time) >= HTTP_DNS_TIMEOUT_MS) {
+                break;
+            }
+        } while (err == ERR_INPROGRESS);
+        if (err != ERR_OK) {
+            debug("error getting IP for '%s'", bindadd);
+            return false;
+        } else {
+            debug("IP %s for '%s'", ip4addr_ntoa(&ipaddr), bindadd);
+        }
+    }
+
+    size_t idx = Con->SocketFD;
+    err = tcp_bind(sock[idx].pcb,
+                   bindadd ? &ipaddr : IP_ANY_TYPE,
+                   PortNo);
+    if (err != ERR_OK) {
+        debug("error binding to '%s'", bindadd);
+        return false;
+    }
+
+    struct tcp_pcb *tmp = tcp_listen(sock[idx].pcb);
+    if (tmp == NULL) {
+        debug("error listening on socket");
+        return false;
+    }
+    sock[idx].pcb = tmp;
+
+    tcp_accept(sock[idx].pcb, tcp_server_accept);
+
+    return true;
+}
+
+bool SocketsCon_Accept(struct SocketCon *Con, struct SocketCon *NewCon) {
+    if ((!Con) || (!NewCon)) {
+        debug("invalid param");
+        return false;
+    }
+
+    size_t idx = Con->SocketFD;
+    size_t new_idx = NewCon->SocketFD;
+
+    if (rb_len(&sock[idx].child_rb) <= 0) {
+        return false;
+    }
+
+    debug("accepting new connection");
+
+    struct tcp_pcb *new_pcb;
+    rb_pop(&sock[idx].child_rb, &new_pcb);
+
+    err_t err = tcp_close(sock[new_idx].pcb);
+    if (err != ERR_OK) {
+        debug("error closing prev new socket");
+    }
+
+    sock[new_idx].pcb = new_pcb;
+    return true;
+}
+
+bool SocketsCon_HasError(struct SocketCon *Con) {
+    if (!Con) {
+        debug("invalid param");
+        return true;
+    }
+    return Con->State == e_ConnectState_Error;
+}
+
+bool SocketsCon_IsConnected(struct SocketCon *Con) {
+    if (!Con) {
+        debug("invalid param");
+        return false;
+    }
+    return Con->State == e_ConnectState_Connected;
+}
+
+int SocketsCon_GetLastErrNo(struct SocketCon *Con) {
+    if (!Con) {
+        debug("invalid param");
+        return -1;
+    }
+    return Con->Last_errno;
+}
+
+e_ConnectErrorType SocketsCon_GetErrorCode(struct SocketCon *Con) {
+    if (!Con) {
+        debug("invalid param");
+        return e_ConnectErrorMAX;
+    }
+    return Con->ErrorCode;
+}
+
+bool SocketsCon_GetSocketHandle(struct SocketCon *Con,
+                                t_ConSocketHandle *RetHandle) {
+    if (!Con) {
+        debug("invalid param");
+        return false;
+    }
+
+    if (Con->SocketFD < 0) {
+        return false;
+    }
+
+    *RetHandle = Con->SocketFD;
+    return true;
+}

src/log.c

 #include "log.h"
 
 static uint8_t log_buff[4096] = {0};
-static struct ring_buffer log = RB_INIT(log_buff, sizeof(log_buff));
+static struct ring_buffer log = RB_INIT(log_buff, sizeof(log_buff), 1);
 
 static uint8_t line_buff[256] = {0};
 static volatile bool got_input = false;
 static FIL log_file_fat;
 
-static void add_to_log(const uint8_t *buff, size_t len) {
+static void add_to_log(const void *buff, size_t len) {
     rb_add(&log, buff, len);
 }
 
-static void log_dump_to_x(void (*write)(const uint8_t *, size_t)) {
+static void log_dump_to_x(void (*write)(const void *, size_t)) {
     if (rb_len(&log) == 0) {
         return;
     }
 #endif
 }
 
-static void log_file_write_callback(const uint8_t *data, size_t len) {
+static void log_file_write_callback(const void *data, size_t len) {
     UINT bw;
     FRESULT res = f_write(&log_file_fat, data, len, &bw);
     if ((res != FR_OK) || (bw != len)) {
     va_end(args);
 }
 
-void debug_handle_input(const uint8_t *buff, size_t len) {
+void debug_handle_input(const void *buff, size_t len) {
     (void)buff;
 
     if (len > 0) {

src/main.c

 #include "serial.h"
 #include "workflow.h"
 #include "wifi.h"
+#include "http.h"
+#include "main.h"
 
 void main_loop_hw(void) {
     watchdog_update();
         lcd_set_backlight(mem_data()->backlight);
     }
 
+    networking_run();
+}
+
+void networking_init(void) {
+    debug("wifi_init");
+    wifi_init();
+
+    debug("http_init");
+    http_init();
+}
+
+void networking_deinit(void) {
+    debug("http_deinit");
+    http_deinit();
+
+    debug("wifi_deinit");
+    wifi_deinit();
+}
+
+void networking_run(void) {
+    http_run();
     wifi_run();
 }
 
     }
 
     if (mem_data()->enable_wifi) {
-        debug("wifi_init");
-        wifi_init();
+        debug("networking_init");
+        networking_init();
     } else {
         debug("wifi not enabled");
     }

src/ring.c

  * See <http://www.gnu.org/licenses/>.
  */
 
+#include <string.h>
+
 #include "config.h"
 #include "ring.h"
 
-void rb_add(struct ring_buffer *rb, const uint8_t *data, size_t length) {
+void rb_add(struct ring_buffer *rb, const void *data, size_t length) {
     for (size_t i = 0; i < length; i++) {
-        rb->buffer[rb->head] = data[i];
+        memcpy(rb->buffer + rb->head * rb->el_len, data + i * rb->el_len, rb->el_len);
 
         if (rb->full && (++(rb->tail) == rb->size)) {
             rb->tail = 0;
     }
 }
 
-void rb_dump(struct ring_buffer *rb, void (*write)(const uint8_t *, size_t)) {
+void rb_dump(struct ring_buffer *rb, void (*write)(const void *, size_t)) {
     if (rb_len(rb) == 0) {
         return;
     }
 
     if (rb->head > rb->tail) {
-        write(rb->buffer + rb->tail, rb->head - rb->tail);
+        write(rb->buffer + rb->tail * rb->el_len, rb->head - rb->tail);
     } else {
-        write(rb->buffer + rb->tail, rb->size - rb->tail);
+        write(rb->buffer + rb->tail * rb->el_len, rb->size - rb->tail);
         write(rb->buffer, rb->head);
     }
 }
 
-void rb_move(struct ring_buffer *rb, void (*write)(const uint8_t *, size_t)) {
+void rb_move(struct ring_buffer *rb, void (*write)(const void *, size_t)) {
     rb_dump(rb, write);
     rb->head = 0;
     rb->tail = 0;
     rb->full = false;
 }
 
-uint8_t rb_peek(struct ring_buffer *rb) {
+void rb_peek(struct ring_buffer *rb, void *buf) {
     if (rb_len(rb) == 0) {
-        return 0;
+        return;
     }
 
-    uint8_t v = rb->buffer[rb->tail];
-    return v;
+    memcpy(buf, rb->buffer + rb->tail * rb->el_len, rb->el_len);
 }
 
-uint8_t rb_pop(struct ring_buffer *rb) {
+void rb_pop(struct ring_buffer *rb, void *buf) {
     if (rb_len(rb) == 0) {
-        return 0;
+        return;
     }
 
-    uint8_t v = rb->buffer[rb->tail++];
+    memcpy(buf, rb->buffer + rb->tail * rb->el_len, rb->el_len);
+    rb->tail++;
     if (rb->tail >= rb->size) {
         rb->tail = 0;
     }
+}
 
-    return v;
+size_t rb_get(struct ring_buffer *rb, void *data, size_t length) {
+    size_t count = 0;
+    while ((length > 0) && (rb_len(rb) > 0)) {
+        rb_pop(rb, data + count * rb->el_len);
+        count++;
+        length--;
+    }
+    return count;
 }

src/serial.c

 #include "serial.h"
 
 static uint8_t rx_buff[UART_RX_BUFF_LEN] = {0};
-static struct ring_buffer rx = RB_INIT(rx_buff, sizeof(rx_buff));
+static struct ring_buffer rx = RB_INIT(rx_buff, sizeof(rx_buff), 1);
 
 static uint8_t tx_buff[UART_TX_BUFF_LEN] = {0};
-static struct ring_buffer tx = RB_INIT(tx_buff, sizeof(tx_buff));
+static struct ring_buffer tx = RB_INIT(tx_buff, sizeof(tx_buff), 1);
 
 static bool reroute_serial_debug = false;
 static bool tx_irq_state = false;
     // Rx - read from UART FIFO to local buffer
     while (uart_is_readable(UART_ID) && (rb_space(&rx) > 0)) {
         uint8_t ch = uart_getc(UART_ID);
-        rb_push(&rx, ch);
+        rb_push(&rx, &ch);
     }
 
     // Tx - write to UART FIFO if needed
     while (uart_is_writable(UART_ID)) {
         if (rb_len(&tx) > 0) {
-            uart_putc_raw(UART_ID, rb_pop(&tx));
+            uint8_t c;
+            rb_pop(&tx, &c);
+            uart_putc_raw(UART_ID, c);
         } else {
             SET_TX_IRQ(false);
             break;
     SET_TX_IRQ(false);
 }
 
-void serial_write(const uint8_t *buf, size_t count) {
+void serial_write(const void *buf, size_t count) {
     SET_TX_IRQ(false);
 
     while ((rb_len(&tx) == 0) && uart_is_writable(UART_ID) && (count > 0)) {
-        uart_putc_raw(UART_ID, *buf++);
+        uart_putc_raw(UART_ID, *(uint8_t *)buf);
+        buf++;
         count--;
     }
 
     SET_RX_IRQ(false);
 
     if (rb_len(&rx) >= 1) {
-        if (rb_peek(&rx) == ENTER_BOOTLOADER_MAGIC) {
+        uint8_t c;
+        rb_peek(&rx, &c);
+        if (c == ENTER_BOOTLOADER_MAGIC) {
             reset_to_bootloader();
         } else if (reroute_serial_debug) {
             rb_move(&rx, debug_handle_input);

src/state_settings.c

 
 #include "config.h"
 #include "log.h"
+#include "main.h"
 #include "menu.h"
 #include "mem.h"
 #include "state.h"
     // apply changed wifi state
     if (mem_data()->enable_wifi) {
         if (!wifi_initialized()) {
-            wifi_init();
+            networking_init();
         }
     } else {
         if (wifi_initialized()) {
-            wifi_deinit();
+            networking_deinit();
         }
     }
 }

src/state_string.c

     while (edit < offset) {
         offset -= 1;
     }
-    while (edit >= (offset + (LCD_WIDTH / 10 - 2))) {
+    while (edit >= (offset + (LCD_WIDTH / 10 - 3))) {
         offset += 1;
     }
 

src/state_venty.c

 static int8_t battery = 0;
 static int8_t eco_current = 0;
 static int8_t eco_voltage = 0;
+static int8_t vibration = 0;
+static int8_t brightness = 0;
 
 void state_venty_target(bd_addr_t addr, bd_addr_type_t type) {
     memcpy(ble_addr, addr, sizeof(bd_addr_t));
     connected = false;
 }
 
+static void exit_cb(void) {
+    debug("venty disconnect");
+    ble_disconnect();
+    wait_for_disconnect = true;
+}
+
 static void enter_cb(int selection) {
     switch (selection) {
     case 0:
+        // Battery
+        break;
+
+    case 1:
         // Target
         state_value_set(&target_temp,
                         sizeof(target_temp),
         state_switch(STATE_VALUE);
         break;
 
-    case 1:
+    case 2:
         // Heater
         state_value_set(&heater_state,
                         sizeof(heater_state),
         state_switch(STATE_VALUE);
         break;
 
-    case 2:
+    case 3:
         // Eco Current
         state_value_set(&eco_current,
                         sizeof(eco_current),
         state_switch(STATE_VALUE);
         break;
 
-    case 3:
+    case 4:
         // Eco Voltage
         state_value_set(&eco_voltage,
                         sizeof(eco_voltage),
         state_value_return(STATE_VENTY);
         state_switch(STATE_VALUE);
         break;
+
+    case 5:
+        // Vibration
+        state_value_set(&vibration,
+                        sizeof(vibration),
+                        0, 1, VAL_STEP_INCREMENT, 1,
+                        "Vibration");
+        state_value_return(STATE_VENTY);
+        state_switch(STATE_VALUE);
+        break;
+
+    case 6:
+        // Brightness
+        state_value_set(&brightness,
+                        sizeof(brightness),
+                        1, 9, VAL_STEP_INCREMENT, 1,
+                        "Brightness");
+        state_value_return(STATE_VENTY);
+        state_switch(STATE_VALUE);
+        break;
+
+    default:
+        exit_cb();
+        break;
     }
 }
 
     venty_set_eco_current(eco_current);
     sleep_ms(250);
     venty_set_eco_voltage(eco_voltage);
+    sleep_ms(250);
+    venty_set_vibration(vibration);
+    sleep_ms(250);
+    venty_set_brightness(brightness);
 }
 
-
 static void fetch_values(void) {
-    venty_set_heater_state(false);
-    heater_state = false;
-
+    heater_state = venty_get_heater_state();
     target_temp = venty_get_target_temp();
     battery = venty_get_battery_state();
     eco_current = venty_get_eco_current();
     eco_voltage = venty_get_eco_voltage();
-}
-
-static void exit_cb(void) {
-    debug("venty disconnect");
-    ble_disconnect();
-    wait_for_disconnect = true;
+    vibration = venty_get_vibration();
+    brightness = venty_get_brightness();
 }
 
 void state_venty_enter(void) {
     int pos = 0;
     menu->length = 0;
 
+    ADD_STATIC_ELEMENT("Battery: %d %%", battery);
     ADD_STATIC_ELEMENT("Target (%d C)", target_temp / 10);
     ADD_STATIC_ELEMENT("Heater (%d)", heater_state);
     ADD_STATIC_ELEMENT("Eco Amps (%d)", eco_current);
     ADD_STATIC_ELEMENT("Eco Volt (%d)", eco_voltage);
-    ADD_STATIC_ELEMENT("Battery: %d %%", battery);
+    ADD_STATIC_ELEMENT("Vibration (%d)", vibration);
+    ADD_STATIC_ELEMENT("Brightness (%d)", brightness);
+
+    ADD_STATIC_ELEMENT("... go back");
 
     if (menu->selection < 0) {
         menu->selection = 0;

src/usb_cdc.c

 
 static bool reroute_cdc_debug = false;
 
-void usb_cdc_write(const uint8_t *buf, size_t count) {
+void usb_cdc_write(const void *buf, size_t count) {
 #ifndef DISABLE_CDC_DTR_CHECK
     if (!tud_cdc_connected()) {
         return;

src/venty.c

 
 #define VENTY_READ_TIMEOUT_MS 500
 
+enum venty_commands {
+    CMD_SETTINGS  = 1,
+    CMD_INTERFACE = 6,
+};
+
 enum venty_values {
     MASK_SET_TEMPERATURE = 1 << 1,
     MASK_SET_BOOST       = 1 << 2,
     SETTING_BOOST_VISUALIZATION = 1 << 6,
 };
 
+enum venty_interface {
+    UI_BRIGHTNESS = 1 << 0,
+    UI_VIBRATION  = 1 << 3,
+};
+
 // "00000000-5354-4f52-5a26-4249434b454c"
 static uint8_t uuid_service[16] = {
     0x00, 0x00, 0x00, 0x00, 0x53, 0x54, 0x4f, 0x52,
     uint8_t cmd[20] = {0};
     uint8_t buff[20] = {0};
 
-    cmd[0] = 1;
+    cmd[0] = CMD_SETTINGS;
 
     int8_t r = venty_cmd(buff, sizeof(buff), cmd, sizeof(cmd));
     if (r < 0) {
     uint8_t cmd[20] = {0};
     uint8_t buff[20] = {0};
 
-    cmd[0] = 1;
+    cmd[0] = CMD_SETTINGS;
     cmd[1] = MASK_SET_TEMPERATURE;
     uint16_t *val = (uint16_t *)(cmd + 4);
     *val = value;
     return r;
 }
 
+int8_t venty_get_heater_state(void) {
+    uint8_t cmd[20] = {0};
+    uint8_t buff[20] = {0};
+
+    cmd[0] = CMD_SETTINGS;
+
+    int8_t r = venty_cmd(buff, sizeof(buff), cmd, sizeof(cmd));
+    if (r < 0) {
+        return r;
+    }
+
+    int8_t *val = (int8_t *)(buff + 11);
+    return *val;
+}
+
 int8_t venty_set_heater_state(bool value) {
     uint8_t cmd[20] = {0};
     uint8_t buff[20] = {0};
 
-    cmd[0] = 1;
+    cmd[0] = CMD_SETTINGS;
     cmd[1] = MASK_HEATER;
     cmd[11] = value ? 1 : 0;
 
     uint8_t cmd[20] = {0};
     uint8_t buff[20] = {0};
 
-    cmd[0] = 1;
+    cmd[0] = CMD_SETTINGS;
 
     int8_t r = venty_cmd(buff, sizeof(buff), cmd, sizeof(cmd));
     if (r < 0) {
     uint8_t cmd[20] = {0};
     uint8_t buff[20] = {0};
 
-    cmd[0] = 1;
+    cmd[0] = CMD_SETTINGS;
 
     int8_t r = venty_cmd(buff, sizeof(buff), cmd, sizeof(cmd));
     if (r < 0) {
     uint8_t cmd[20] = {0};
     uint8_t buff[20] = {0};
 
-    cmd[0] = 1;
+    cmd[0] = CMD_SETTINGS;
 
     int8_t r = venty_cmd(buff, sizeof(buff), cmd, sizeof(cmd));
     if (r < 0) {
     uint8_t cmd[20] = {0};
     uint8_t buff[20] = {0};
 
-    cmd[0] = 1;
+    cmd[0] = CMD_SETTINGS;
     cmd[1] = MASK_SETTINGS;
     cmd[14] = value ? SETTING_ECOMODE_CHARGE : 0;
     cmd[15] = SETTING_ECOMODE_CHARGE;
     uint8_t cmd[20] = {0};
     uint8_t buff[20] = {0};
 
-    cmd[0] = 1;
+    cmd[0] = CMD_SETTINGS;
     cmd[1] = MASK_SETTINGS;
     cmd[14] = value ? SETTING_ECOMODE_VOLTAGE : 0;
     cmd[15] = SETTING_ECOMODE_VOLTAGE;
     int8_t r = venty_cmd(buff, sizeof(buff), cmd, sizeof(cmd));
     return r;
 }
+
+int8_t venty_get_vibration(void) {
+    uint8_t cmd[6] = {0};
+    uint8_t buff[6] = {0};
+
+    cmd[0] = CMD_INTERFACE;
+
+    int8_t r = venty_cmd(buff, sizeof(buff), cmd, sizeof(cmd));
+    if (r < 0) {
+        return r;
+    }
+
+    int8_t *val = (int8_t *)(buff + 5);
+    return *val;
+}
+
+int8_t venty_get_brightness(void) {
+    uint8_t cmd[6] = {0};
+    uint8_t buff[6] = {0};
+
+    cmd[0] = CMD_INTERFACE;
+
+    int8_t r = venty_cmd(buff, sizeof(buff), cmd, sizeof(cmd));
+    if (r < 0) {
+        return r;
+    }
+
+    int8_t *val = (int8_t *)(buff + 2);
+    return *val;
+}
+
+int8_t venty_set_vibration(bool value) {
+    uint8_t cmd[6] = {0};
+    uint8_t buff[6] = {0};
+
+    cmd[0] = CMD_INTERFACE;
+    cmd[1] = UI_VIBRATION;
+    cmd[5] = value ? 1 : 0;
+
+    int8_t r = venty_cmd(buff, sizeof(buff), cmd, sizeof(cmd));
+    return r;
+}
+
+int8_t venty_set_brightness(uint8_t value) {
+    uint8_t cmd[6] = {0};
+    uint8_t buff[6] = {0};
+
+    cmd[0] = CMD_INTERFACE;
+    cmd[1] = UI_BRIGHTNESS;
+    cmd[2] = MIN(MAX(value, 1), 9);
+
+    int8_t r = venty_cmd(buff, sizeof(buff), cmd, sizeof(cmd));
+    return r;
+}

src/wifi.c

 /*
  * wifi.c
  *
- * https://github.com/raspberrypi/pico-examples/blob/master/adc/read_vsys/power_status.c
- *
  * Copyright (c) 2023 Thomas Buck (thomas@xythobuz.de)
  *
  * This program is free software: you can redistribute it and/or modify
         return "Connecting";
 
     case WS_READY:
-        return "Connected";
+        return ip4addr_ntoa(netif_ip4_addr(netif_default));
     }
 
     return NULL;