diff options
45 files changed, 1396 insertions, 61 deletions
@@ -1,2 +1,3 @@ build -.vscode/**
\ No newline at end of file +.vscode/** +.cache diff --git a/.gitmodules b/.gitmodules index c951407..1a813e0 100644 --- a/.gitmodules +++ b/.gitmodules @@ -1,10 +1,20 @@ -[submodule "main/lib/pico-sdk"] - path = main/lib/pico-sdk +[submodule "pico-sdk"] + path = lib/pico-sdk url = https://github.com/raspberrypi/pico-sdk branch = 1.5.1 shallow = true -[submodule "test/lib/googletest"] - path = test/lib/googletest +[submodule "googletest"] + path = lib/googletest url = https://github.com/google/googletest branch = v1.14.0 shallow = true +[submodule "FreeRTOS-Kernel"] + path = lib/FreeRTOS-Kernel + url = https://github.com/FreeRTOS/FreeRTOS-Kernel + branch = V11.1.0 + shallow = true +[submodule "lib/mpack"] + path = lib/mpack + url = https://github.com/ludocode/mpack + branch = v1.1.1 + shallow = true diff --git a/client/CMakeLists.txt b/client/CMakeLists.txt new file mode 100644 index 0000000..35a55b6 --- /dev/null +++ b/client/CMakeLists.txt @@ -0,0 +1,25 @@ +cmake_minimum_required(VERSION 3.29) + +set(CMAKE_C_STANDARD 11) +set(CMAKE_CXX_STANDARD 17) +set(CMAKE_EXPORT_COMPILE_COMMANDS 1) + +project(puzzlebox_client C CXX) + +include(../proto/include.cmake) + +add_executable(pbc + main.cpp + rl.cpp + sock.cpp + cmd.cpp + parse.cpp + ) + +target_link_libraries(pbc + puzbus + mpack + readline # this is such a common library that I did not bother adding it as a submodule + ) + + diff --git a/client/cmd.cpp b/client/cmd.cpp new file mode 100644 index 0000000..1ec2cb8 --- /dev/null +++ b/client/cmd.cpp @@ -0,0 +1,63 @@ +#include <cstdio> +#include <cstdlib> +#include <string.h> + +#include "cmd.h" +#include "sock.h" +#include "parse.h" + +char* consume_token(char* input, const char* ifs) { + strtok(input, ifs); + return strtok(NULL, "\0"); +} + +void cmd_exit(char*) { + exit(EXIT_SUCCESS); +} + +void cmd_test(char*) { + const char* data = "Hello world!"; + i2c_send(0x39, data, strlen(data)); +} + +void cmd_help(char*) { + printf("List of available commands:\n"); + for (size_t i = 0; i < cmds_length; i++) { + struct cmd cmd = cmds[i]; + printf(" %-*s", 10, cmd.name); + if (cmd.info != NULL) + printf(" %s", cmd.info); + printf("\n"); + } + + printf( + "\n" + "You can also use the TAB key to autocomplete commands\n" + ); +} + +void cmd_send(char* addr_str) { + char* data_str = consume_token(addr_str, IFS); + + char* end; + uint16_t addr = strtol(addr_str, &end, 0); + if (addr_str + strlen(addr_str) != end) { + printf("address format error\n"); + return; + } + + char* data; + size_t data_size; + int err = strtodata(data_str, &data, &data_size); + if (err <= 0) { + printf("data format error at index %d:\n%s\n%*s^\n", + -err, data_str, -err, ""); + return; + } + + // printf("(0x%02x) -> \"%.*s\"\n", addr, data_size, data); + i2c_send(addr, data, data_size); + + free(data); +} + diff --git a/client/cmd.h b/client/cmd.h new file mode 100644 index 0000000..9d20328 --- /dev/null +++ b/client/cmd.h @@ -0,0 +1,60 @@ +#pragma once + +#include <stddef.h> + +typedef void cmd_fn_t(char *); + +struct cmd { + void (* handle)(char *); + const char* name; + const char* info; + // TODO: tab completion function? +}; + +cmd_fn_t cmd_exit; +cmd_fn_t cmd_test; +cmd_fn_t cmd_help; +cmd_fn_t cmd_send; +cmd_fn_t cmd_status; +cmd_fn_t cmd_reset; +cmd_fn_t cmd_ls; + +static const struct cmd cmds[] = { + { + .handle = cmd_exit, + .name = "exit", + .info = "exit pbc", + }, + { + .handle = cmd_test, + .name = "test", + .info = "send a test puzbus message", + }, + { + .handle = cmd_help, + .name = "help", + .info = "show this help", + }, + { + .handle = cmd_send, + .name = "send", + .info = "[debug] send raw message", + }, + // { + // .handle = cmd_status, + // .name = "status", + // .info = "show global puzzle box state (main controller state)", + // }, + // { + // .handle = cmd_reset, + // .name = "reset", + // .info = "reset entire game state", + // }, + // { + // .handle = cmd_ls, + // .name = "ls", + // .info = "list connected puzzle modules", + // }, +}; +static const size_t cmds_length = sizeof(cmds) / sizeof(cmds[0]); + diff --git a/client/compile_commands.json b/client/compile_commands.json new file mode 120000 index 0000000..25eb4b2 --- /dev/null +++ b/client/compile_commands.json @@ -0,0 +1 @@ +build/compile_commands.json
\ No newline at end of file diff --git a/client/examples/puzbus-hello-world.cpp b/client/examples/puzbus-hello-world.cpp new file mode 100644 index 0000000..dcc965b --- /dev/null +++ b/client/examples/puzbus-hello-world.cpp @@ -0,0 +1,67 @@ +#include <cstdio> +#include <cstdlib> +#include <cstring> +#include <unistd.h> + +#include "puzbusv1.h" + +int send_message() { + const char* data = "Test message data!"; + struct pb_msg output = { + .addr = 0x39, + .data = (char*) data, + .length = strlen(data), + }; + + char* packed; + size_t size; + if (!pb_write(&output, &packed, &size)) { + printf("error writing!\n"); + return EXIT_FAILURE; + } + + fwrite(packed, sizeof(packed[0]), size, stdout); + fflush(stdout); + + return EXIT_SUCCESS; +} + +int read_message() { + freopen(NULL, "rb", stdin); // allow binary on stdin + struct pb_msg input; + + char buf[4]; // extremely small buffer to test chunked message parsing + size_t bytes = 0; + + while ((bytes = fread(buf, sizeof(buf[0]), sizeof(buf), stdin)) > 0) { + int ret = pb_read(&input, buf, bytes); + + // header read error + if (ret < 0) { + printf("error reading!\n"); + return EXIT_FAILURE; + } + + // continue reading if more bytes needed... + if (ret > 0) continue; + + // message read completely! + printf("address: 0x%02x\n", input.addr); + printf("data: \"%.*s\"\n", input.length, input.data); + free(input.data); + return EXIT_SUCCESS; + } + + // if we reach this point, data was read but it did not contain a complete + // message, and is thus considered a failure + return EXIT_FAILURE; +} + +int main() { + if (!isatty(fileno(stdout))) return send_message(); + if (!isatty(fileno(stdin))) return read_message(); + + printf("please pipe some data in or out to use this program\n"); + return EXIT_SUCCESS; +} + diff --git a/client/lib b/client/lib new file mode 120000 index 0000000..dc598c5 --- /dev/null +++ b/client/lib @@ -0,0 +1 @@ +../lib
\ No newline at end of file diff --git a/client/main.cpp b/client/main.cpp new file mode 100644 index 0000000..5c26107 --- /dev/null +++ b/client/main.cpp @@ -0,0 +1,38 @@ +#include <cstdio> +#include <cstdlib> +#include <cstdint> +#include <exception> + +#include "rl.h" +#include "sock.h" + +PBSocket* sock; + +int main(int argc, char** argv) { + if (argc < 2) { + printf("usage: %s addr [port]\n", argv[0]); + return EXIT_FAILURE; + } + + // parse arguments + char* addr = argv[1]; + uint16_t port = 9191; + if (argc >= 3) port = atoi(argv[2]); + + sock = new PBSocket(addr, port); + try { + // connect to TCP socket (automatically spawns thread) + sock->sock_connect(); + } catch (const std::exception& e) { + printf("error: %s\n", e.what()); + return EXIT_FAILURE; + } + + // enter main CLI (using GNU readline for comfyness) + int ret = cli_main(); + + delete sock; + + return ret; +} + diff --git a/client/makefile b/client/makefile new file mode 100644 index 0000000..8352615 --- /dev/null +++ b/client/makefile @@ -0,0 +1,2 @@ +include ../lazy.mk + diff --git a/client/parse.cpp b/client/parse.cpp new file mode 100644 index 0000000..223dc5d --- /dev/null +++ b/client/parse.cpp @@ -0,0 +1,117 @@ +#include <math.h> +#include <stdlib.h> +#include <string.h> +#include <stdio.h> + +#include "parse.h" + +static int parse_str(const char* str, char* data, size_t* size) { + char closing = str[0]; + char escape = false; + bool scan = data == NULL; + int i = 0; + size_t len = strlen(str); + + switch (str[i]) { + case '\'': + escape = false; + break; + case '\"': + escape = true; + break; + default: + return -i; + } + + for (i = 1; i < len && str[i] != '\0'; i++) { + char c = str[i]; + + if (c == closing) { + if (scan) printf("string%s of length %d\n", escape ? " (w/ escape)" : "", i - 1); + return i + 1; // +1 for closing quote + } + + if (scan) *size += 1; + } + + return -i; +} + +static int parse_num(const char* str, char* data, size_t* size) { + const char* ifs = IFS; + size_t len = strcspn(str, ifs); + bool scan = data == NULL; + int i = 0; + int base = 10; + bool bytestring = false; + + const char* colon = strchr(str, ':'); + if (colon != NULL && colon < str + len) { // byte string + base = 16; + bytestring = true; + } else if (len > 2 && strncmp(str, "0x", 2) == 0) { // hexadecimal prefix + base = 16; + i += 2; + }/* else if (len > 1 && strncmp(str, "0", 1) == 0) { // octal prefix + base = 8; + i += 1; + }*/ + + const char* set; + // if (base == 8) set = SET_OCT; + if (base == 10) set = SET_DEC; + if (base == 16) { + if (bytestring) set = SET_HEX_STR; + else set = SET_HEX; + } + + size_t len_ok = strspn(str + i, set) + i; + if (len != len_ok) return -len_ok; + + if (scan) { + if (base == 10) *size += 1; + else if (base == 16) { + if (!bytestring) { + *size += (len - i + 1) / 2; + } else { + for (; colon != NULL && colon < str + len; colon = strchr(str, ':')) { + *size += 1; + } + } + } + } + + if (scan) printf("number (base %d%s) of length %lu\n", base, bytestring ? " as bytestring" : "", len - i); + return len; +} + +int strtodata(const char* str, char** data, size_t* size) { + const char* ifs = IFS; + *size = 0; + size_t i; + size_t len = strlen(str); + + for (i = 0; i < len;) { + // skip whitespace + int run; + run = strspn(&str[i], ifs); + if (run > 0) printf("skipping whitespace for %d bytes...\n", run); + i += run; + // end of string + if (str[i] == '\0') break; + + if ((run = parse_str(str + i, NULL, size)) > 0) { i += run; continue; } + if ((run = parse_num(str + i, NULL, size)) > 0) { i += run; continue; } + + // no format detected + return -i + run; + } + printf("end of string w/o parse errors\n"); + printf("buffer size is now %lu\n", *size); + exit(0); + + *data = (char*) malloc(*size); + + return 0; +} + diff --git a/client/parse.h b/client/parse.h new file mode 100644 index 0000000..10274e7 --- /dev/null +++ b/client/parse.h @@ -0,0 +1,42 @@ +#pragma once + +#include <stddef.h> + +#define IFS " \t\n" + +#define SET_OCT "01234567" +#define SET_DEC "0123456789" +#define SET_HEX SET_DEC"abcdefABCDEF" +#define SET_HEX_STR SET_HEX":" + +/** + * \brief modify \p token to point to the first token when broken up on \p ifs + * and return the remaining data + * + * \p token will be null-terminated to indicate the end of the first token. A + * pointer to the remaining line after the NULL byte is returned, or NULL when + * the end of the string has been reached. + * + * \param token input string + * \param ifs string containing field separators + * + * \return the remaining data after \p token and the first \p ifs + */ +char* consume_token(char* token, const char* ifs); + +/** + * \brief convert string with literals into raw data + * + * \param str input string containing literals + * \param data pointer to \c char* that will store the resulting data + * \param size size of \p data + * + * \return 0 or a negative integer representing the index where there is a + * syntax error if there was an error, or a positive integer representing the + * amount of bytes parsed from \p str + * + * \note The pointer that \p data refers to will not be initialized by this + * function if parsing fails + */ +int strtodata(const char* str, char** data, size_t* size); + diff --git a/client/pbc b/client/pbc new file mode 120000 index 0000000..51eda50 --- /dev/null +++ b/client/pbc @@ -0,0 +1 @@ +build/pbc
\ No newline at end of file diff --git a/client/readme.md b/client/readme.md new file mode 100644 index 0000000..04471d2 --- /dev/null +++ b/client/readme.md @@ -0,0 +1,21 @@ +# puzzle box client + +goal (in order of implementation): +``` +(pbc) help + exit exit pbc + test send a test puzbus message + help show this help + send <addr> <data> [debug] send raw message + status show global puzzle box state (main controller state) + reset reset entire game state + ls list connected puzzle modules +``` + + +``` +send 0x39 "Hello world!" de:ad:be:ef 0xff 5 0a 0750 + ^~~~~~~~~~~~~~ ^~~~~~~~~~~ ~^~~ ~^ ~^ ~~~~^ + STR_INTP BYTE_ARR UNSIGNED UNSIGNED UNSIGNED UNSIGNED + (hex+0x) (dec) (hex) (oct) +``` diff --git a/client/rl.cpp b/client/rl.cpp new file mode 100644 index 0000000..3f93e99 --- /dev/null +++ b/client/rl.cpp @@ -0,0 +1,86 @@ +#include <stdlib.h> +#include <stdio.h> +#include <stdbool.h> +#include <stdarg.h> + +#include <readline/readline.h> +#include <readline/history.h> + +#include "rl.h" +#include "cmd.h" +#include "parse.h" + +void rl_printf(const char *fmt, ...) { + // save line + char* saved_line = rl_copy_text(0, rl_end); + int saved_point = rl_point; + int saved_end = rl_end; + + // clear line + rl_save_prompt(); + rl_replace_line("", 0); + rl_redisplay(); + + // printf + va_list args; + va_start(args, fmt); + vprintf(fmt, args); + va_end(args); + + // restore line + rl_restore_prompt(); + rl_replace_line(saved_line, 0); + rl_point = saved_point; + rl_end = saved_end; + rl_redisplay(); + + free(saved_line); +} + +static void cli_cmd(char* cmd) { + char* line = consume_token(cmd, IFS); + + for (size_t i = 0; i < cmds_length; i++) { + if (strncmp(cmds[i].name, cmd, strlen(cmd)) != 0) + continue; + + cmds[i].handle(line); + return; + } + + printf("unknown command!\n"); +} + +static char* rl_completion_entries(const char *text, int state) { + static size_t i = 0; + if (state == 0) i = 0; + + while (i < cmds_length) { + struct cmd cmd = cmds[i]; + i++; + if (strncmp(text, cmd.name, strlen(text)) == 0) { + return strdup(cmd.name); + } + } + + return NULL; +} + +int cli_main() { + char* input = NULL; + rl_completion_entry_function = rl_completion_entries; + + while (1) { + if (input != NULL) free(input); + input = readline(CLI_PROMPT); + + if (input == NULL) return EXIT_SUCCESS; // exit on ^D (EOF) + if (*input == '\0') continue; // ignore empty lines + add_history(input); + + cli_cmd(input); + } + + return EXIT_SUCCESS; +} + diff --git a/client/rl.h b/client/rl.h new file mode 100644 index 0000000..503225f --- /dev/null +++ b/client/rl.h @@ -0,0 +1,10 @@ +#pragma once + +#define COLOR_OFF "\x1b[0m" +#define COLOR_BOLD "\x1b[1m" + +#define CLI_PROMPT "(" COLOR_BOLD "pbc" COLOR_OFF ") " + +int cli_main(); +void rl_printf(const char *fmt, ...); + diff --git a/client/sock.cpp b/client/sock.cpp new file mode 100644 index 0000000..f967f64 --- /dev/null +++ b/client/sock.cpp @@ -0,0 +1,125 @@ +#include <arpa/inet.h> +#include <cstring> +#include <stdexcept> +#include <unistd.h> +#include <cstdio> +#include <sys/types.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <errno.h> + +#include <thread> + +#include "puzbusv1.h" +#include "sock.h" +#include "rl.h" + +using std::logic_error; +using std::thread; + +PBSocket::PBSocket() { } +PBSocket::PBSocket(const char * addr, uint16_t port) : PBSocket() { + set_server(addr, port); +} + +PBSocket::~PBSocket() { + // stop TCP listen thread + if (_thread != nullptr) { + _thread->detach(); + delete _thread; + } + + sock_close(); +} + +void PBSocket::set_server(const char * addr, uint16_t port) { + _addr = addr; + _port = port; +} + +void PBSocket::sock_connect() { + if (_addr == NULL) throw logic_error("no server address defined"); + if (_port == 0) throw logic_error("no server port defined"); + + if (_thread != nullptr) throw logic_error("already connected"); + + rl_printf("connecting to %s on port %d...\n", _addr, _port); + + _fd = socket(AF_INET, SOCK_STREAM, 0); + if (_fd < 0) throw logic_error("socket create failed"); + + struct sockaddr_in server = { + .sin_family = AF_INET, + .sin_port = htons(_port), + .sin_addr = { + .s_addr = inet_addr(_addr), + }, + }; + int ret = connect(_fd, (struct sockaddr*) &server, sizeof(server)); + if (ret != 0) throw logic_error(strerror(errno)); + + this->_thread = new thread(&PBSocket::sock_task, this); +} + +void PBSocket::sock_close() { + if (_fd < 0) return; // already closed + close(_fd); + _fd = -1; +} + +void PBSocket::send(const char * buf, size_t buf_sz) { + write(_fd, buf, buf_sz); +} + +void PBSocket::sock_task() { + struct pb_msg input; + + while(1) { + char buf[80]; + ssize_t bytes = read(_fd, buf, sizeof(buf)); + + if (bytes == -1) { + rl_printf("error: %s (%d)\n", strerror(errno), errno); + break; + } + + // skip empty frames + if (bytes == 0) continue; + + int ret = pb_read(&input, buf, bytes); + + // header read error + if (ret < 0) { + rl_printf("pb_read error!\n"); + break; + } + + // continue reading if more bytes needed... + if (ret > 0) continue; + + // message read completely! + i2c_recv(input.addr, input.data, input.length); + free(input.data); + } + + sock_close(); +} + +void i2c_send(uint16_t addr, const char * data, size_t data_size) { + struct pb_msg msg = { + .addr = addr, + .data = (char *) data, + .length = data_size, + }; + + char* packed; + size_t size; + if (!pb_write(&msg, &packed, &size)) return; + + sock->send(packed, size); +} + +void i2c_recv(uint16_t addr, const char * data, size_t data_size) { + rl_printf("[0x%02x]: %.*s\n", addr, data_size, data); +} + diff --git a/client/sock.h b/client/sock.h new file mode 100644 index 0000000..42eba3b --- /dev/null +++ b/client/sock.h @@ -0,0 +1,34 @@ +#pragma once + +#include <cstdint> +#include <thread> + +class PBSocket { +public: + PBSocket(); + PBSocket(const char * addr, uint16_t port); + virtual ~PBSocket(); + + void set_server(const char * addr, uint16_t port); + + void sock_connect(); + + void send(const char * buf, size_t buf_sz); + +private: + void sock_task(); + void sock_close(); + + std::thread* _thread = nullptr; + + const char * _addr = NULL; + uint16_t _port = 0; + + int _fd = -1; +}; + +extern PBSocket* sock; + +void i2c_send(uint16_t addr, const char * data, size_t data_size); +void i2c_recv(uint16_t addr, const char * data, size_t data_size); + @@ -0,0 +1,20 @@ +# this file is for lazy people (loek) + +BUILD_DIR ?= build +TARGET ?= $(BUILD_DIR)/main + +.PHONY: FORCE + +all: FORCE $(TARGET) + +$(BUILD_DIR)/build.ninja: CMakeLists.txt + mkdir -p $(BUILD_DIR) + cmake -B $(BUILD_DIR) -G Ninja --fresh --log-level WARNING + +$(TARGET): $(BUILD_DIR)/build.ninja FORCE + ninja -C $(BUILD_DIR) +# ninja automatically builds in parallel, so is preferred + +clean: FORCE + $(RM) -r $(BUILD_DIR) + diff --git a/lib/FreeRTOS-Kernel b/lib/FreeRTOS-Kernel new file mode 160000 +Subproject dbf70559b27d39c1fdb68dfb9a32140b6a6777a diff --git a/test/lib/googletest b/lib/googletest -Subproject 5197b1a8e6a1ef9f214f4aa537b0be17cbf9194 +Subproject 5197b1a8e6a1ef9f214f4aa537b0be17cbf9194 diff --git a/lib/mpack b/lib/mpack new file mode 160000 +Subproject 79d3fcd3e04338b06e82d01a62f4aa98c7bad5f diff --git a/main/lib/pico-sdk b/lib/pico-sdk -Subproject 6a7db34ff63345a7badec79ebea3aaef1712f37 +Subproject 6a7db34ff63345a7badec79ebea3aaef1712f37 diff --git a/main/.gitignore b/main/.gitignore index 7c3ba25..0e56cf2 100644 --- a/main/.gitignore +++ b/main/.gitignore @@ -1,3 +1 @@ config.h -build -.cache diff --git a/main/CMakeLists.txt b/main/CMakeLists.txt index e24d9a5..30685a4 100644 --- a/main/CMakeLists.txt +++ b/main/CMakeLists.txt @@ -1,22 +1,39 @@ cmake_minimum_required(VERSION 3.29) -include(lib/pico-sdk/pico_sdk_init.cmake) - -project(puzzlebox_main C CXX ASM) - set(CMAKE_C_STANDARD 11) set(CMAKE_CXX_STANDARD 17) set(CMAKE_EXPORT_COMPILE_COMMANDS 1) set(PICO_BOARD pico_w) +include(lib/pico-sdk/pico_sdk_init.cmake) +include(lib/FreeRTOS-Kernel/portable/ThirdParty/GCC/RP2040/FreeRTOS_Kernel_import.cmake) +include(../proto/include.cmake) + +project(puzzlebox_main C CXX ASM) + pico_sdk_init() add_executable(main - main.cpp -) + main.c + init.c + sock.c + i2c.c + ) pico_enable_stdio_usb(main 1) -# pico_enable_stdio_uart(main 1) +pico_enable_stdio_uart(main 0) pico_add_extra_outputs(main) + +include_directories(lib/pico-sdk/lib/lwip/contrib/ports/freertos/include) + target_include_directories(main PRIVATE ${CMAKE_CURRENT_LIST_DIR}) -target_link_libraries(main pico_cyw43_arch_lwip_threadsafe_background pico_stdlib) +target_link_libraries(main + pico_cyw43_arch_lwip_sys_freertos + pico_stdlib + hardware_i2c + FreeRTOS-Kernel + FreeRTOS-Kernel-Heap4 + puzbus + mpack + ) + diff --git a/main/FreeRTOSConfig.h b/main/FreeRTOSConfig.h new file mode 100644 index 0000000..c811296 --- /dev/null +++ b/main/FreeRTOSConfig.h @@ -0,0 +1,69 @@ +#pragma once +// values from pico-examples/pico_w/wifi/freertos + +#define configUSE_PREEMPTION 1 +#define configUSE_TICKLESS_IDLE 0 +#define configUSE_IDLE_HOOK 0 +#define configUSE_TICK_HOOK 0 +#define configTICK_RATE_HZ ((TickType_t) 1000) +#define configMAX_PRIORITIES 32 +#define configMINIMAL_STACK_SIZE ((configSTACK_DEPTH_TYPE) 512) +#define configUSE_16_BIT_TICKS 0 +#define configIDLE_SHOULD_YIELD 1 +#define configUSE_MUTEXES 1 +#define configUSE_RECURSIVE_MUTEXES 1 +#define configUSE_APPLICATION_TASK_TAG 0 +#define configUSE_COUNTING_SEMAPHORES 1 +#define configQUEUE_REGISTRY_SIZE 8 +#define configUSE_QUEUE_SETS 1 +#define configUSE_TIME_SLICING 1 +#define configUSE_NEWLIB_REENTRANT 0 +#define configENABLE_BACKWARD_COMPATIBILITY 1 +#define configNUM_THREAD_LOCAL_STORAGE_POINTERS 5 +#define configSTACK_DEPTH_TYPE uint32_t +#define configMESSAGE_BUFFER_LENGTH_TYPE size_t +#define configSUPPORT_STATIC_ALLOCATION 0 +#define configSUPPORT_DYNAMIC_ALLOCATION 1 +#define configTOTAL_HEAP_SIZE (128 * 1024) +#define configAPPLICATION_ALLOCATED_HEAP 0 +#define configCHECK_FOR_STACK_OVERFLOW 0 +#define configUSE_MALLOC_FAILED_HOOK 0 +#define configUSE_DAEMON_TASK_STARTUP_HOOK 0 +#define configGENERATE_RUN_TIME_STATS 0 +#define configUSE_TRACE_FACILITY 1 +#define configUSE_STATS_FORMATTING_FUNCTIONS 0 +#define configUSE_CO_ROUTINES 0 +#define configMAX_CO_ROUTINE_PRIORITIES 1 +#define configUSE_TIMERS 1 +#define configTIMER_TASK_PRIORITY (configMAX_PRIORITIES - 1) +#define configTIMER_QUEUE_LENGTH 10 +#define configTIMER_TASK_STACK_DEPTH 1024 + +// #define configNUM_CORES 2 +// #define configTICK_CORE 0 +// #define configRUN_MULTIPLE_PRIORITIES 1 +// #define configUSE_CORE_AFFINITY 1 + +#define configSUPPORT_PICO_SYNC_INTEROP 1 +#define configSUPPORT_PICO_TIME_INTEROP 1 + +#include <assert.h> +#define configASSERT(x) assert(x) + +#define INCLUDE_vTaskPrioritySet 1 +#define INCLUDE_uxTaskPriorityGet 1 +#define INCLUDE_vTaskDelete 1 +#define INCLUDE_vTaskSuspend 1 +#define INCLUDE_vTaskDelayUntil 1 +#define INCLUDE_vTaskDelay 1 +#define INCLUDE_xTaskGetSchedulerState 1 +#define INCLUDE_xTaskGetCurrentTaskHandle 1 +#define INCLUDE_uxTaskGetStackHighWaterMark 1 +#define INCLUDE_xTaskGetIdleTaskHandle 1 +#define INCLUDE_eTaskGetState 1 +#define INCLUDE_xTimerPendFunctionCall 1 +#define INCLUDE_xTaskAbortDelay 1 +#define INCLUDE_xTaskGetHandle 1 +#define INCLUDE_xTaskResumeFromISR 1 +#define INCLUDE_xQueueGetMutexHolder 1 + diff --git a/main/config.def.h b/main/config.def.h index 48de559..7fcaed9 100644 --- a/main/config.def.h +++ b/main/config.def.h @@ -1,8 +1,17 @@ #pragma once +#include <pico/cyw43_arch.h> +// wifi credentials #define CONF_NET_SSID "network name" #define CONF_NET_PASS "network password" +#define CONF_NET_AUTH CYW43_AUTH_WPA2_AES_PSK +// max duration (milliseconds) for establishing wifi connection +#define CONF_NET_CONN_TIMEOUT 10e3 -#include "cyw43_country.h" +#include <cyw43_country.h> #define CONF_NET_COUNTRY CYW43_COUNTRY_NETHERLANDS +#define CONF_SRV_PORT 9191 + +#define LED_PIN CYW43_WL_GPIO_LED_PIN + diff --git a/main/i2c.c b/main/i2c.c new file mode 100644 index 0000000..b324124 --- /dev/null +++ b/main/i2c.c @@ -0,0 +1,93 @@ +#include "i2c.h" +#include "init.h" + +#include <stdio.h> +#include <stddef.h> +#include <stdint.h> +#include <pico/stdlib.h> +#include <hardware/i2c.h> + +void init_i2c() { + i2c_init(I2C_PORT, 100 * 1000); // currently at 100kHz + + // Initialize I2C pins - sda(16), scl(17) + gpio_set_function(SDA_PIN, GPIO_FUNC_I2C); + gpio_set_function(SCL_PIN, GPIO_FUNC_I2C); + + gpio_pull_up(SDA_PIN); + gpio_pull_up(SCL_PIN); +} + +int read_i2c(uint8_t addr, uint8_t *output, size_t len) { + // false - finished with bus + return i2c_read_blocking (I2C_PORT, addr, output, len, false); +} + +int write_i2c(uint8_t addr, uint8_t *input, size_t len) { + // true to keep master control of bus + return i2c_write_blocking (I2C_PORT, addr, input, len, true); +} + +bool reserved_addr(uint8_t addr) { + return (addr & 0x78) == 0 || (addr & 0x78) == 0x78; +} + +void init_addr_array(uint8_t array[], int size) { + for(int i = 0; i < size; i++){ + array[i] = 0x00; + } +} + +uint8_t* scan_bus(uint8_t *array) { + int ret; + int i = 0; + uint8_t rxdata; + + for(int addr = 0; addr < (1<<7); addr++) { + // ignore reserved addresses + // These are any addresses of the form 000 0xxx or 111 1xxx + if( reserved_addr(addr) ){ + ret = PICO_ERROR_GENERIC; + }else{ + ret = i2c_read_blocking(I2C_PORT, addr, &rxdata, 1, false); + } + + // if acknowledged -> ret == number of bytes sent + if(ret > 0){ + printf("found i2c slave on addr: %d\n", addr); + array[i] = addr; + i++; + } + } + + return array; +} + +void bus_task() { + // scan bus for slaves + // send updates at regular intervals + await_init(); + + int i = 0; + uint8_t found[MAX_SLAVES]; + init_addr_array(found, MAX_SLAVES); + + while(1) { + // printf("Bus scan!"); + scan_bus(found); + + for(int i = 0; i < MAX_SLAVES; i++){ + if( found[i] == 0x00 ) + break; + + uint8_t data = 0x01; + // send data to found slave address + write_i2c(found[i], &data, 1); + + data = 0x02; + write_i2c(found[i], &data, 1); + // request update from slave addr at found[i] + //write_i2c(); + } + } +} diff --git a/main/i2c.h b/main/i2c.h new file mode 100644 index 0000000..5ad5cfb --- /dev/null +++ b/main/i2c.h @@ -0,0 +1,44 @@ +#pragma once +// https://github.com/raspberrypi/pico-examples/tree/master/i2c + +#include <stddef.h> +#include <stdint.h> +#include <hardware/i2c.h> + +#define SDA_PIN 16 +#define SCL_PIN 17 +#define I2C_PORT i2c0 +#define MAX_SLAVES 10 + +/** + * \brief initialize all required gpio for i2c usage on the pico + * + * This functions only initializes the standard gpio required to start i2c + * communications. + * + * \note Tasks shouldn't depend on any other module in the main controller + */ +void init_i2c(); + +/** + * \brief read data from addr with length len from i2c bus. + * + * This functions reads data from a specific address on the i2c bus, + * the output var will hold the data which was read from said address with + * length len. + */ +int read_i2c(uint8_t addr, uint8_t *output, size_t len); + +/** + * \brief write data to addr with length len from i2c bus. + * \param addr + * \param input + * \param len + * This functions writes data to a specific address on the i2c bus, + * the input var holds the data which will be written to the given + * address with length len. + */ +int write_i2c(uint8_t addr, uint8_t *input, size_t len); + +/** \brief looking for slave addresses and requesting updates */ +void bus_task(); diff --git a/main/init.c b/main/init.c new file mode 100644 index 0000000..08177c7 --- /dev/null +++ b/main/init.c @@ -0,0 +1,59 @@ +#include "config.h" +#include "init.h" +#include "i2c.h" + +#include <FreeRTOS.h> +#include <task.h> +#include <event_groups.h> + +#include <pico/stdio.h> +#include <pico/cyw43_arch.h> + +EventGroupHandle_t init_complete; + +static void init_stdio() { + stdio_init_all(); +} + +static void init_cyw34() { + if (cyw43_arch_init_with_country(CONF_NET_COUNTRY)) + panic("cyw43_arch_init_with_country failed\n"); +} + +static void init_wifi() { + // enable 'station' mode (connect to an access point instead of acting like one) + cyw43_arch_enable_sta_mode(); + + // if (cyw43_arch_wifi_connect_timeout_ms(CONF_NET_SSID, CONF_NET_PASS, CONF_NET_AUTH, CONF_NET_CONN_TIMEOUT)) + // panic("cyw43_arch_wifi_connect failed\n"); + + printf("connected to Wi-Fi\n"); + + // TODO: announce hostname(?) +} + +static void async_init() { + init_cyw34(); + init_i2c(); + init_wifi(); + + xEventGroupSetBits(init_complete, 1); + + // delete self + vTaskDelete(NULL); +} + +void init() { + init_complete = xEventGroupCreate(); + + // used for debug `printf` and `panic` on errors + init_stdio(); + + // defer other initialization until the task scheduler is running (important) + xTaskCreate((TaskFunction_t) async_init, "init", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY + 4, NULL); +} + +void await_init() { + xEventGroupWaitBits(init_complete, 1, pdFALSE, pdFALSE, portMAX_DELAY); +} + diff --git a/main/init.h b/main/init.h new file mode 100644 index 0000000..de9023c --- /dev/null +++ b/main/init.h @@ -0,0 +1,38 @@ +#pragma once + +#include <FreeRTOS.h> +#include <event_groups.h> + +/** + * \brief init function complete event group handle + * + * This is required to make sure the main task waits until initialization is + * complete. Due to the combination of FreeRTOS + lwIP, the initialization + * should be done while the task scheduler is running. Specifically the + * cyw43_arch_init functions make the pico hang indefinitely when used while + * the task scheduler is not running. + * + * \note `init_complete` only utilizes LSB, so `uxBitsToWaitFor` should always + * be set to *1* + */ +extern EventGroupHandle_t init_complete; + +/** + * \brief initialize all peripherals on the pico + * + * This function only synchronously initializes the standard input/output (used + * for `printf` and `panic`), and queues all other types of initialization in + * the `init` task using FreeRTOS. + * + * \note Tasks dependent on the wifi being initialized should use the + * `init_complete` event group to wait for initialization to complete! + */ +void init(); + +/** + * \brief block task until all initialization is complete + * + * utility function, see above comments + */ +void await_init(); + diff --git a/main/lib b/main/lib new file mode 120000 index 0000000..dc598c5 --- /dev/null +++ b/main/lib @@ -0,0 +1 @@ +../lib
\ No newline at end of file diff --git a/main/lwipopts.h b/main/lwipopts.h index 75a57ee..b2b6e76 100644 --- a/main/lwipopts.h +++ b/main/lwipopts.h @@ -1,13 +1,7 @@ #pragma once -// allow override in some examples -#ifndef NO_SYS -#define NO_SYS 1 -#endif - -#ifndef LWIP_SOCKET -#define LWIP_SOCKET 0 -#endif +#define NO_SYS 0 +#define LWIP_SOCKET 1 #if PICO_CYW43_ARCH_POLL #define MEM_LIBC_MALLOC 1 @@ -83,3 +77,16 @@ #define SLIP_DEBUG LWIP_DBG_OFF #define DHCP_DEBUG LWIP_DBG_OFF +#define TCPIP_THREAD_STACKSIZE 2048 +#define DEFAULT_THREAD_STACKSIZE 1024 +#define DEFAULT_RAW_RECVMBOX_SIZE 8 +#define TCPIP_MBOX_SIZE 8 + +#define DEFAULT_UDP_RECVMBOX_SIZE TCPIP_MBOX_SIZE +#define DEFAULT_TCP_RECVMBOX_SIZE TCPIP_MBOX_SIZE +#define DEFAULT_ACCEPTMBOX_SIZE TCPIP_MBOX_SIZE + +#define LWIP_TIMEVAL_PRIVATE 0 + +#define LWIP_TCPIP_CORE_LOCKING_INPUT 1 + diff --git a/main/main.c b/main/main.c new file mode 100644 index 0000000..19dd3cd --- /dev/null +++ b/main/main.c @@ -0,0 +1,32 @@ +#include <FreeRTOS.h> +#include <task.h> + +#include <pico/stdlib.h> +#include <pico/time.h> + +#include "config.h" +#include "init.h" +#include "sock.h" +#include "i2c.h" + +void blink_task() { + await_init(); // `blink_task` uses GPIO + + while (true) { + cyw43_arch_gpio_put(LED_PIN, 0); + vTaskDelay(250 / portTICK_PERIOD_MS); + cyw43_arch_gpio_put(LED_PIN, 1); + vTaskDelay(250 / portTICK_PERIOD_MS); + } +} + +int main() { + init(); + + xTaskCreate((TaskFunction_t) blink_task, "blink", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY + 2, NULL); + //xTaskCreate((TaskFunction_t) serve_task, "serve", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY + 2, NULL); + xTaskCreate((TaskFunction_t) bus_task, "bus", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY + 2, NULL); + + vTaskStartScheduler(); +} + diff --git a/main/main.cpp b/main/main.cpp deleted file mode 100644 index 9fd3123..0000000 --- a/main/main.cpp +++ /dev/null @@ -1,36 +0,0 @@ -#include <stdio.h> - -#include "config.h" - -#include "pico/stdlib.h" -#include "pico/cyw43_arch.h" - -const unsigned int LED_PIN = CYW43_WL_GPIO_LED_PIN; - -int main() { - stdio_init_all(); - sleep_ms(2000); - - if (cyw43_arch_init_with_country(CONF_NET_COUNTRY)) { - printf("failed to initialize\n"); - return 1; - } - cyw43_arch_gpio_put(LED_PIN, 1); - printf("initialised\n"); - - cyw43_arch_enable_sta_mode(); - - if (cyw43_arch_wifi_connect_timeout_ms(CONF_NET_SSID, CONF_NET_PASS, CYW43_AUTH_WPA2_AES_PSK, 10000)) { - printf("failed to connect\n"); - return 1; - } - printf("connected\n"); - - while (true) { - cyw43_arch_gpio_put(LED_PIN, 0); - sleep_ms(250); - cyw43_arch_gpio_put(LED_PIN, 1); - sleep_ms(250); - } -} - diff --git a/main/makefile b/main/makefile new file mode 100644 index 0000000..9df4f09 --- /dev/null +++ b/main/makefile @@ -0,0 +1,9 @@ +TARGET = $(BUILD_DIR)/main.uf2 + +include ../lazy.mk + +flash: $(TARGET) FORCE + picotool load -fx $< +# -f forces a reboot of the pico before flashing +# -x resets the pico after flashing + diff --git a/main/readme.md b/main/readme.md new file mode 100644 index 0000000..425a00b --- /dev/null +++ b/main/readme.md @@ -0,0 +1,21 @@ +# main controller firmware + +This directory contains the software for the main controller of the Puzzle Box. + +## building + +1. make sure the submodules are initialized +2. copy [`config.def.h`](./config.def.h) to `config.h` and edit the defaults +3. `mkdir build` +4. `cmake -B build` +5. `make -C build` or `ninja -C build` (choose your preference) + +alternatively, a makefile is provided for convenience + +## "flashing" + +1. [build](#building) +2. (re)connect the raspberry pi pico while holding the BOOTSEL button (this is + the only button) +3. `picotool load build/main.uf2` + diff --git a/main/sock.c b/main/sock.c new file mode 100644 index 0000000..4f50981 --- /dev/null +++ b/main/sock.c @@ -0,0 +1,96 @@ +#include <pico/stdio.h> + +#include <lwip/opt.h> +#include <lwip/sys.h> +#include <lwip/api.h> +#include <string.h> + +#include "init.h" +#include "config.h" +#include "puzbusv1.h" +#include "sock.h" + +struct netconn* current_connection = NULL; +struct pb_msg recv_msg; + +void i2c_send(uint16_t addr, const char * data, size_t data_size) { + if (current_connection == NULL) return; + + struct pb_msg send_msg = { + .addr = addr, + .data = (char *) data, + .length = data_size, + }; + + char * buf; + size_t buf_sz; + + if (!pb_write(&send_msg, &buf, &buf_sz)) return; + + // NOTE: netconn does return an error code, but the data needs to be freed + // whether netconn throws an error or not, so it remains unused + netconn_write(current_connection, buf, buf_sz, NETCONN_COPY); + + free(buf); +} + +void i2c_recv(uint16_t addr, const char * data, size_t data_size) { + printf("address: 0x%02x\n", addr); + printf("data: \"%.*s\"\n", data_size, data); + + // send message back + char reply[] = "Test message back!"; + i2c_send(0x69, reply, strlen(reply)); + + // TODO: this function should forward the recieved message onto the puzzle + // bus instead of printing/replying +} + +void recv_handler(struct netconn* conn, struct netbuf* buf) { + pb_read_reset(&recv_msg); + + do { + char* data; + uint16_t len; + netbuf_data(buf, (void**)&data, &len); + + // continue early if more data is needed to complete message + if (!pb_read(&recv_msg, data, len)) continue; + + // forward received message to puzzle bus + i2c_recv(recv_msg.addr, recv_msg.data, recv_msg.length); + free(recv_msg.data); + } while (netbuf_next(buf) >= 0); + + netbuf_delete(buf); +} + +void accept_handler(struct netconn* conn) { + current_connection = conn; + + struct netbuf* buf; + while (netconn_recv(conn, &buf) == ERR_OK) + recv_handler(conn, buf); + + netconn_close(conn); + netconn_delete(conn); + + current_connection = NULL; +} + +void serve_task() { + await_init(); + + printf("starting server...\n"); + struct netconn* conn = netconn_new(NETCONN_TCP); + netconn_bind(conn, IP_ADDR_ANY, CONF_SRV_PORT); + netconn_listen(conn); + + printf("listening on %s:%d\n", ip4addr_ntoa(netif_ip4_addr(netif_list)), CONF_SRV_PORT); + while (1) { + struct netconn* incoming; + if (netconn_accept(conn, &incoming) == ERR_OK) + accept_handler(incoming); + } +} + diff --git a/main/sock.h b/main/sock.h new file mode 100644 index 0000000..f2db35d --- /dev/null +++ b/main/sock.h @@ -0,0 +1,11 @@ +#pragma once + +#include <stdint.h> +#include <stddef.h> + +/** \brief start listening for TCP socket requests */ +void serve_task(); + +void i2c_send(uint16_t addr, const char * data, size_t data_size); +void i2c_recv(uint16_t addr, const char * data, size_t data_size); + diff --git a/proto/include.cmake b/proto/include.cmake new file mode 100644 index 0000000..ac1305e --- /dev/null +++ b/proto/include.cmake @@ -0,0 +1,16 @@ +include_directories(${CMAKE_CURRENT_LIST_DIR}) +add_library(puzbus STATIC + ${CMAKE_CURRENT_LIST_DIR}/puzbusv1.c + ) + +# mpack +include_directories(${CMAKE_CURRENT_LIST_DIR}/lib/mpack/src/mpack) +add_library(mpack STATIC + ${CMAKE_CURRENT_LIST_DIR}/lib/mpack/src/mpack/mpack-common.c + ${CMAKE_CURRENT_LIST_DIR}/lib/mpack/src/mpack/mpack-expect.c + ${CMAKE_CURRENT_LIST_DIR}/lib/mpack/src/mpack/mpack-node.c + ${CMAKE_CURRENT_LIST_DIR}/lib/mpack/src/mpack/mpack-platform.c + ${CMAKE_CURRENT_LIST_DIR}/lib/mpack/src/mpack/mpack-reader.c + ${CMAKE_CURRENT_LIST_DIR}/lib/mpack/src/mpack/mpack-writer.c + ) + diff --git a/proto/lib b/proto/lib new file mode 120000 index 0000000..dc598c5 --- /dev/null +++ b/proto/lib @@ -0,0 +1 @@ +../lib
\ No newline at end of file diff --git a/proto/puzbusv1.c b/proto/puzbusv1.c new file mode 100644 index 0000000..73deda5 --- /dev/null +++ b/proto/puzbusv1.c @@ -0,0 +1,55 @@ +#include <mpack.h> +#include <stdio.h> + +// MIN() macro +#include <sys/param.h> +// TODO: check if this works on pico as well + +#include "puzbusv1.h" + +int pb_read(struct pb_msg * target, const char * buf, size_t buf_sz) { + // a new reader is used per buffer block passed to this function + mpack_reader_t reader; + mpack_reader_init_data(&reader, buf, buf_sz); + + // at start of message + if (target->_rdata == 0) { + // NOTE: The entire start of a message needs to be readable from the buffer + // at this point. When target->addr can be read and target->length is past + // the end of the current buffer block, this function will crash and burn. + // This is a highly unlikely scenario, as pb_read is called for each chunk + // of a TCP frame, and frames (should) include only one puzzle bus message. + // The check here is kind of optional. + if (buf_sz < 4) return -1; + + target->addr = mpack_expect_u16(&reader); + target->length = target->_rdata = mpack_expect_bin(&reader); + target->data = (char *) malloc(target->length); + } + + // continue reading chunks of target->data until the amount of bytes + // specified in target->length + size_t to_read = MIN(mpack_reader_remaining(&reader, NULL), target->_rdata); + char * data = target->data + target->length - target->_rdata; + mpack_read_bytes(&reader, data, to_read); + target->_rdata -= to_read; + + // if rdata = 0, the message was completely read + return target->_rdata; +} + +void pb_read_reset(struct pb_msg * target) { + target->_rdata = 0; +} + +bool pb_write(const struct pb_msg * target, char ** buf, size_t * buf_sz) { + mpack_writer_t writer; + mpack_writer_init_growable(&writer, buf, buf_sz); + + mpack_write_u16(&writer, target->addr); + mpack_write_bin(&writer, target->data, target->length); + + // finish writing + return mpack_writer_destroy(&writer) == mpack_ok; +} + diff --git a/proto/puzbusv1.h b/proto/puzbusv1.h new file mode 100644 index 0000000..0985b2b --- /dev/null +++ b/proto/puzbusv1.h @@ -0,0 +1,70 @@ +#pragma once + +#include <stddef.h> +#include <stdint.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/** \brief Puzzle bus message (v1) */ +struct pb_msg { + uint16_t addr; //!< I^2^C address + char * data; //!< message content + size_t length; //!< message size + size_t _rdata; //!< \private remaining bytes to read until message is complete +}; + +/** + * \brief Read chunk of input stream, and store resulting message in \p target + * + * This function is called for each chunk of data from an input stream, and + * will parse the next puzzle bus message into \p target. The input stream is + * assumed to only contain messages encoded by \p pb_write() + * + * \param target pointer to struct that will contain the finished message data + * \param buf pointer to input stream data chunk + * \param buf_sz size of \p buf + * + * \returns Integer representing amount of bytes required to finish message, or + * -1 if the message header could not be read. If this function returns 0, the + * message in \p target is complete. + * + * \note target->data will automatically be allocated by this function, even if + * the message is not fully parsed. This variable must be `free()`d by the + * caller after each complete message to prevent memory leaks. + */ +int pb_read(struct pb_msg * target, const char * buf, size_t buf_sz); + +/** + * \brief reset the remaining message data counter + * + * Calling this function has the effect of forcing \c pb_read() to parse the + * next buffer chunk as the start of a new message. This function may be called + * before reading a TCP frame's data to mitigate any synchronization issues + * arising from earlier corrupt or otherwise malformed messages. + */ +void pb_read_reset(struct pb_msg * target); + +/** + * \brief Allocate and write a msgpack-formatted message to \p buf + * + * This function allocates a buffer large enough to fit the message specified + * in \p target, and encodes the data in \p target in a format that can be + * decoded later using \p pb_read() + * + * \param target pointer to struct that contains the message data + * \param buf pointer to \c char* that will contain the formatted message + * \param buf_sz pointer to \c size_t that will represent the final size of \p buf + * + * \returns boolean true if a the message could be encoded successfully, false + * if there was some kind of error + * + * \note the pointer stored in \p buf must be `free()`d by the caller afterwards + */ +bool pb_write(const struct pb_msg * target, char ** buf, size_t * buf_sz); + +#ifdef __cplusplus +} +#endif + diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index a0bd099..a280a86 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -20,4 +20,4 @@ target_link_libraries(tests PRIVATE gtest_main) add_test( NAME tests COMMAND tests -)
\ No newline at end of file +) diff --git a/test/lib b/test/lib new file mode 120000 index 0000000..dc598c5 --- /dev/null +++ b/test/lib @@ -0,0 +1 @@ +../lib
\ No newline at end of file |