switch to event based expander interface (WIP)

main/drivers/CMakeLists.txt

@@ -4,15 +4,14 @@ set(SOURCES
     "TM1640/TM1640.cpp"
     "SparkFunBQ27441/SparkFunBQ27441.cpp"
     "esp_lcd_ili9488/esp_lcd_ili9488.c"
-    "bottom_half.cpp"
+    # "bottom_half.cpp"
     "char_lcd.cpp"
     "game_info.cpp"
     "game_timer.cpp"
-    "hwdata.cpp"
     "i2c_lcd_pcf8574.c"
     "i2c.cpp"
+    "inputs.cpp"
     "leds.cpp"
-    "nvs.cpp"
     "perh.cpp"
     "power.cpp"
     "sd.cpp"

main/drivers/all.cpp

@@ -4,7 +4,6 @@ void init_drivers() {
     init_i2c();
     // init char_lcd so we can use it to report other initialization errors.
     init_lcd();
-    init_nvs();
     init_star_code_system();
     // init the bottom half so that we can get user input.
     init_bottom_half();

main/drivers/all.h

@@ -6,7 +6,6 @@
 #include "game_timer.h"
 #include "i2c.h"
 #include "leds.h"
-#include "nvs.h"
 #include "power.h"
 #include "sd.h"
 #include "speaker.h"

main/drivers/char_lcd.cpp

@@ -9,7 +9,6 @@
 #include "game_info.h"
 
 i2c_lcd_pcf8574_handle_t lcd;
-SemaphoreHandle_t lcd_mutex;
 
 static volatile bool header_enabled = false;
 
@@ -18,7 +17,6 @@ static const char* EMPTY_ROW = "                    ";
 
 static char buf[65];
 
-// TODO: move this to power.cpp
 static void monitor_battery_task(void* _arg) {
     (void) _arg;
 
@@ -31,35 +29,53 @@ static void monitor_battery_task(void* _arg) {
 static bool replay_handler(const char* event, char* arg) {
     if (strcmp(event, "LCD_CLEAR") == 0) {
         lcd_clear();
+        return true;
     }
-    else if (strcmp(event, "LCD_SET_DISPLAY") == 0) {
+    if (strcmp(event, "LCD_CURSOR") == 0) {
+        char* col_str = strtok(arg, ",");
+        char* row_str = strtok(NULL, ",");
+        uint32_t col = atoi(col_str);
+        uint32_t row = atoi(row_str);
+        lcd_set_cursor_pos(col, row);
+        return true;
+    }
+    if (strcmp(event, "LCD_SET_DISPLAY") == 0) {
         lcd_set_display(strcmp(arg, "true") == 0);
+        return true;
     }
-    else if (strcmp(event, "LCD_CURSOR_VIS") == 0) {
+    if (strcmp(event, "LCD_CURSOR_VIS") == 0) {
         lcd_set_cursor_vis(strcmp(arg, "true") == 0);
+        return true;
     }
-    else if (strcmp(event, "LCD_CURSOR_BLINK") == 0) {
+    if (strcmp(event, "LCD_CURSOR_BLINK") == 0) {
         lcd_set_cursor_blink(strcmp(arg, "true") == 0);
+        return true;
     }
-    else if (strcmp(event, "LCD_SCROLL_DISPLAY_LEFT") == 0) {
+    if (strcmp(event, "LCD_SCROLL_DISPLAY_LEFT") == 0) {
         lcd_scroll_display_left();
+        return true;
     }
-    else if (strcmp(event, "LCD_SCROLL_DISPLAY_RIGHT") == 0) {
+    if (strcmp(event, "LCD_SCROLL_DISPLAY_RIGHT") == 0) {
         lcd_scroll_display_right();
+        return true;
     }
-    else if (strcmp(event, "LCD_LEFT_TO_RIGHT") == 0) {
+    if (strcmp(event, "LCD_LEFT_TO_RIGHT") == 0) {
         lcd_left_to_right();
+        return true;
     }
-    else if (strcmp(event, "LCD_RIGHT_TO_LEFT") == 0) {
+    if (strcmp(event, "LCD_RIGHT_TO_LEFT") == 0) {
         lcd_right_to_left();
+        return true;
     }
-    else if (strcmp(event, "LCD_AUTOSCROLL") == 0) {
+    if (strcmp(event, "LCD_AUTOSCROLL") == 0) {
         lcd_set_autoscroll(strcmp(arg, "true") == 0);
+        return true;
     }
-    else if (strcmp(event, "LCD_BACKLIGHT") == 0) {
+    if (strcmp(event, "LCD_BACKLIGHT") == 0) {
         lcd_set_backlight(strcmp(arg, "true") == 0);
+        return true;
     }
-    else if (strcmp(event, "LCD_CREATE_CHAR") == 0) {
+    if (strcmp(event, "LCD_CREATE_CHAR") == 0) {
         char* location_str = strtok(arg, ",");
         uint8_t location = atoi(location_str);
 
@@ -70,34 +86,24 @@ static bool replay_handler(const char* event, char* arg) {
         }
 
         lcd_create_char(location, charmap);
+        return true;
     }
-    else if (strcmp(event, "LCD_PRINT") == 0) {
+    if (strcmp(event, "LCD_PRINT") == 0) {
-        char* str = strtok(arg, ",");
-        uint8_t row = atoi(str);
-        str = strtok(NULL, ",");
-        uint8_t col = atoi(str);
-        // get remaining part of string.
-        str = strtok(NULL, "");
-
         // TODO: handle \r and \n
-        lcd_print(row, col, str);
+        lcd_print(&lcd, arg);
-    } else {
+        return true;
-        return false;
     }
 
-    return true;
+    return false;
 }
 
 void init_lcd() {
     ESP_LOGI(TAG, "Initializing LCD...");
 
-    lcd_mutex = xSemaphoreCreateMutex();
-    assert(lcd_mutex != NULL);
-
     lcd_init(&lcd, LCD_ADDR, CHAR_LCD_I2C_NUM);
     lcd_begin(&lcd, LCD_COLS, LCD_ROWS);
 
-    lcd_set_backlight_to(&lcd, 1);
+    lcd_set_backlight(&lcd, 255);
 
     register_replay_fn(replay_handler);
 
@@ -106,122 +112,115 @@ void init_lcd() {
     ESP_LOGI(TAG, "LCD initialized!");
 }
 
-void lcd_clear(bool no_lock) {
+void lcd_clear() {
     if (!header_enabled) {
-        if (!no_lock) xSemaphoreTake(lcd_mutex, portMAX_DELAY);
         lcd_clear(&lcd);
-        if (!no_lock) xSemaphoreGive(lcd_mutex);
 
         if (is_state_tracking()) {
             event_occured("LCD_CLEAR", NULL);
         }
     } else {
-        if (!no_lock) xSemaphoreTake(lcd_mutex, portMAX_DELAY);
+        lcd_print(0, 1, EMPTY_ROW);
-        lcd_print(1, 0, EMPTY_ROW, true);
+        lcd_print(0, 2, EMPTY_ROW);
-        lcd_print(2, 0, EMPTY_ROW, true);
+        lcd_print(0, 3, EMPTY_ROW);
-        lcd_print(3, 0, EMPTY_ROW, true);
-        if (!no_lock) xSemaphoreGive(lcd_mutex);
     }
 }
 
-void lcd_set_display(bool display,  bool no_lock) {
+// TODO: rm
-    if (!no_lock) xSemaphoreTake(lcd_mutex, portMAX_DELAY);
+void lcd_cursor_home() {
+    lcd_set_cursor_pos(0, 0);
+}
+
+// TODO: with print requiring you to set a pos every time, this function is not helpful
+void lcd_set_cursor_pos(uint8_t col, uint8_t row) {
+    lcd_set_cursor(&lcd, col, row);
+
+    if (is_state_tracking()) {
+        sprintf(buf, "%d,%d", col, row);
+        event_occured("LCD_CURSOR", buf);
+    }
+}
+
+void lcd_set_display(bool display) {
     if (display) {
         lcd_display(&lcd);
     } else {
         lcd_no_display(&lcd);
     }
-    if (!no_lock) xSemaphoreGive(lcd_mutex);
 
     if (is_state_tracking()) {
         event_occured("LCD_SET_DISPLAY", display ? "true" : "false");
     }
 }
 
-void lcd_set_cursor_vis(bool cursor, bool no_lock) {
+void lcd_set_cursor_vis(bool cursor) {
-    if (!no_lock) xSemaphoreTake(lcd_mutex, portMAX_DELAY);
     if (cursor) {
         lcd_cursor(&lcd);
     } else {
         lcd_no_cursor(&lcd);
     }
-    if (!no_lock) xSemaphoreGive(lcd_mutex);
 
     if (is_state_tracking()) {
         event_occured("LCD_CURSOR_VIS", cursor ? "true" : "false");
     }
 }
 
-void lcd_set_cursor_blink(bool blink, bool no_lock) {
+void lcd_set_cursor_blink(bool blink) {
-    if (!no_lock) xSemaphoreTake(lcd_mutex, portMAX_DELAY);
     if (blink) {
         lcd_blink(&lcd);
     } else {
         lcd_no_blink(&lcd);
     }
-    if (!no_lock) xSemaphoreGive(lcd_mutex);
 
     if (is_state_tracking()) {
         event_occured("LCD_CURSOR_BLINK", blink ? "true" : "false");
     }
 }
 
-void lcd_scroll_display_left(bool no_lock) {
+void lcd_scroll_display_left() {
-    if (!no_lock) xSemaphoreTake(lcd_mutex, portMAX_DELAY);
     lcd_scroll_display_left(&lcd);
-    if (!no_lock) xSemaphoreGive(lcd_mutex);
 
     if (is_state_tracking()) {
         event_occured("LCD_SCROLL_DISPLAY_LEFT", NULL);
     }
 }
-void lcd_scroll_display_right(bool no_lock) {
+void lcd_scroll_display_right() {
-    if (!no_lock) xSemaphoreTake(lcd_mutex, portMAX_DELAY);
     lcd_scroll_display_right(&lcd);
-    if (!no_lock) xSemaphoreGive(lcd_mutex);
 
     if (is_state_tracking()) {
         event_occured("LCD_SCROLL_DISPLAY_RIGHT", NULL);
     }
 }
 
-void lcd_left_to_right(bool no_lock) {
+void lcd_left_to_right() {
-    if (!no_lock) xSemaphoreTake(lcd_mutex, portMAX_DELAY);
     lcd_left_to_right(&lcd);
-    if (!no_lock) xSemaphoreGive(lcd_mutex);
 
     if (is_state_tracking()) {
         event_occured("LCD_LEFT_TO_RIGHT", NULL);
     }
 }
-void lcd_right_to_left(bool no_lock) {
+void lcd_right_to_left() {
-    if (!no_lock) xSemaphoreTake(lcd_mutex, portMAX_DELAY);
     lcd_right_to_left(&lcd);
-    if (!no_lock) xSemaphoreGive(lcd_mutex);
 
     if (is_state_tracking()) {
         event_occured("LCD_RIGHT_TO_LEFT", NULL);
     }
 }
 
-void lcd_set_autoscroll(bool autoscroll, bool no_lock) {
+void lcd_set_autoscroll(bool autoscroll) {
-    if (!no_lock) xSemaphoreTake(lcd_mutex, portMAX_DELAY);
     if (autoscroll) {
         lcd_autoscroll(&lcd);
     } else {
         lcd_no_autoscroll(&lcd);
     }
-    if (!no_lock) xSemaphoreGive(lcd_mutex);
 
     if (is_state_tracking()) {
         event_occured("LCD_AUTOSCROLL", autoscroll ? "true" : "false");
     }
 }
 
-void lcd_set_backlight(bool backlight, bool no_lock) {
+void lcd_set_backlight(bool backlight) {
-    if (!no_lock) xSemaphoreTake(lcd_mutex, portMAX_DELAY);
+    lcd_set_backlight(&lcd, backlight);
-    lcd_set_backlight_to(&lcd, backlight);
-    if (!no_lock) xSemaphoreGive(lcd_mutex);
 
     if (is_state_tracking()) {
         sprintf(buf, "%d", backlight);
@@ -229,15 +228,11 @@ void lcd_set_backlight(bool backlight, bool no_lock) {
     }
 }
 
-void lcd_create_char(uint8_t location, const uint8_t charmap[], bool no_lock) {
+void lcd_create_char(uint8_t location, const uint8_t charmap[]) {
-    if (location == 8) location = 0;
-
-    if (!no_lock) xSemaphoreTake(lcd_mutex, portMAX_DELAY);
     lcd_create_char(&lcd, location, charmap);
-    if (!no_lock) xSemaphoreGive(lcd_mutex);
 
     if (is_state_tracking()) {
-        snprintf(buf, sizeof(buf),
+        snprintf(buf, 65,
             "%d,%d,%d,%d,%d,%d,%d,%d,%d", location, 
             charmap[0], charmap[1], charmap[2], charmap[3], charmap[4], charmap[5], charmap[6], charmap[7]
         );
@@ -245,16 +240,14 @@ void lcd_create_char(uint8_t location, const uint8_t charmap[], bool no_lock) {
     }
 }
 
-void lcd_print(uint8_t row, uint8_t col, const char* str, bool no_lock) {
+// TODO: switch to row, col
-    if (!no_lock) xSemaphoreTake(lcd_mutex, portMAX_DELAY);
+void lcd_print(uint8_t col, uint8_t row, const char* str) {
-    lcd_set_cursor(&lcd, col, row);
+    lcd_set_cursor_pos(col, row);
     lcd_print(&lcd, str);
-    if (!no_lock) xSemaphoreGive(lcd_mutex);
 
     if (is_state_tracking()) {
-        // TODO: handle \r and \n and others
+        // TODO: handle \r and \n
-        snprintf(buf, sizeof(buf), "%d,%d,%s", row, col, str);
+        event_occured("LCD_PRINT", str);
-        event_occured("LCD_PRINT", buf);
     }
 }
 
@@ -291,23 +284,13 @@ void lcd_do_splash() {
     };
 
     // TODO: make the lcd_lib somehow support the custom character 0 which would otherwise be a null terminator
-    xSemaphoreTake(lcd_mutex, portMAX_DELAY);
+    lcd_create_char(1, custom_char[0]);
-    lcd_create_char(1, custom_char[0], true);
+    lcd_create_char(2, custom_char[1]);
-    lcd_create_char(2, custom_char[1], true);
+    lcd_create_char(3, custom_char[2]);
-    lcd_create_char(3, custom_char[2], true);
+    lcd_create_char(4, custom_char[3]);
-    lcd_create_char(4, custom_char[3], true);
+    lcd_create_char(5, custom_char[4]);
-    lcd_create_char(5, custom_char[4], true);
+    lcd_create_char(6, custom_char[5]);
-    lcd_create_char(6, custom_char[5], true);
 
-    lcd_print(1, 6, "\x01\x02Marino", true);
+    lcd_print(6, 1, "\x01\x02Marino");
-    lcd_print(2, 5, "\x03\x04\x05\x06""DEV", true);
+    lcd_print(5, 2, "\x03\x04\x05\x06""DEV");
-    xSemaphoreGive(lcd_mutex);
-}
-
-bool lcd_lock(uint32_t ticks_to_wait) {
-    return xSemaphoreTake(lcd_mutex, ticks_to_wait);
-}
-
-void lcd_unlock() {
-    xSemaphoreGive(lcd_mutex);
 }

main/drivers/char_lcd.h

@@ -6,53 +6,54 @@
 #define CHAR_LCD_I2C_NUM I2C_NUM_0
 
 #define LCD_ADDR 0x27
-#define LCD_ROWS 4
 #define LCD_COLS 20
+#define LCD_ROWS 4
 
-/// @brief Initializes the 2004 Character LCD
+/// Initializes the 2004 Character LCD
 void init_lcd();
 
-/// @brief Clear the LCD
+/// Clear the LCD
-void lcd_clear(bool no_lock = false);
+void lcd_clear();
 
-/// @brief Move cursor to home position
+/// Move cursor to home position
-void lcd_cursor_home(bool no_lock = false);
+void lcd_cursor_home();
 
-/// @brief Turn the display on/off
+/// Set cursor position
-void lcd_set_display(bool display, bool no_lock = false);
+void lcd_set_cursor_pos(uint8_t col, uint8_t row);
 
-/// @brief Turn the cursor's visibility on/off
+/// Turn the display on/off
-void lcd_set_cursor_vis(bool cursor, bool no_lock = false);
+void lcd_set_display(bool display);
 
-/// @brief Turn blinking cursor on/off
+/// Turn the cursor's visibility on/off
-void lcd_set_cursor_blink(bool blink, bool no_lock = false);
+void lcd_set_cursor_vis(bool cursor);
 
-/// @brief Scroll the display left
+/// Turn blinking cursor on/off
-void lcd_scroll_display_left(bool no_lock = false);
+void lcd_set_cursor_blink(bool blink);
-/// @brief Scroll the display right
-void lcd_scroll_display_right(bool no_lock = false);
 
-/// @brief Set the text to flows automatically left to right
+/// Scroll the display left
-void lcd_left_to_right(bool no_lock = false);
+void lcd_scroll_display_left();
-/// @brief Set the text to flows automatically right to left
+/// Scroll the display right
-void lcd_right_to_left(bool no_lock = false);
+void lcd_scroll_display_right();
 
-/// @brief Turn on/off autoscroll
+/// Set the text to flows automatically left to right
-void lcd_set_autoscroll(bool autoscroll, bool no_lock = false);
+void lcd_left_to_right();
+/// Set the text to flows automatically right to left
+void lcd_right_to_left();
 
-/// @brief Set backlight brightness
+// Turn on/off autoscroll
-void lcd_set_backlight(bool backlight, bool no_lock = false);
+void lcd_set_autoscroll(bool autoscroll);
 
-/// @brief Create a custom character. You get 8 custom characters.
+// Set backlight brightness
-/// You can print custom characters by using escape characters in strings:
+void lcd_set_backlight(bool backlight);
-/// use '\x01' - '\x07' for custom characters 1-7. Use '\x08' for custom char 0.
+
-void lcd_create_char(uint8_t location, const uint8_t charmap[], bool no_lock = false);
+// Create a custom character
+void lcd_create_char(uint8_t location, const uint8_t charmap[]);
 
 /// @brief Print a string to the LCD at a given pos. 
-/// @param row the row the print the string at.
 /// @param col the column to print the string at.
+/// @param row the row the print the string at.
 /// @param str the string to print.
-void lcd_print(uint8_t row, uint8_t col, const char* str, bool no_lock = false);
+void lcd_print(uint8_t col, uint8_t row, const char* str);
 
 /// @brief Enables or disables the header on the LCD.
 /// @param enable `true` to enable the header, `false` to disable.
@@ -68,15 +69,4 @@ void lcd_print_header();
 /// @brief Prints the splash screen for the BLK_BOX.
 void lcd_do_splash();
 
-/// @brief Locks the LCD to allow chaining multiple commands without interuptions.
-///
-/// Commands you call while you lock the LCD, you must call with the `no_lock` flag set to true.
-///
-/// Do not hold this lock for an extended period of time.
-/// @return `true` iff the lock was aquired.
-bool lcd_lock(uint32_t ticks_to_wait);
-
-/// @brief Unlocks the LCD to give away the mutex access to it.
-void lcd_unlock();
-
 #endif /* CHAR_LCD_H */

main/drivers/game_info.cpp

@@ -17,5 +17,5 @@ void lcd_print_header_step() {
     if (!lcd_header_enabled()) return;
     if (lcd_starcode_displaying_result()) return;
 
-    lcd_print(0, 10, game_state);
+    lcd_print(10, 0, game_state);
 }

main/drivers/hwdata.cpp

@@ -1,138 +0,0 @@
-#include "hwdata.h"
-#include "esp_err.h"
-#include "esp_log.h"
-
-static const char* TAG = "hwdata";
-
-HWData::HWData() 
-    : compat_mode(true) 
-{}
-
-HWData::HWData(HWData1 data, bool compat_mode)
-    : compat_mode(compat_mode),
-      inner(data) 
-{}
-
-esp_err_t HWData::save(nvs_handle_t handle, bool force) {
-    if (compat_mode && !force) {
-        ESP_LOGW(TAG, "Not saving due to being in compatability mode.");
-        return ESP_OK;
-    }
-    return inner.save(handle);
-}
-
-HWData HWData::load(nvs_handle_t handle) {
-    esp_err_t err;
-
-    uint16_t stored_version = 0;
-    err = nvs_get_u16(handle, "version", &stored_version);
-    if (err == ESP_ERR_NVS_NOT_FOUND) {
-        ESP_LOGE(TAG, "No NVS data found! using defaults");
-        return HWData();
-    } else if (err != ESP_OK) {
-        ESP_ERROR_CHECK_WITHOUT_ABORT(err);
-        ESP_LOGE(TAG, "Other esp error! using defaults");
-        return HWData();
-    }
-
-    HWData1 data;
-    switch (stored_version) {
-        case 0:
-            ESP_LOGE(TAG, "HWData version was 0! using defaults");
-            return HWData();
-        case 1:
-            data.load(handle);
-            return HWData(data, false);
-        default:
-            ESP_LOGW(TAG, "Max currently supported version is %d, but saved version is %d. Loading version %d anyway!", CURRENT_HWDATA_VERSION, stored_version, CURRENT_HWDATA_VERSION);
-            data.load(handle);
-            return HWData(data, true);
-    }
-}
-
-HWData1::HWData1() {}
-
-esp_err_t HWData1::save(nvs_handle_t handle) const {
-    ESP_ERROR_CHECK(nvs_set_u16(handle, "version", 1));
-
-    // Serial number
-    ESP_ERROR_CHECK(nvs_set_str(handle, "serial_num", serial_num.c_str()));
-
-    // Revisions
-    ESP_ERROR_CHECK(nvs_set_u8(handle, "rev_ctrl_maj", rev_ctrl_maj));
-    ESP_ERROR_CHECK(nvs_set_u8(handle, "rev_ctrl_min", rev_ctrl_min));
-    ESP_ERROR_CHECK(nvs_set_u8(handle, "rev_exp_maj", rev_exp_maj));
-    ESP_ERROR_CHECK(nvs_set_u8(handle, "rev_exp_min", rev_exp_min));
-    ESP_ERROR_CHECK(nvs_set_u8(handle, "rev_ft_maj", rev_ft_maj));
-    ESP_ERROR_CHECK(nvs_set_u8(handle, "rev_ft_min", rev_ft_min));
-    ESP_ERROR_CHECK(nvs_set_u8(handle, "rev_fb_maj", rev_fb_maj));
-    ESP_ERROR_CHECK(nvs_set_u8(handle, "rev_fb_min", rev_fb_min));
-
-    // Enums
-    ESP_ERROR_CHECK(nvs_set_u8(handle, "sseg_color_t", static_cast<uint8_t>(sseg_color_t)));
-    ESP_ERROR_CHECK(nvs_set_u8(handle, "sseg_color_b", static_cast<uint8_t>(sseg_color_b)));
-    ESP_ERROR_CHECK(nvs_set_u8(handle, "lcd_color", static_cast<uint8_t>(lcd_color)));
-    ESP_ERROR_CHECK(nvs_set_u8(handle, "button_type", static_cast<uint8_t>(button_type)));
-    ESP_ERROR_CHECK(nvs_set_u8(handle, "tft_type", static_cast<uint8_t>(tft_type)));
-    ESP_ERROR_CHECK(nvs_set_u8(handle, "bat_type", static_cast<uint8_t>(bat_type)));
-    ESP_ERROR_CHECK(nvs_set_u8(handle, "shape1", static_cast<uint8_t>(shape1)));
-    ESP_ERROR_CHECK(nvs_set_u8(handle, "shape2", static_cast<uint8_t>(shape2)));
-    ESP_ERROR_CHECK(nvs_set_u8(handle, "shape3", static_cast<uint8_t>(shape3)));
-    ESP_ERROR_CHECK(nvs_set_u8(handle, "shape4", static_cast<uint8_t>(shape4)));
-
-    // Other fields
-    ESP_ERROR_CHECK(nvs_set_u8(handle, "switch_pos", switch_pos));
-    ESP_ERROR_CHECK(nvs_set_u8(handle, "has_speaker", has_speaker));
-    ESP_ERROR_CHECK(nvs_set_u8(handle, "has_mic", has_mic));
-    ESP_ERROR_CHECK(nvs_set_u8(handle, "has_ir", has_ir));
-    ESP_ERROR_CHECK(nvs_set_u8(handle, "has_rfid", has_rfid));
-    ESP_ERROR_CHECK(nvs_set_u8(handle, "has_fp", has_fp));
-    ESP_ERROR_CHECK(nvs_set_u8(handle, "has_fp_hall", has_fp_hall));
-    ESP_ERROR_CHECK(nvs_set_u8(handle, "has_close_hall", has_close_hall));
-
-    // Battery capacity
-    ESP_ERROR_CHECK(nvs_set_u16(handle, "bat_cap", bat_cap));
-
-    return nvs_commit(handle);
-}
-
-void HWData1::load(nvs_handle_t handle) {
-    char buf[128];
-    size_t required_size = sizeof(buf);
-    esp_err_t err = nvs_get_str(handle, "serial_num", buf, &required_size);
-    serial_num = (err == ESP_OK) ? std::string(buf) : "";
-
-    nvs_get_u8(handle, "rev_ctrl_maj", &rev_ctrl_maj);
-    nvs_get_u8(handle, "rev_ctrl_min", &rev_ctrl_min);
-    nvs_get_u8(handle, "rev_exp_maj", &rev_exp_maj);
-    nvs_get_u8(handle, "rev_exp_min", &rev_exp_min);
-    nvs_get_u8(handle, "rev_ft_maj", &rev_ft_maj);
-    nvs_get_u8(handle, "rev_ft_min", &rev_ft_min);
-    nvs_get_u8(handle, "rev_fb_maj", &rev_fb_maj);
-    nvs_get_u8(handle, "rev_fb_min", &rev_fb_min);
-
-    uint8_t tmp;
-    if (nvs_get_u8(handle, "sseg_color_t", &tmp) == ESP_OK) sseg_color_t = static_cast<SSegColor>(tmp);
-    if (nvs_get_u8(handle, "sseg_color_b", &tmp) == ESP_OK) sseg_color_b = static_cast<SSegColor>(tmp);
-    if (nvs_get_u8(handle, "lcd_color", &tmp) == ESP_OK) lcd_color = static_cast<LCDColor>(tmp);
-    if (nvs_get_u8(handle, "button_type", &tmp) == ESP_OK) button_type = static_cast<ButtonType>(tmp);
-    if (nvs_get_u8(handle, "tft_type", &tmp) == ESP_OK) tft_type = static_cast<TFTType>(tmp);
-    if (nvs_get_u8(handle, "bat_type", &tmp) == ESP_OK) bat_type = static_cast<BatType>(tmp);
-    nvs_get_u16(handle, "bat_cap", &bat_cap);
-
-    if (nvs_get_u8(handle, "shape1", &tmp) == ESP_OK) shape1 = static_cast<Shape>(tmp);
-    if (nvs_get_u8(handle, "shape2", &tmp) == ESP_OK) shape2 = static_cast<Shape>(tmp);
-    if (nvs_get_u8(handle, "shape3", &tmp) == ESP_OK) shape3 = static_cast<Shape>(tmp);
-    if (nvs_get_u8(handle, "shape4", &tmp) == ESP_OK) shape4 = static_cast<Shape>(tmp);
-
-    nvs_get_u8(handle, "switch_pos", &switch_pos);
-    nvs_get_u8(handle, "has_speaker", &tmp); has_speaker = tmp;
-    nvs_get_u8(handle, "has_mic", &tmp); has_mic = tmp;
-    nvs_get_u8(handle, "has_ir", &tmp); has_ir = tmp;
-    nvs_get_u8(handle, "has_rfid", &tmp); has_rfid = tmp;
-    nvs_get_u8(handle, "has_fp", &tmp); has_fp = tmp;
-    nvs_get_u8(handle, "has_fp_hall", &tmp); has_fp_hall = tmp;
-    nvs_get_u8(handle, "has_close_hall", &tmp); has_close_hall = tmp;
-}
-
-

main/drivers/hwdata.h

@@ -1,133 +0,0 @@
-#ifndef HWDATA_H
-#define HWDATA_H
-
-#include <string>
-#include <cstdint>
-#include <cstring>
-#include "esp_err.h"
-#include "nvs_flash.h"
-
-#define CURRENT_HWDATA_VERSION 1
-#define CURRENT_HWDATA_STRUCT HWData1
-
-enum class SSegColor : uint8_t {
-    UNKNOWN = 0,
-    NONE = 1,
-    OTHER = 2,
-    RED = 3,
-    ORANGE = 4,
-    YELLOW = 5,
-    GREEN = 6,
-    BLUE = 7,
-    PURPLE = 8,
-    WHITE = 9,
-};
-
-enum class LCDColor : uint8_t {
-    UNKNOWN = 0,
-    NONE = 1,
-    OTHER = 2,
-    BLACK_GREEN = 3,
-    WHITE_BLUE = 4,
-    BLACK_SKY = 5,
-    BLACK_WHITE = 6,
-    WHITE_BLACK = 7,
-};
-
-enum class ButtonType : uint8_t {
-    UNKNOWN = 0,
-    NONE = 1,
-    OTHER = 2,
-    WHITE = 3,
-    BROWN = 4,
-    RED = 5,
-};
-
-enum class TFTType : uint8_t {
-    UNKNOWN = 0,
-    NONE = 1,
-    OTHER = 2,
-    EAST_RISING = 3,
-    SHENZHEN = 4,
-};
-
-enum class BatType : uint8_t {
-    UNKNOWN = 0,
-    NONE = 1,
-    OTHER = 2,
-    BAT_18650 = 3,
-    LIPO = 4,
-};
-
-enum class Shape : uint8_t {
-    UNKNOWN = 0,
-    OTHER = 1,
-    CIRCLE = 2,
-    SQUARE = 3,
-    TRIANGLE = 4,
-    X = 5,
-    STAR = 6,
-    SPADE = 7,
-    DIAMOND = 8,
-    CLUB = 9,
-    HEART = 10,
-};
-
-
-/// @brief Version 1 of HWData, kept constant for migrations
-struct HWData1 {
-    std::string serial_num;
-    uint8_t rev_ctrl_maj;
-    uint8_t rev_ctrl_min;
-    uint8_t rev_exp_maj;
-    uint8_t rev_exp_min;
-    uint8_t rev_ft_maj;
-    uint8_t rev_ft_min;
-    uint8_t rev_fb_maj;
-    uint8_t rev_fb_min;
-
-    SSegColor sseg_color_t;
-    SSegColor sseg_color_b;
-    LCDColor lcd_color;
-    uint8_t switch_pos;
-    ButtonType button_type;
-    TFTType tft_type;
-    BatType bat_type;
-    uint16_t bat_cap;
-
-    Shape shape1;
-    Shape shape2;
-    Shape shape3;
-    Shape shape4;
-
-    bool has_speaker;
-    bool has_mic;
-    bool has_ir;
-    bool has_rfid;
-    bool has_fp;
-    bool has_fp_hall;
-    bool has_close_hall;
-
-    HWData1();
-
-    esp_err_t save(nvs_handle_t handle) const;
-    void load(nvs_handle_t handle);
-
-    // Add migration method as necessary
-};
-
-/// @brief The current version of HWData, to be stored
-struct HWData {
-    /// @brief `true` if there is some issue in loading, and we are doing a "best effort" to be compatible
-    /// We should make no writes to NVS if this is `true`.
-    volatile bool compat_mode;
-    HWData1 inner;
-
-    HWData();
-    HWData(HWData1 data, bool compat_mode);
-
-    esp_err_t save(nvs_handle_t handle, bool force = false);
-    static HWData load(nvs_handle_t handle);
-};
-
-#endif /* HWDATA_H */

main/drivers/i2c_lcd_pcf8574.c

@@ -233,7 +233,7 @@ void lcd_no_autoscroll(i2c_lcd_pcf8574_handle_t* lcd) {
 
 // Setting the backlight: It can only be turn on or off.
 // Current backlight value is saved in the i2c_lcd_pcf8574_handle_t struct for further data transfers
-void lcd_set_backlight_to(i2c_lcd_pcf8574_handle_t* lcd, uint8_t brightness) {
+void lcd_set_backlight(i2c_lcd_pcf8574_handle_t* lcd, uint8_t brightness) {
     // Place the backlight value in the lcd struct
     lcd->backlight = brightness;
     // Send no data
@@ -258,12 +258,7 @@ void lcd_write(i2c_lcd_pcf8574_handle_t* lcd, uint8_t value) {
 // Print characters to the LCD: cursor set or clear instruction must preceded this instruction, or it will write on the current text.
 void lcd_print(i2c_lcd_pcf8574_handle_t* lcd, const char* str) {
     while (*str) {
-        if (*str == '\x08') {
+        lcd_write(lcd, *str++);
-            lcd_write(lcd, '\x00');
-            str++;
-        } else {
-            lcd_write(lcd, *str++);
-        }
     }
 }  // lcd_print()
 
@@ -301,17 +296,18 @@ void lcd_print_number(i2c_lcd_pcf8574_handle_t* lcd, uint8_t col, uint8_t row, u
 
 // Private functions: derived from the esp32 i2c_master driver
 
+
 static void lcd_send(i2c_lcd_pcf8574_handle_t* lcd, uint8_t value, bool is_data) {
+    xSemaphoreTake(main_i2c_mutex, portMAX_DELAY);
     i2c_cmd_handle_t cmd = i2c_cmd_link_create();
     i2c_master_start(cmd);
     i2c_master_write_byte(cmd, (lcd->i2c_addr << 1) | I2C_MASTER_WRITE, true);
-    xSemaphoreTake(main_i2c_mutex, portMAX_DELAY);
     lcd_write_nibble(lcd, (value >> 4 & 0x0F), is_data, cmd);
     lcd_write_nibble(lcd, (value & 0x0F), is_data, cmd);
     i2c_master_stop(cmd);
     esp_err_t ret = i2c_master_cmd_begin(lcd->i2c_port, cmd, I2C_MASTER_TIMEOUT_MS / portTICK_PERIOD_MS);
-    xSemaphoreGive(main_i2c_mutex);
     i2c_cmd_link_delete(cmd);
+    xSemaphoreGive(main_i2c_mutex);
     
     if (ret != ESP_OK) {
         ESP_LOGE(TAG, "Failed to send data to LCD: %s", esp_err_to_name(ret));
@@ -350,15 +346,15 @@ static void lcd_write_i2c(i2c_lcd_pcf8574_handle_t* lcd, uint8_t data, bool is_d
         data |= lcd->backlight_mask;
     }
 
+    xSemaphoreTake(main_i2c_mutex, portMAX_DELAY);
     i2c_cmd_handle_t cmd = i2c_cmd_link_create();
     i2c_master_start(cmd);
     i2c_master_write_byte(cmd, (lcd->i2c_addr << 1) | I2C_MASTER_WRITE, true);
     i2c_master_write_byte(cmd, data, true);
     i2c_master_stop(cmd);
-    xSemaphoreTake(main_i2c_mutex, portMAX_DELAY);
     esp_err_t ret = i2c_master_cmd_begin(lcd->i2c_port, cmd, I2C_MASTER_TIMEOUT_MS / portTICK_PERIOD_MS);
-    xSemaphoreGive(main_i2c_mutex);
     i2c_cmd_link_delete(cmd);
+    xSemaphoreGive(main_i2c_mutex);
 
     if (ret != ESP_OK) {
         ESP_LOGE(TAG, "Failed to write to LCD: %s", esp_err_to_name(ret));

main/drivers/i2c_lcd_pcf8574.h

@@ -91,7 +91,7 @@ void lcd_autoscroll(i2c_lcd_pcf8574_handle_t* lcd);
 void lcd_no_autoscroll(i2c_lcd_pcf8574_handle_t* lcd);
 
 // Set backlight brightness
-void lcd_set_backlight_to(i2c_lcd_pcf8574_handle_t* lcd, uint8_t brightness);
+void lcd_set_backlight(i2c_lcd_pcf8574_handle_t* lcd, uint8_t brightness);
 
 // Create a custom character
 void lcd_create_char(i2c_lcd_pcf8574_handle_t* lcd, uint8_t location, const uint8_t charmap[]);

main/drivers/inputs.cpp

@@ -0,0 +1,486 @@
+#include "blk_box_drivers/inputs.hpp"
+
+#include "bottom_half.h"
+#include "pins.h"
+#include "driver/i2c.h"
+#include "driver/gpio.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "esp_log.h"
+#include "esp_err.h"
+
+static const char *TAG = "INPUTS";
+
+static TaskHandle_t expander_task_handle = NULL;
+
+static i2c_master_dev_handle_t expander_i2c_dev_handle;
+
+const static uint8_t REG_WHOAMI = 0x01;
+const static uint8_t REG_SW_VERSION = 0x02;
+const static uint8_t REG_EVENT_QUEUE_POP = 0x10;
+const static uint8_t REG_EVENT_QUEUE_LEN = 0x11;
+const static uint8_t REG_STATE_BUTTONS = 0x20;
+const static uint8_t REG_STATE_SWITCHES = 0x21;
+const static uint8_t REG_STATE_KEYPAD = 0x22;
+const static uint8_t REG_STATE_TOUCH = 0x23;
+const static uint8_t REG_STATE_RFID = 0x24;
+const static uint8_t REG_STATE_HALL = 0x25;
+const static uint8_t REG_STATE_CLOSE = 0x26;
+const static uint8_t REG_RESET = 0x30;
+const static uint8_t REG_HALL_SENSITIVITY = 0x31;
+const static uint8_t REG_CLOSE_SENSITIVITY = 0x32;
+const static uint8_t REG_SWITCH_TOUCH_EVENT = 0x33;
+
+/// The global data for the expander peripheral.
+class ExpanderPeripheral {
+    // TODO: change these to private
+    // or even make this class hidden
+    public: 
+    SemaphoreHandle_t state_mutex;
+    InputsState state;
+
+    // channels
+    QueueHandle_t button_press_events;
+    QueueHandle_t button_release_events;
+    QueueHandle_t switch_flip_events;
+    QueueHandle_t switch_touch_events;
+    QueueHandle_t touch_events;
+    QueueHandle_t keypad_press_events;
+    QueueHandle_t keypad_release_events;
+};
+
+ExpanderPeripheral expander_peripheral_singleton;
+
+// forward declarations
+static void get_events();
+static void handle_event(uint8_t event);
+static void handle_button_switch_event(uint8_t event);
+static void handle_keypad_event(uint8_t event);
+static void handle_touch_event(uint8_t event);
+static void handle_rfid_event(uint8_t event);
+static void handle_close_hal_event(uint8_t event);
+static void expander_task(void *arg);
+
+// ISR handler
+static void IRAM_ATTR expander_isr_handler(void *arg) {
+    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
+
+    if (expander_task_handle != NULL) {
+        vTaskNotifyGiveFromISR(expander_task_handle, &xHigherPriorityTaskWoken);
+    }
+
+    if (xHigherPriorityTaskWoken == pdTRUE) {
+        portYIELD_FROM_ISR();
+    }
+}
+
+void init_expander() {
+    ESP_LOGI(TAG, "Initializing expander...");
+
+    i2c_device_config_t dev_config = {
+        .dev_addr_length = I2C_ADDR_BIT_LEN_7,
+        .device_address = EXPANDER_I2C_ADDR,
+        .scl_speed_hz = EXPANDER_I2C_SPEED,
+        .scl_wait_us = 0, // default
+        .flags = {
+            .disable_ack_check = 0,
+        }
+    };
+
+    // setup interrupt on BOTTOM_PIN_INTERUPT
+    gpio_config_t io_conf = {
+        .pin_bit_mask = (1ULL << BOTTOM_PIN_INTERUPT),
+        .mode = GPIO_MODE_INPUT,
+        .pull_up_en = GPIO_PULLUP_ENABLE,
+        .pull_down_en = GPIO_PULLDOWN_DISABLE,
+        .intr_type = GPIO_INTR_NEGEDGE
+    };
+
+    ESP_ERROR_CHECK(gpio_config(&io_conf));
+
+    // Install ISR service (only call once in your program)
+    ESP_ERROR_CHECK(gpio_install_isr_service(0));
+
+    // Attach the ISR to the expander pin
+    ESP_ERROR_CHECK(gpio_isr_handler_add(BOTTOM_PIN_INTERUPT, expander_isr_handler, NULL));
+
+    // verify the expander connection status by reading the WHOAMI register
+    uint8_t read_buf[2] = {0};
+
+    i2c_master_write_read_device(I2C_NUM_0, BOTTOM_I2C_ADDR, &REG_WHOAMI, 1, read_buf, 1, 1000);
+
+    if (read_buf[0] != EXPANDER_WHOAMI_VALUE) {
+        ESP_LOGE(TAG, "WHOAMI mismatch, expected 0x%02X, got 0x%02X", EXPANDER_WHOAMI_VALUE, read_buf[0]);
+        return;
+    }
+
+    ESP_LOGD(TAG, "Expander WHOAMI check passed");
+
+    ESP_ERROR_CHECK(i2c_master_transmit_receive(expander_i2c_dev_handle, &REG_SW_VERSION, 1, read_buf, 2, EXPANDER_TIMEOUT_MS));
+
+    // init the peripheral struct
+    expander_peripheral_singleton.state_mutex = xSemaphoreCreateMutex();
+    expander_peripheral_singleton.button_press_events= xQueueCreate(EXPANDER_EVENT_QUEUE_SIZE, sizeof(Button));
+    expander_peripheral_singleton.button_release_events= xQueueCreate(EXPANDER_EVENT_QUEUE_SIZE, sizeof(Button));
+    expander_peripheral_singleton.switch_flip_events= xQueueCreate(EXPANDER_EVENT_QUEUE_SIZE, sizeof(SwitchFlip));
+    expander_peripheral_singleton.switch_touch_events= xQueueCreate(EXPANDER_EVENT_QUEUE_SIZE, sizeof(SwitchTouch));
+    expander_peripheral_singleton.touch_events= xQueueCreate(EXPANDER_EVENT_QUEUE_SIZE, sizeof(TouchedReleased));
+    expander_peripheral_singleton.keypad_press_events= xQueueCreate(EXPANDER_KEYPAD_QUEUE_SIZE, sizeof(KeypadKey));
+    expander_peripheral_singleton.keypad_release_events= xQueueCreate(EXPANDER_KEYPAD_QUEUE_SIZE, sizeof(KeypadKey));
+
+    ESP_LOGI(TAG, "Expander initialized! SW version: v%d.%d", read_buf[0], read_buf[1]);
+
+    // Create the expander background worker task
+    BaseType_t task_created = xTaskCreate(
+        expander_task,
+        "expander_task",
+        4096,
+        NULL,
+        tskIDLE_PRIORITY + 1,
+        &expander_task_handle
+    );
+
+    if (task_created != pdPASS) {
+        ESP_LOGE(TAG, "Failed to create expander task");
+    }
+}
+
+static void expander_task(void *arg) {
+    (void)arg;
+
+    while (true) {
+        get_events();
+
+        // Wait for interrupt notification (signal is sent when INT falls)
+        ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
+    }
+}
+
+static void get_events() {
+    uint8_t recv;
+    while (gpio_get_level(PIN_EXPANDER_INT) == 0) {
+        ESP_ERROR_CHECK(i2c_master_transmit_receive(expander_i2c_dev_handle, &REG_EVENT_QUEUE_POP, 1, &recv, 1, EXPANDER_TIMEOUT_MS));
+        handle_event(recv);
+    }
+}
+
+static void handle_event(uint8_t event) {
+    const uint8_t BUTTON_SWITCH = 0b000;
+    const uint8_t KEYPAD = 0b001;
+    const uint8_t TOUCH = 0b010;
+    const uint8_t RFID = 0b011;
+
+    ESP_LOGD(TAG, "Expander event: 0b%08b (0x%02X)", event, event);
+
+    if (event == 0) {
+        ESP_LOGE(TAG, "We read from event queue while it was empty!");
+        return;
+    }
+
+    uint8_t type_bits = event >> 5;
+
+    switch (type_bits) {
+        case BUTTON_SWITCH:
+            handle_button_switch_event(event);
+            break;
+        case KEYPAD:
+            handle_keypad_event(event);
+            break;
+        case TOUCH:
+            handle_touch_event(event);
+            break;
+        case RFID:
+            handle_rfid_event(event);
+            break;
+        default:
+            handle_close_hal_event(event);
+            break;
+    }
+}
+
+static void handle_button_switch_event(uint8_t event) {
+    const uint8_t PRESSED_NOT_RELEASED_BIT = 0b10000;
+    const uint8_t SWITCH_NOT_BUTTON_BIT = 0b01000;
+    const uint8_t SWITCH_UP_NOT_DOWN_BIT = 0b00100;
+    const uint8_t NUMBER_MASK = 0b00011;
+
+    bool pressed = (event & PRESSED_NOT_RELEASED_BIT) != 0;
+    uint8_t number = event & NUMBER_MASK;
+
+    if ((event & SWITCH_NOT_BUTTON_BIT) != 0) {
+        // For now, we support two position switches by only looking at the switch up events
+        bool switch_up = (event & SWITCH_UP_NOT_DOWN_BIT) != 0;
+        if (!switch_up) {
+            return;
+        }
+
+        Switch sw = static_cast<Switch>(number);
+        SwitchFlip sw_flip = SwitchFlip(sw, pressed);
+        xQueueSendToBack(expander_peripheral_singleton.switch_flip_events, &sw_flip, 0);
+        xSemaphoreTake(expander_peripheral_singleton.state_mutex, portMAX_DELAY);
+        if (pressed) {
+            // set
+            expander_peripheral_singleton.state.switch_state |= 1 << number;
+        } else {
+            // clear
+            expander_peripheral_singleton.state.switch_state &= ~(1 << number);
+        }
+        xSemaphoreGive(expander_peripheral_singleton.state_mutex);
+    } else {
+        // button
+        Button button = static_cast<Button>(number);
+        if (pressed) {
+            xQueueSendToBack(expander_peripheral_singleton.button_press_events, &button, 0);
+            xSemaphoreTake(expander_peripheral_singleton.state_mutex, portMAX_DELAY);
+            expander_peripheral_singleton.state.button_state |= 1 << number;
+            xSemaphoreGive(expander_peripheral_singleton.state_mutex);
+        } else {
+            xQueueSendToBack(expander_peripheral_singleton.button_release_events, &button, 0);
+            xSemaphoreTake(expander_peripheral_singleton.state_mutex, portMAX_DELAY);
+            expander_peripheral_singleton.state.button_state &= ~(1 << number);
+            xSemaphoreGive(expander_peripheral_singleton.state_mutex);
+        }
+    }
+}
+
+static void handle_keypad_event(uint8_t event) {
+    const uint8_t PRESSED_NOT_RELEASED_BIT = 0b10000;
+    const uint8_t KEY_MASK = 0b1111;
+
+    bool pressed = (event & PRESSED_NOT_RELEASED_BIT) != 0;
+    uint8_t number = event & KEY_MASK;
+    KeypadKey key = static_cast<KeypadKey>(number);
+
+    // starcode system gets first dibs
+    // TODO: do starcode inbetweener
+    // if starcode_handle_keypad(key, pressed).await {
+    //     return;
+    // }
+
+    if (pressed) {
+        xQueueSendToBack(expander_peripheral_singleton.keypad_press_events, &key, 0);
+        xSemaphoreTake(expander_peripheral_singleton.state_mutex, portMAX_DELAY);
+        expander_peripheral_singleton.state.keypad_state |= 1 << number;
+        xSemaphoreGive(expander_peripheral_singleton.state_mutex);
+    } else {
+        xQueueSendToBack(expander_peripheral_singleton.keypad_release_events, &key, 0);
+        xSemaphoreTake(expander_peripheral_singleton.state_mutex, portMAX_DELAY);
+        expander_peripheral_singleton.state.keypad_state &= ~(1 << number);
+        xSemaphoreGive(expander_peripheral_singleton.state_mutex);
+    }
+}
+
+static void handle_touch_event(uint8_t event) {
+    const uint8_t TOUCHED_NOT_UNTOUCHED_BIT = 0b10000;
+    const uint8_t SENSOR_MASK = 0b0111;
+    const uint8_t FINGERPRINT_BIT = 0b0100;
+
+    bool touched = (event & TOUCHED_NOT_UNTOUCHED_BIT) != 0;
+    uint8_t sensor = event & SENSOR_MASK;
+
+    if ((sensor & FINGERPRINT_BIT) != 0) {
+        TouchedReleased touch_state = static_cast<TouchedReleased>(touched);
+        xQueueSendToBack(expander_peripheral_singleton.touch_events, &touch_state, 0);
+    } else {
+        Switch sw = static_cast<Switch>(sensor);
+        SwitchTouch sw_touch = SwitchTouch(sw, touched);
+        xQueueSendToBack(expander_peripheral_singleton.switch_touch_events, &sw_touch, 0);
+    }
+
+    xSemaphoreTake(expander_peripheral_singleton.state_mutex, portMAX_DELAY);
+    if (touched) {
+        expander_peripheral_singleton.state.touch_state |= 1 << sensor;
+    } else {
+        expander_peripheral_singleton.state.touch_state &= ~(1 << sensor);
+    }
+    xSemaphoreGive(expander_peripheral_singleton.state_mutex);
+}
+
+static void handle_rfid_event(uint8_t event) {
+    // TODO: impl
+    (void)event;
+}
+
+static void handle_close_hal_event(uint8_t event) {
+    // TODO: impl
+    (void)event;
+}
+
+// InputsController implementations
+
+/// Clears all events waiting in the queues.
+void InputsController::clear_all_events() {
+    xQueueReset(expander_peripheral_singleton.button_press_events);
+    xQueueReset(expander_peripheral_singleton.button_release_events);
+    xQueueReset(expander_peripheral_singleton.switch_flip_events);
+    xQueueReset(expander_peripheral_singleton.switch_touch_events);
+    xQueueReset(expander_peripheral_singleton.touch_events);
+    xQueueReset(expander_peripheral_singleton.keypad_press_events);
+    xQueueReset(expander_peripheral_singleton.keypad_release_events);
+}
+
+InputsState InputsController::get_input_state() {
+    xSemaphoreTake(expander_peripheral_singleton.state_mutex, portMAX_DELAY);
+    InputsState state_copy = expander_peripheral_singleton.state;
+    xSemaphoreGive(expander_peripheral_singleton.state_mutex);
+    return state_copy;
+}
+
+/// Returns `true` iff there is a button press event waiting.
+bool InputsController::has_button_press() {
+    return uxQueueMessagesWaiting(expander_peripheral_singleton.button_press_events) > 0;
+}
+
+/// Gets the next button press event (if any).
+std::optional<Button> InputsController::get_button_press() {
+    Button b;
+    if (xQueueReceive(expander_peripheral_singleton.button_press_events, &b, 0) == pdTRUE) {
+        return b;
+    }
+    return std::nullopt;
+}
+
+/// Gets the next button press event, waiting if neccesary.
+Button InputsController::wait_button_press() {
+    Button b;
+    xQueueReceive(expander_peripheral_singleton.button_press_events, &b, portMAX_DELAY);
+    return b;
+}
+
+/// Gets the current state of the buttons.
+uint8_t InputsController::button_state() {
+    xSemaphoreTake(expander_peripheral_singleton.state_mutex, portMAX_DELAY);
+    uint8_t value = expander_peripheral_singleton.state.button_state;
+    xSemaphoreGive(expander_peripheral_singleton.state_mutex);
+    return value;
+}
+
+/// Returns `true` iff there is a button release event waiting.
+bool InputsController::has_button_release() {
+    return uxQueueMessagesWaiting(expander_peripheral_singleton.button_release_events) > 0;
+}
+
+/// Gets the next button release event (if any).
+std::optional<Button> InputsController::get_button_release() {
+    Button b;
+    if (xQueueReceive(expander_peripheral_singleton.button_release_events, &b, 0) == pdTRUE) {
+        return b;
+    }
+    return std::nullopt;
+}
+
+/// Gets the next button release event, waiting if neccesary.
+Button InputsController::wait_button_release() {
+    Button b;
+    xQueueReceive(expander_peripheral_singleton.button_release_events, &b, portMAX_DELAY);
+    return b;
+}
+
+/// Returns `true` iff there is a switch flip event waiting.
+bool InputsController::has_switch_flip() {
+    return uxQueueMessagesWaiting(expander_peripheral_singleton.switch_flip_events) > 0;
+}
+
+/// Gets the next switch flip event (if any).
+std::optional<SwitchFlip> InputsController::get_switch_flip() {
+    SwitchFlip s;
+    if (xQueueReceive(expander_peripheral_singleton.switch_flip_events, &s, 0) == pdTRUE) {
+        return s;
+    }
+    return std::nullopt;
+}
+
+/// Gets the next switch flip event, waiting if neccesary.
+SwitchFlip InputsController::wait_switch_flip() {
+    SwitchFlip s;
+    xQueueReceive(expander_peripheral_singleton.switch_flip_events, &s, portMAX_DELAY);
+    return s;
+}
+
+/// Gets the current state of the switches.
+uint8_t InputsController::switch_state() {
+    xSemaphoreTake(expander_peripheral_singleton.state_mutex, portMAX_DELAY);
+    uint8_t value = expander_peripheral_singleton.state.switch_state;
+    xSemaphoreGive(expander_peripheral_singleton.state_mutex);
+    return value;
+}
+
+/// Returns `true` iff there is a switch touch event waiting.
+bool InputsController::has_switch_touch() {
+    return uxQueueMessagesWaiting(expander_peripheral_singleton.switch_touch_events) > 0;
+}
+
+/// Gets the next switch touch event (if any).
+std::optional<SwitchTouch> InputsController::get_switch_touch() {
+    SwitchTouch s;
+    if (xQueueReceive(expander_peripheral_singleton.switch_touch_events, &s, 0) == pdTRUE) {
+        return s;
+    }
+    return std::nullopt;
+}
+
+/// Gets the next switch touch event, waiting if neccesary.
+SwitchTouch InputsController::wait_switch_touch() {
+    SwitchTouch s;
+    xQueueReceive(expander_peripheral_singleton.switch_touch_events, &s, portMAX_DELAY);
+    return s;
+}
+
+/// Gets the current state of the touch sensors.
+uint8_t InputsController::switch_touch_state() {
+    xSemaphoreTake(expander_peripheral_singleton.state_mutex, portMAX_DELAY);
+    uint8_t value = expander_peripheral_singleton.state.touch_state;
+    xSemaphoreGive(expander_peripheral_singleton.state_mutex);
+    return value;
+}
+
+/// Returns `true` iff there is a keypad press event waiting.
+bool InputsController::has_keypad_press() {
+    return uxQueueMessagesWaiting(expander_peripheral_singleton.keypad_press_events) > 0;
+}
+
+/// Gets the next keypad press event (if any).
+std::optional<KeypadKey> InputsController::get_keypad_press() {
+    KeypadKey k;
+    if (xQueueReceive(expander_peripheral_singleton.keypad_press_events, &k, 0) == pdTRUE) {
+        return k;
+    }
+    return std::nullopt;
+}
+
+/// Gets the next keypad press event, waiting if neccesary.
+KeypadKey InputsController::wait_keypad_press() {
+    KeypadKey k;
+    xQueueReceive(expander_peripheral_singleton.keypad_press_events, &k, portMAX_DELAY);
+    return k;
+}
+
+/// Returns `true` iff there is a keypad release event waiting.
+bool InputsController::has_keypad_release() {
+    return uxQueueMessagesWaiting(expander_peripheral_singleton.keypad_release_events) > 0;
+}
+
+/// Gets the next keypad release event (if any).
+std::optional<KeypadKey> InputsController::get_keypad_release() {
+    KeypadKey k;
+    if (xQueueReceive(expander_peripheral_singleton.keypad_release_events, &k, 0) == pdTRUE) {
+        return k;
+    }
+    return std::nullopt;
+}
+
+/// Gets the next keypad release event, waiting if neccesary.
+KeypadKey InputsController::wait_keypad_release() {
+    KeypadKey k;
+    xQueueReceive(expander_peripheral_singleton.keypad_release_events, &k, portMAX_DELAY);
+    return k;
+}
+
+/// Gets the current state of the keypad.
+uint16_t InputsController::keypad_state() {
+    xSemaphoreTake(expander_peripheral_singleton.state_mutex, portMAX_DELAY);
+    uint16_t value = expander_peripheral_singleton.state.keypad_state;
+    xSemaphoreGive(expander_peripheral_singleton.state_mutex);
+    return value;
+}
+

main/drivers/nvs.cpp

@@ -1,63 +0,0 @@
-#include "nvs.h"
-#include "esp_log.h"
-#include "bottom_half.h"
-#include "char_lcd.h"
-
-static const char* TAG = "nvs";
-
-static const char* HWDATA_NAMESPACE = "hwdata";
-static HWData hw_data;
-
-bool init_nvs() {
-    ESP_LOGI(TAG, "Initializing NVS...");
-    esp_err_t ret = nvs_flash_init();
-    if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
-        // NVS partition was truncated, erase and retry
-        ESP_LOGE(TAG, "Failed to init nvs flash: %s.", esp_err_to_name(ret));
-        lcd_print(1, 0, "NVS: ");
-        lcd_print(1, 4, esp_err_to_name(ret));
-        lcd_print(2, 0, "Press Yellow to skip");
-        lcd_print(3, 0, "Press Red to erase");
-
-        ButtonKey button;
-        while (!( get_button_pressed(&button) && (button == ButtonKey::button_red || button == ButtonKey::button_yellow) )) vTaskDelay(pdMS_TO_TICKS(10));
-
-        lcd_clear();
-        
-        if (button == ButtonKey::button_yellow) {
-            return false;
-        }
-        if (button == ButtonKey::button_red) {
-            ESP_ERROR_CHECK(nvs_flash_erase());
-            ret = nvs_flash_init();
-        }
-    }
-    ESP_ERROR_CHECK(ret);
-
-    nvs_handle_t hw_handle;
-    ret = nvs_open(HWDATA_NAMESPACE, NVS_READONLY, &hw_handle);
-    if (ret == ESP_ERR_NVS_NOT_FOUND) {
-        ESP_LOGW(TAG, "Partition \"%s\" has not been initialized. Loading defaults.", HWDATA_NAMESPACE);
-        hw_data = HWData();
-    } else {
-        ESP_ERROR_CHECK(ret);
-        hw_data = HWData::load(hw_handle);
-        nvs_close(hw_handle);
-    }
-
-    ESP_LOGI(TAG, "NVS initialized!");
-
-    return true;
-}
-
-HWData& get_hw_data() {
-    return hw_data;
-}
-
-void save_hw_data(bool force) {
-    nvs_handle_t hw_handle;
-    ESP_ERROR_CHECK(nvs_open(HWDATA_NAMESPACE, NVS_READWRITE, &hw_handle));
-    hw_data.save(hw_handle);
-    nvs_close(hw_handle);
-}
-

main/drivers/nvs.h

@@ -1,13 +0,0 @@
-#ifndef NVS_H
-#define NVS_H
-
-#include "nvs_flash.h"
-#include "hwdata.h"
-
-/// @brief Initializes the NVS.
-bool init_nvs();
-
-/// Gets the HWData stored in NVS.
-HWData& get_hw_data();
-
-#endif /* NVS_H */

main/drivers/power.cpp

@@ -12,9 +12,9 @@ void bat_monitor_task(void* arg) {
         sprintf(str_buf, "%d.%03dV", voltage / 1000, voltage % 1000);
 
         lcd_clear();
-        lcd_print(0, 1, str_buf);
+        lcd_print(1, 0, str_buf);
 
-        int16_t current = lipo.current();
+        int16_t current = lipo.current(current_measure::AVG);
         sprintf(str_buf, "%dmA", current);
 
         lcd_print(1, 1, str_buf);
@@ -23,12 +23,12 @@ void bat_monitor_task(void* arg) {
         int16_t total_cap = lipo.capacity(capacity_measure::FULL);
         sprintf(str_buf, "%dmAh", total_cap);
 
-        lcd_print(2, 1, str_buf);
+        lcd_print(1, 2, str_buf);
 
         int16_t soc = lipo.soc(soc_measure::FILTERED);
         sprintf(str_buf, "%d%%", soc);
 
-        lcd_print(3, 1, str_buf);
+        lcd_print(1, 3, str_buf);
 
 
         vTaskDelay(pdMS_TO_TICKS(250));
@@ -60,7 +60,7 @@ void lcd_print_header_bat() {
     if (lcd_starcode_displaying_result()) return;
     
     uint8_t soc = lipo.soc();
-    int16_t current = lipo.current();
+    uint8_t current = lipo.current();
     char buf[6];
     if (soc < 5 && current <= 0) {
         snprintf(buf, sizeof(buf), " LOW");
@@ -74,5 +74,5 @@ void lcd_print_header_bat() {
         }
     }
 
-    lcd_print(0, 16, buf);
+    lcd_print(16, 0, buf);
 }

main/drivers/sd.cpp

@@ -51,10 +51,10 @@ bool init_sd() {
         ESP_LOGE(TAG, "Failed to mount sd card: %s.", esp_err_to_name(ret));
 
         lcd_print(0, 0, "SD: ");
-        lcd_print(0, 4, esp_err_to_name(ret));
+        lcd_print(4, 0, esp_err_to_name(ret));
-        lcd_print(1, 0, "Press Green to retry");
+        lcd_print(0, 1, "Press Green to retry");
-        lcd_print(2, 0, "Press Yellow to skip");
+        lcd_print(0, 2, "Press Yellow to skip");
-        lcd_print(3, 0, "Press Red to format");
+        lcd_print(0, 3, "Press Red to format");
 
         ButtonKey button;
         while (!( get_button_pressed(&button) && (button == ButtonKey::button_green || button == ButtonKey::button_red || button == ButtonKey::button_yellow) )) vTaskDelay(pdMS_TO_TICKS(10));

main/drivers/wires.cpp

@@ -85,7 +85,7 @@ void clear_wires_pressed_released_cut(void) {
 
 void strike(const char* reason) {
     ESP_LOGW("strike!", "%s", reason);
-    lcd_print(3, 0, reason);
+    lcd_print(0, 3, reason);
     time_penalty(STRIKE_TIME_PENALTY);
     if (current_step > 0 && current_step <= N_STEPS) {
         total_strikes += 1;

main/steps/setup_wires.cpp

@@ -11,7 +11,7 @@ void print_wires(WireColor* wires, int editing_idx) {
     lcd_print(1, 1, string_buf);
 
     cut_to_string(cut, string_buf);
-    lcd_print(2, 1, string_buf);
+    lcd_print(1, 2, string_buf);
 
     wires_state = get_wires();
     for (int i = 0; i < NUM_WIRES; i++) {
@@ -21,10 +21,9 @@ void print_wires(WireColor* wires, int editing_idx) {
             string_buf[i] = '!';
         }
     }
-    lcd_print(3, 1, string_buf);
+    lcd_print(1, 3, string_buf);
 
-    // TODO: find a way to indicate without a cursor.
+    lcd_set_cursor_pos(editing_idx+1, 1);
-    // lcd_set_cursor_pos(editing_idx+1, 1);
 }
 
 void setup_wires(void) {

main/steps/step0.cpp

@@ -34,9 +34,6 @@ static void battery_stats() {
         vTaskDelete(xHandle);
     }
 }
-static void hardware_config() {
-    
-}
 
 // TODO: remove. This is temperary
 static void replay_last() {
@@ -67,17 +64,10 @@ void step0() {
             .callback = nullptr,
             .triggered_sem = continue_sem,
         },
-        {
-            .code = "59860",
-            .display_text = "Hardware Config",
-            .delay_us = 2'000'000,
-            .callback = hardware_config,
-            .triggered_sem = nullptr,
-        },
         {
             .code = "59861",
             .display_text = "Setup Wires",
-            .delay_us = 2'000'000,
+            .delay_us = 10'000'000,
             .callback = setup_wires,
             .triggered_sem = nullptr,
         },
@@ -224,8 +214,7 @@ static void _update_display(uint8_t* digits, uint8_t cursor_pos) {
     lcd_print(1, 1, str_buf);
     cursor_pos = MAX(0, MIN(4, cursor_pos));
     int mapped_cursor_pos = CURSOR_POS_MAP[cursor_pos];
-    // TODO: find some way to indicate without a cursor.
+    lcd_set_cursor_pos(mapped_cursor_pos, 1);
-    // lcd_set_cursor_pos(mapped_cursor_pos, 1);
 }
 
 static void set_game_time() {
@@ -346,32 +335,32 @@ static void debug_switches() {
     while (1) {
         if (get_button_pressed(&button)) {
             sprintf(buf, "Button Pressed: %d ", button);
-            lcd_print(3, 0, buf);
+            lcd_print(0, 3, buf);
             ESP_LOGI(TAG, "%s", buf);
         }
         if (get_button_released(&button)) {
             sprintf(buf, "Button Released: %d", button);
-            lcd_print(3, 0, buf);
+            lcd_print(0, 3, buf);
             ESP_LOGI(TAG, "%s", buf);
         }
         if (get_switch_flipped_down(&switch_)) {
             sprintf(buf, "Switch Down: %d    ", switch_);
-            lcd_print(3, 0, buf);
+            lcd_print(0, 3, buf);
             ESP_LOGI(TAG, "%s", buf);
         }
         if (get_switch_flipped_up(&switch_)) {
             sprintf(buf, "Switch Up: %d      ", switch_);
-            lcd_print(3, 0, buf);
+            lcd_print(0, 3, buf);
             ESP_LOGI(TAG, "%s", buf);
         }
         if (get_switch_touch_pressed(&switch_)) {
             sprintf(buf, "Switch Touch: %d   ", switch_);
-            lcd_print(3, 0, buf);
+            lcd_print(0, 3, buf);
             ESP_LOGI(TAG, "%s", buf);
         }
         if (get_switch_touch_released(&switch_)) {
             sprintf(buf, "Switch Un-touch: %d", switch_);
-            lcd_print(3, 0, buf);
+            lcd_print(0, 3, buf);
             ESP_LOGI(TAG, "%s", buf);
         }
 
@@ -380,7 +369,7 @@ static void debug_switches() {
             switch_touch_state = new_switch_touch_state;
             print_4bin_rev(bin_buf, switch_touch_state);
             sprintf(buf, "t: %s", bin_buf);
-            lcd_print(0, 1, buf);
+            lcd_print(1, 0, buf);
             ESP_LOGI(TAG, "%s", buf);
         }
 
@@ -398,7 +387,7 @@ static void debug_switches() {
             button_state = new_button_state;
             print_4bin_rev(bin_buf, button_state);
             sprintf(buf, "b: %s", bin_buf);
-            lcd_print(2, 1, buf);
+            lcd_print(1, 2, buf);
             ESP_LOGI(TAG, "%s", buf);
         }
         

main/steps/step1.cpp

@@ -199,7 +199,7 @@ static int generate_part(void) {
 static void update_lcd_count(int times) {
     char buf[16] = {0};
     sprintf(buf, "%d/15", times);
-    lcd_print(1, 14, buf);
+    lcd_print(14, 1, buf);
 }
 
 static bool play_part(uint32_t time) {

main/steps/step5.cpp

@@ -729,7 +729,7 @@ void step5(void) {
                 }
 
                 // display expression
-                lcd_print(2, 1, display_expression.c_str());
+                lcd_print(1, 2, display_expression.c_str());
 
                 // set LEDs
                 const uint32_t COLORS[] = {
@@ -790,8 +790,8 @@ void step5(void) {
 
                         lcd_clear();
                         lcd_print(1, 1, "What");
-                        lcd_print(2, 1, display_expression.c_str());
+                        lcd_print(1, 2, display_expression.c_str());
-                        lcd_print(3, 1, entered_string.c_str());
+                        lcd_print(1, 3, entered_string.c_str());
                     }
                     if (get_module_time() <= 0) {
                         strike("Ran out of time!");
@@ -849,7 +849,7 @@ void step5(void) {
 
                     // ESP_LOGI(TAG, "color string: %s", color_string.c_str());
 
-                    lcd_print(2, 1, color_string.c_str());
+                    lcd_print(1, 2, color_string.c_str());
 
                     std::string entered_string;
 
@@ -880,8 +880,8 @@ void step5(void) {
 
                             lcd_clear();
                             lcd_print(1, 1, "Plink");
-                            lcd_print(2, 1, color_string.c_str());
+                            lcd_print(1, 2, color_string.c_str());
-                            lcd_print(3, 1, entered_string.c_str());
+                            lcd_print(1, 3, entered_string.c_str());
                         }
                         if (get_module_time() <= 0) {
                             strike("Ran out of time!");