feat: disable spin when bag is full, queue re-enabling

Author: shortcuts

pgpemu-esp32/main/log_tags.c

@@ -12,8 +12,9 @@ void log_levels_debug() {
     esp_log_level_set(CONFIG_SECRETS_TAG, ESP_LOG_DEBUG);
     esp_log_level_set(CONFIG_STORAGE_TAG, ESP_LOG_DEBUG);
     esp_log_level_set(HANDSHAKE_TAG, ESP_LOG_DEBUG);
-    esp_log_level_set(PGPEMU_TAG, ESP_LOG_DEBUG);
     esp_log_level_set(LEDHANDLER_TAG, ESP_LOG_DEBUG);
+    esp_log_level_set(PGPEMU_TAG, ESP_LOG_DEBUG);
+    esp_log_level_set(SETTINGS_TAG, ESP_LOG_DEBUG);
     esp_log_level_set(STATS_TAG, ESP_LOG_DEBUG);
     esp_log_level_set(UART_TAG, ESP_LOG_DEBUG);
 }
@@ -28,8 +29,9 @@ void log_levels_info() {
     esp_log_level_set(CONFIG_SECRETS_TAG, ESP_LOG_INFO);
     esp_log_level_set(CONFIG_STORAGE_TAG, ESP_LOG_INFO);
     esp_log_level_set(HANDSHAKE_TAG, ESP_LOG_INFO);
-    esp_log_level_set(PGPEMU_TAG, ESP_LOG_INFO);
     esp_log_level_set(LEDHANDLER_TAG, ESP_LOG_INFO);
+    esp_log_level_set(PGPEMU_TAG, ESP_LOG_INFO);
+    esp_log_level_set(SETTINGS_TAG, ESP_LOG_INFO);
     esp_log_level_set(STATS_TAG, ESP_LOG_INFO);
     esp_log_level_set(UART_TAG, ESP_LOG_INFO);
 }
@@ -44,8 +46,9 @@ void log_levels_verbose() {
     esp_log_level_set(CONFIG_SECRETS_TAG, ESP_LOG_VERBOSE);
     esp_log_level_set(CONFIG_STORAGE_TAG, ESP_LOG_VERBOSE);
     esp_log_level_set(HANDSHAKE_TAG, ESP_LOG_VERBOSE);
-    esp_log_level_set(PGPEMU_TAG, ESP_LOG_VERBOSE);
     esp_log_level_set(LEDHANDLER_TAG, ESP_LOG_VERBOSE);
+    esp_log_level_set(PGPEMU_TAG, ESP_LOG_VERBOSE);
+    esp_log_level_set(SETTINGS_TAG, ESP_LOG_VERBOSE);
     esp_log_level_set(STATS_TAG, ESP_LOG_VERBOSE);
     esp_log_level_set(UART_TAG, ESP_LOG_VERBOSE);
 }

pgpemu-esp32/main/log_tags.h

@@ -21,6 +21,7 @@ static const char CONFIG_STORAGE_TAG[] = "config_storage";
 static const char HANDSHAKE_TAG[] = "pgp_handshake";
 static const char LEDHANDLER_TAG[] = "pgp_led";
 static const char PGPEMU_TAG[] = "PGPEMU";
+static const char SETTINGS_TAG[] = "settings";
 static const char STATS_TAG[] = "stats";
 static const char UART_TAG[] = "uart_events";
 

pgpemu-esp32/main/pgp_autobutton.c

@@ -17,12 +17,17 @@ static void autobutton_task(void* pvParameters);
 
 bool init_autobutton() {
     button_queue = xQueueCreate(10, sizeof(button_queue_item_t));
-    if (button_queue == 0) {
-        ESP_LOGE(BUTTON_TASK_TAG, "%s creating button queue failed", __func__);
+    if (!button_queue) {
+        ESP_LOGE(SETTINGS_TAG, "%s creating button queue failed", __func__);
         return false;
     }
 
-    xTaskCreate(autobutton_task, "autobutton_task", 3072, NULL, 11, NULL);
+    BaseType_t ret = xTaskCreate(autobutton_task, "autobutton_task", 3072, NULL, 11, NULL);
+    if (ret != pdPASS) {
+        ESP_LOGE(SETTINGS_TAG, "%s creating task failed", __func__);
+        vQueueDelete(button_queue);
+        return false;
+    }
 
     return true;
 }

pgpemu-esp32/main/pgp_led_handler.c

@@ -8,6 +8,9 @@
 #include "log_tags.h"
 #include "pgp_autobutton.h"
 #include "settings.h"
+#include "uart.h"
+
+const int retoggle_delay = 300000;
 
 void handle_led_notify_from_app(esp_gatt_if_t gatts_if, uint16_t conn_id, const uint8_t* buffer) {
     int number_of_patterns = buffer[3] & 0x1f;
@@ -92,27 +95,54 @@ void handle_led_notify_from_app(esp_gatt_if_t gatts_if, uint16_t conn_id, const
         ESP_LOGD(LEDHANDLER_TAG, "[%d] Turn LEDs off.", conn_id);
     } else if (count_white && count_white == count_notoff) {
         // only white
-        ESP_LOGW(LEDHANDLER_TAG, "[%d] Can't spin Pokestop. Bag is full.", conn_id);
+        process_char('s');
+
+        ESP_LOGW(LEDHANDLER_TAG,
+            "[%d] Bag is full: press button %s - re-enabling autospin after %d ms",
+            conn_id,
+            get_setting_log_value(&settings.autospin),
+            retoggle_delay);
+
+        settings_queue_item_t item;
+        item.gatts_if = gatts_if;
+        item.conn_id = conn_id;
+        item.delay = retoggle_delay;
+        xQueueSend(settings_queue, &item, portMAX_DELAY);
     } else if (count_red && count_off && count_red == count_notoff) {
         // blinking just red
         ESP_LOGW(
             LEDHANDLER_TAG, "[%d] Pokeballs are empty or Pokestop went out of range.", conn_id);
     } else if (count_red && !count_off && count_red == count_notoff) {
         // only red
-        ESP_LOGW(LEDHANDLER_TAG, "[%d] Can't catch Pokemon. Box is full.", conn_id);
+        process_char('c');
+        ESP_LOGW(LEDHANDLER_TAG,
+            "[%d] Box is full: press button %s",
+            conn_id,
+            get_setting_log_value(&settings.autospin));
     } else if (count_green && count_green == count_notoff) {
         // blinking green
-        ESP_LOGI(LEDHANDLER_TAG, "[%d] Pokemon in range!", conn_id);
+        ESP_LOGI(LEDHANDLER_TAG,
+            "[%d] Pokemon in range: press button %s",
+            conn_id,
+            get_setting_log_value(&settings.autocatch));
         if (get_setting(&settings.autocatch)) {
             press_button = true;
         }
     } else if (count_yellow && count_yellow == count_notoff) {
         // blinking yellow
-        ESP_LOGI(LEDHANDLER_TAG, "[%d] New Pokemon in range!", conn_id);
-        press_button = true;
+        ESP_LOGI(LEDHANDLER_TAG,
+            "[%d] New pokemon in range: press button %s",
+            conn_id,
+            get_setting_log_value(&settings.autocatch));
+        if (get_setting(&settings.autocatch)) {
+            press_button = true;
+        }
     } else if (count_blue && count_blue == count_notoff) {
         // blinking blue
-        ESP_LOGI(LEDHANDLER_TAG, "[%d] Pokestop in range!", conn_id);
+        ESP_LOGI(LEDHANDLER_TAG,
+            "[%d] Pokestop in range: press button %s",
+            conn_id,
+            get_setting_log_value(&settings.autospin));
         if (get_setting(&settings.autospin)) {
             press_button = true;
         }

pgpemu-esp32/main/pgpemu.c

@@ -78,6 +78,12 @@ void app_main() {
     // runtime counter
     init_stats();
 
+    // start autosetting task
+    if (!init_autosetting()) {
+        ESP_LOGI(PGPEMU_TAG, "creating setting task failed");
+        return;
+    }
+
     // start autobutton task
     if (!init_autobutton()) {
         ESP_LOGI(PGPEMU_TAG, "creating button task failed");

pgpemu-esp32/main/settings.c

@@ -1,6 +1,8 @@
 #include "settings.h"
 
 #include "config_secrets.h"
+#include "esp_log.h"
+#include "log_tags.h"
 
 #include <stdint.h>
 
@@ -20,6 +22,45 @@ void init_settings() {
     xSemaphoreTake(settings.mutex, portMAX_DELAY);  // block until end of this function
 }
 
+QueueHandle_t settings_queue;
+
+static void autosettings_task(void* pvParameters);
+
+bool init_autosetting() {
+    settings_queue = xQueueCreate(10, sizeof(settings_queue_item_t));
+    if (!settings_queue) {
+        ESP_LOGE(SETTINGS_TAG, "%s creating settings queue failed", __func__);
+        return false;
+    }
+
+    BaseType_t ret = xTaskCreate(autosettings_task, "autosettings_task", 3072, NULL, 11, NULL);
+    if (ret != pdPASS) {
+        ESP_LOGE(SETTINGS_TAG, "%s creating task failed", __func__);
+        vQueueDelete(settings_queue);
+        return false;
+    }
+
+    return true;
+}
+
+static void autosettings_task(void* pvParameters) {
+    settings_queue_item_t item;
+
+    ESP_LOGI(SETTINGS_TAG, "task start");
+
+    while (1) {
+        if (xQueueReceive(settings_queue, &item, portMAX_DELAY)) {
+            ESP_LOGD(
+                SETTINGS_TAG, "[%d] toggling setting after delay=%d ms", item.conn_id, item.delay);
+            vTaskDelay(item.delay / portTICK_PERIOD_MS);
+
+            toggle_setting(&settings.autospin);
+        }
+    }
+
+    vTaskDelete(NULL);
+}
+
 void settings_ready() {
     xSemaphoreGive(settings.mutex);
 }
@@ -61,6 +102,10 @@ bool get_setting(bool* var) {
     return result;
 }
 
+char* get_setting_log_value(bool* var) {
+    return get_setting(var) ? "on" : "off";
+}
+
 uint8_t get_setting_uint8(uint8_t* var) {
     if (!var || !xSemaphoreTake(settings.mutex, portMAX_DELAY)) {
         return 0;

pgpemu-esp32/main/settings.h

@@ -1,6 +1,7 @@
 #ifndef SETTINGS_H
 #define SETTINGS_H
 
+#include "esp_gatt_defs.h"
 #include "freertos/FreeRTOS.h"
 #include "freertos/FreeRTOSConfig.h"
 #include "freertos/semphr.h"
@@ -29,11 +30,25 @@ typedef struct {
 
 extern Settings settings;
 
+typedef struct {
+    // which session does this belong to
+    esp_gatt_if_t gatts_if;
+    uint16_t conn_id;
+
+    // delay after which setting is toggled
+    int delay;
+} settings_queue_item_t;
+
+extern QueueHandle_t settings_queue;
+
+bool init_autosetting();
+
 void init_settings();
 void settings_ready();
 bool toggle_setting(bool* var);
 bool cycle_setting(uint8_t* var, uint8_t min, uint8_t max);
 bool get_setting(bool* var);
+char* get_setting_log_value(bool* var);
 uint8_t get_setting_uint8(uint8_t* var);
 bool set_setting_uint8(uint8_t* var, const uint8_t val);
 bool set_chosen_device(uint8_t id);

pgpemu-esp32/main/uart.c

@@ -59,7 +59,7 @@ void init_uart() {
     xTaskCreate(usb_console_task, "usb_console", 4096, NULL, 12, NULL);
 }
 
-static void process_char(uint8_t c) {
+void process_char(uint8_t c) {
     if (c == 't') {
         // show connection status
         dump_client_connection_times();
@@ -71,21 +71,19 @@ static void process_char(uint8_t c) {
         if (!toggle_setting(&settings.autospin)) {
             ESP_LOGE(UART_TAG, "failed!");
         }
-        ESP_LOGI(UART_TAG, "autospin %s", get_setting(&settings.autospin) ? "on" : "off");
+        ESP_LOGI(UART_TAG, "autospin %s", get_setting_log_value(&settings.autospin));
     } else if (c == 'c') {
         // toggle autocatch
         if (!toggle_setting(&settings.autocatch)) {
             ESP_LOGE(UART_TAG, "failed!");
         }
-        ESP_LOGI(UART_TAG, "autocatch %s", get_setting(&settings.autocatch) ? "on" : "off");
+        ESP_LOGI(UART_TAG, "autocatch %s", get_setting_log_value(&settings.autocatch));
     } else if (c == 'B') {
         // toggle input button
         if (!toggle_setting(&settings.use_button)) {
             ESP_LOGE(UART_TAG, "failed!");
         }
-        ESP_LOGI(UART_TAG,
-            "input button %s",
-            get_setting(&settings.use_button) ? "available" : "not available");
+        ESP_LOGI(UART_TAG, "input button %s", get_setting_log_value(&settings.use_button));
     } else if (c == 'l') {
         // cycle through log levels
         if (!cycle_setting(&settings.log_level, 1, 3)) {
@@ -167,9 +165,9 @@ static void process_char(uint8_t c) {
             "Log level: %d\n"
             "Chosen device #: %d - Name: %s\n"
             "Connections: %d / %d",
-            get_setting(&settings.autospin) ? "on" : "off",
-            get_setting(&settings.autocatch) ? "on" : "off",
-            get_setting(&settings.use_button) ? "available" : "not available",
+            get_setting_log_value(&settings.autospin),
+            get_setting_log_value(&settings.autocatch),
+            get_setting_log_value(&settings.use_button),
             get_setting_uint8(&settings.log_level),
             get_setting_uint8(&settings.chosen_device),
             PGP_CLONE_NAME,

pgpemu-esp32/main/uart.h

@@ -1,6 +1,9 @@
 #ifndef UART_H
 #define UART_H
 
+#include <stdint.h>
+
 void init_uart();
+void process_char(uint8_t);
 
 #endif /* UART_H */