main/drivers/CMakeLists.txt

@@ -16,7 +16,7 @@ set(SOURCES
     "sd.cpp"
     "speaker.cpp"
     "sseg.cpp"
-    "starcode.cpp"
+    "star_code.cpp"
     "state_tracking.cpp"
     "tft.cpp"
     "wires.cpp"

main/drivers/all.h

@@ -10,7 +10,7 @@
 #include "sd.h"
 #include "speaker.h"
 #include "sseg.h"
-#include "starcode.h"
+#include "star_code.h"
 #include "state_tracking.h"
 #include "tft.h"
 #include "wires.h"

main/drivers/bottom_half.cpp

@@ -1,7 +1,7 @@
 #include "bottom_half.h"
 #include <esp_log.h>
 #include "state_tracking.h"
-#include "starcode.h"
+#include "star_code.h"
 
 static const char *TAG = "bottom_half";
 

main/drivers/char_lcd.cpp

@@ -5,11 +5,10 @@
 #include "state_tracking.h"
 #include <cstring>
 #include "power.h"
-#include "starcode.h"
+#include "star_code.h"
 #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 col = atoi(str);
-        str = strtok(NULL, ",");
-        uint8_t row = atoi(str);
-        // get remaining part of string.
-        str = strtok(NULL, "");
-
         // TODO: handle \r and \n
-        lcd_print(col, row, 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(0, 1, EMPTY_ROW, true);
+        lcd_print(0, 2, EMPTY_ROW);
-        lcd_print(0, 2, EMPTY_ROW, true);
+        lcd_print(0, 3, EMPTY_ROW);
-        lcd_print(0, 3, 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,12 +228,8 @@ 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, 65,
@@ -246,16 +241,13 @@ void lcd_create_char(uint8_t location, const uint8_t charmap[], bool no_lock) {
 }
 
 // TODO: switch to row, col
-void lcd_print(uint8_t col, uint8_t row, const char* str, bool no_lock) {
+void lcd_print(uint8_t col, uint8_t row, const char* str) {
-    if (!no_lock) xSemaphoreTake(lcd_mutex, portMAX_DELAY);
+    lcd_set_cursor_pos(col, row);
-    lcd_set_cursor(&lcd, 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", col, row, str);
+        event_occured("LCD_PRINT", str);
-        event_occured("LCD_PRINT", buf);
     }
 }
 
@@ -292,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(6, 1, "\x01\x02Marino", true);
+    lcd_print(6, 1, "\x01\x02Marino");
-    lcd_print(5, 2, "\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

@@ -9,50 +9,51 @@
 #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 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 col, uint8_t row, 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

@@ -1,21 +1,24 @@
 #include "game_info.h"
-#include "starcode.h"
+#include "star_code.h"
 #include <stdio.h>
 #include "char_lcd.h"
 
-static char game_state[GAME_STATE_MAX_LEN+2] = " MENU ";
+static char game_state[GAME_STATE_MAX_LEN+1] = "MENU ";
 
-void set_game_state(const char* new_state) {
+void set_game_state(char* new_state) {
-    snprintf(game_state, sizeof(game_state), " %-5s", new_state);
+    snprintf(game_state, sizeof(game_state), "%-5s", new_state);
 }
 
 void reset_game_state() {
-    set_game_state("");
+    for (int i = 0; i < GAME_STATE_MAX_LEN; i++) {
+        game_state[i] = '\0';
+    }
+    game_state[GAME_STATE_MAX_LEN] = '\0';
 }
 
 void lcd_print_header_step() {
     if (!lcd_header_enabled()) return;
     if (lcd_starcode_displaying_result()) return;
 
-    lcd_print(10, 0, game_state);
+    lcd_print(11, 0, game_state);
 }

main/drivers/game_info.h

@@ -6,7 +6,7 @@
 /// @brief Sets the game state, used for the header.
 ///
 /// Must be <= 5 characters
-void set_game_state(const char* new_state);
+void set_game_state(char* new_state);
 
 /// @brief Resets the game state to be blank.
 void reset_game_state();

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/power.cpp

@@ -1,6 +1,6 @@
 #include "power.h"
 #include "char_lcd.h"
-#include "starcode.h"
+#include "star_code.h"
 #include <esp_log.h>
 
 static const char* TAG = "power";
@@ -61,18 +61,18 @@ void lcd_print_header_bat() {
     
     uint8_t soc = lipo.soc();
     uint8_t current = lipo.current();
-    char buf[6];
+    char buf[5];
     if (soc < 5 && current <= 0) {
-        snprintf(buf, sizeof(buf), " LOW");
+        snprintf(buf, sizeof(buf), "LOW");
     } else if (soc == 100) {
-        snprintf(buf, sizeof(buf), " 100");
+        snprintf(buf, sizeof(buf), "100");
     } else {
         if (current > 0) {
-            snprintf(buf, sizeof(buf), " %2d+", soc);
+            snprintf(buf, sizeof(buf), "%2d+", soc);
         } else {
-            snprintf(buf, sizeof(buf), " %2d%%", soc);
+            snprintf(buf, sizeof(buf), "%2d%%", soc);
         }
     }
 
-    lcd_print(16, 0, buf);
+    lcd_print(17, 0, buf);
 }

main/drivers/star_code.cpp

@@ -1,4 +1,4 @@
-#include "starcode.h"
+#include "star_code.h"
 #include <vector>
 #include <algorithm>
 #include <string.h>

main/steps/setup_wires.cpp

@@ -23,8 +23,7 @@ void print_wires(WireColor* wires, int editing_idx) {
     }
     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

@@ -214,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() {