#include #include #include "freertos/FreeRTOS.h" #include "freertos/task.h" #include "freertos/event_groups.h" #include "freertos/timers.h" #include "esp_system.h" #include "esp_wifi.h" #include "esp_event.h" #include "esp_log.h" #include "esp_http_server.h" #include "esp_task_wdt.h" #include "nvs_flash.h" #include "nvs.h" #include "driver/gpio.h" #include "driver/ledc.h" #include "cJSON.h" // Project configuration #include "config.h" // WiFi event group static EventGroupHandle_t s_wifi_event_group; static int s_retry_num = 0; // Motor control typedef enum { MOTOR_OFF, MOTOR_EXHAUST, MOTOR_INTAKE } motor_mode_t; typedef enum { MOTOR_STATE_IDLE, // Motor is off or running normally MOTOR_STATE_RAMPING, // Motor is ramping up/down MOTOR_STATE_STOPPING, // Motor is stopping for direction change MOTOR_STATE_COOLDOWN, // Motor is in cooldown period MOTOR_STATE_RESTARTING // Motor is restarting after cooldown } motor_state_enum_t; typedef struct { motor_mode_t mode; motor_mode_t pending_mode; // Mode to switch to after cooldown int target_speed; int pending_speed; // Speed to set after cooldown int current_speed; motor_state_enum_t state; bool ramping; TimerHandle_t ramp_timer; TimerHandle_t cooldown_timer; uint32_t cooldown_remaining_ms; // For status reporting // State preservation motor_mode_t last_on_mode; // Last non-OFF mode for ON button int last_on_speed; // Last non-zero speed for ON button bool user_turned_off; // Track if user manually turned off } motor_state_t; static motor_state_t motor_state = { .mode = MOTOR_OFF, .pending_mode = MOTOR_OFF, .target_speed = 0, .pending_speed = 0, .current_speed = 0, .state = MOTOR_STATE_IDLE, .ramping = false, .ramp_timer = NULL, .cooldown_timer = NULL, .cooldown_remaining_ms = 0, .last_on_mode = MOTOR_EXHAUST, // Default to exhaust for ON button .last_on_speed = 50, // Default to 50% for ON button .user_turned_off = false }; // HTTP server handle static httpd_handle_t server = NULL; // Task handles for watchdog static TaskHandle_t main_task_handle = NULL; // Compact HTML web page for control static const char* html_page = "Maxxfan

Maxxfan Controller

" "

Status

Mode: OFF

Speed: 0%

" "

Target: 0%

State: IDLE

" "

Last ON: EXHAUST @ 50%

" "

Ramping...

" "

Direction change cooldown: 0s

" "

Error

Connecting...

" "

Fan Control

" "" "" "

" "

Speed Control

Speed: 50%" "" "" "

" ""; // Forward declarations static void motor_ramp_timer_callback(TimerHandle_t xTimer); static void motor_cooldown_timer_callback(TimerHandle_t xTimer); static void apply_motor_pwm(int speed_percent); static void start_motor_operation(motor_mode_t mode, int speed_percent); static esp_err_t save_motor_state_to_nvs(void); static esp_err_t load_motor_state_from_nvs(void); static bool is_watchdog_reset(void); static void save_last_on_state(motor_mode_t mode, int speed); // Initialize watchdog timer void init_watchdog(void) { ESP_LOGI(SYSTEM_TAG, "Setting up watchdog monitoring..."); // Get current task handle and add to watchdog main_task_handle = xTaskGetCurrentTaskHandle(); esp_err_t result = esp_task_wdt_add(main_task_handle); if (result == ESP_OK) { ESP_LOGI(SYSTEM_TAG, "Main task added to watchdog monitoring"); } else if (result == ESP_ERR_INVALID_ARG) { ESP_LOGI(SYSTEM_TAG, "Task already monitored by watchdog"); } else { ESP_LOGW(SYSTEM_TAG, "Watchdog not available: %s", esp_err_to_name(result)); main_task_handle = NULL; // Disable watchdog feeding } } // Feed the watchdog void feed_watchdog(void) { if (main_task_handle != NULL) { esp_err_t result = esp_task_wdt_reset(); if (result != ESP_OK) { MOTOR_LOGD(SYSTEM_TAG, "Watchdog reset failed: %s", esp_err_to_name(result)); } } } // Check if this was a watchdog reset static bool is_watchdog_reset(void) { esp_reset_reason_t reset_reason = esp_reset_reason(); // Only consider TASK_WDT and INT_WDT as true watchdog resets // ESP_RST_WDT can be triggered by power disconnection, so we exclude it return (reset_reason == ESP_RST_TASK_WDT || reset_reason == ESP_RST_INT_WDT); } // Save motor state to NVS static esp_err_t save_motor_state_to_nvs(void) { nvs_handle_t nvs_handle; esp_err_t err; err = nvs_open(NVS_NAMESPACE, NVS_READWRITE, &nvs_handle); if (err != ESP_OK) { ESP_LOGE(SYSTEM_TAG, "Error opening NVS handle: %s", esp_err_to_name(err)); return err; } ESP_LOGI(SYSTEM_TAG, "=== SAVING STATE TO NVS ==="); ESP_LOGI(SYSTEM_TAG, "Mode: %d, Speed: %d%%, Last ON: %d@%d%%, User OFF: %s", motor_state.mode, motor_state.target_speed, motor_state.last_on_mode, motor_state.last_on_speed, motor_state.user_turned_off ? "YES" : "NO"); // Save current motor state err = nvs_set_u8(nvs_handle, NVS_KEY_MODE, (uint8_t)motor_state.mode); if (err == ESP_OK) { err = nvs_set_u8(nvs_handle, NVS_KEY_SPEED, (uint8_t)motor_state.target_speed); } // Save last ON state if (err == ESP_OK) { err = nvs_set_u8(nvs_handle, NVS_KEY_LAST_ON_MODE, (uint8_t)motor_state.last_on_mode); } if (err == ESP_OK) { err = nvs_set_u8(nvs_handle, NVS_KEY_LAST_ON_SPEED, (uint8_t)motor_state.last_on_speed); } // Save power state (whether user turned off manually) if (err == ESP_OK) { err = nvs_set_u8(nvs_handle, NVS_KEY_POWER_STATE, motor_state.user_turned_off ? 1 : 0); } if (err == ESP_OK) { err = nvs_commit(nvs_handle); if (err == ESP_OK) { ESP_LOGI(SYSTEM_TAG, "✓ Motor state successfully saved to NVS"); } else { ESP_LOGE(SYSTEM_TAG, "✗ NVS commit failed: %s", esp_err_to_name(err)); } } else { ESP_LOGE(SYSTEM_TAG, "✗ Error saving to NVS: %s", esp_err_to_name(err)); } ESP_LOGI(SYSTEM_TAG, "==========================="); nvs_close(nvs_handle); return err; } // Load motor state from NVS static esp_err_t load_motor_state_from_nvs(void) { nvs_handle_t nvs_handle; esp_err_t err; err = nvs_open(NVS_NAMESPACE, NVS_READONLY, &nvs_handle); if (err != ESP_OK) { ESP_LOGI(SYSTEM_TAG, "NVS not found, using default state"); return ESP_ERR_NVS_NOT_FOUND; } uint8_t stored_mode = 0; uint8_t stored_speed = 0; uint8_t stored_last_mode = 1; // Default to MOTOR_EXHAUST uint8_t stored_last_speed = 50; uint8_t stored_power_state = 0; // Load current motor state err = nvs_get_u8(nvs_handle, NVS_KEY_MODE, &stored_mode); if (err == ESP_OK) { nvs_get_u8(nvs_handle, NVS_KEY_SPEED, &stored_speed); nvs_get_u8(nvs_handle, NVS_KEY_LAST_ON_MODE, &stored_last_mode); nvs_get_u8(nvs_handle, NVS_KEY_LAST_ON_SPEED, &stored_last_speed); nvs_get_u8(nvs_handle, NVS_KEY_POWER_STATE, &stored_power_state); // Validate ranges using config macros if (stored_mode > MOTOR_INTAKE) stored_mode = MOTOR_OFF; if (!IS_VALID_SPEED(stored_speed)) stored_speed = 0; if (stored_last_mode < MOTOR_EXHAUST || stored_last_mode > MOTOR_INTAKE) stored_last_mode = MOTOR_EXHAUST; if (!IS_VALID_SPEED(stored_last_speed)) stored_last_speed = 50; motor_state.last_on_mode = (motor_mode_t)stored_last_mode; motor_state.last_on_speed = stored_last_speed; motor_state.user_turned_off = (stored_power_state == 1); ESP_LOGI(SYSTEM_TAG, "Loaded state from NVS - Mode: %d, Speed: %d%%, Last ON: %d@%d%%, User OFF: %s", stored_mode, stored_speed, motor_state.last_on_mode, motor_state.last_on_speed, motor_state.user_turned_off ? "YES" : "NO"); // Check reset reason to decide whether to restore state bool was_watchdog_reset = is_watchdog_reset(); esp_reset_reason_t reset_reason = esp_reset_reason(); ESP_LOGI(SYSTEM_TAG, "=== RESET ANALYSIS ==="); ESP_LOGI(SYSTEM_TAG, "Reset reason: %d", reset_reason); ESP_LOGI(SYSTEM_TAG, "Reset reason name: %s", reset_reason == ESP_RST_POWERON ? "POWERON" : reset_reason == ESP_RST_EXT ? "EXTERNAL" : reset_reason == ESP_RST_SW ? "SOFTWARE" : reset_reason == ESP_RST_PANIC ? "PANIC" : reset_reason == ESP_RST_INT_WDT ? "INT_WDT" : reset_reason == ESP_RST_TASK_WDT ? "TASK_WDT" : reset_reason == ESP_RST_WDT ? "WDT" : reset_reason == ESP_RST_DEEPSLEEP ? "DEEPSLEEP" : reset_reason == ESP_RST_BROWNOUT ? "BROWNOUT" : reset_reason == ESP_RST_SDIO ? "SDIO" : "UNKNOWN"); ESP_LOGI(SYSTEM_TAG, "Watchdog reset: %s", was_watchdog_reset ? "YES" : "NO"); ESP_LOGI(SYSTEM_TAG, "Stored mode: %d, speed: %d", stored_mode, stored_speed); ESP_LOGI(SYSTEM_TAG, "User turned off: %s", motor_state.user_turned_off ? "YES" : "NO"); ESP_LOGI(SYSTEM_TAG, "===================="); if (was_watchdog_reset) { // True watchdog reset (TASK_WDT or INT_WDT) - don't restore state, start fresh ESP_LOGI(SYSTEM_TAG, "⚠️ TRUE watchdog reset detected - starting in OFF state for safety"); motor_state.mode = MOTOR_OFF; motor_state.target_speed = 0; motor_state.current_speed = 0; motor_state.user_turned_off = false; // Reset user off flag } else if (motor_state.user_turned_off) { // User manually turned off - stay off ESP_LOGI(SYSTEM_TAG, "🔒 User had turned off manually - staying OFF"); motor_state.mode = MOTOR_OFF; motor_state.target_speed = 0; motor_state.current_speed = 0; } else if (stored_mode != MOTOR_OFF && stored_speed > 0) { // Normal power loss or general WDT (which can be power-related) - restore previous state ESP_LOGI(SYSTEM_TAG, "🔋 Power restored - will resume previous state: %s @ %d%%", stored_mode == MOTOR_EXHAUST ? "EXHAUST" : "INTAKE", stored_speed); motor_state.mode = (motor_mode_t)stored_mode; motor_state.target_speed = stored_speed; motor_state.current_speed = 0; // Always start ramping from 0 } else { ESP_LOGI(SYSTEM_TAG, "❌ No valid state to restore (mode=%d, speed=%d)", stored_mode, stored_speed); motor_state.mode = MOTOR_OFF; motor_state.target_speed = 0; motor_state.current_speed = 0; } } else { ESP_LOGI(SYSTEM_TAG, "No saved state found, using defaults"); err = ESP_ERR_NVS_NOT_FOUND; } nvs_close(nvs_handle); return err; } // Save the last ON state (for ON button functionality) static void save_last_on_state(motor_mode_t mode, int speed) { if (mode != MOTOR_OFF && speed > 0) { motor_state.last_on_mode = mode; motor_state.last_on_speed = speed; ESP_LOGI(SYSTEM_TAG, "Last ON state updated: %s @ %d%%", mode == MOTOR_EXHAUST ? "EXHAUST" : "INTAKE", speed); } } // WiFi event handler static void event_handler(void* arg, esp_event_base_t event_base, int32_t event_id, void* event_data) { if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_START) { esp_wifi_connect(); } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_DISCONNECTED) { if (s_retry_num < WIFI_MAXIMUM_RETRY) { esp_wifi_connect(); s_retry_num++; ESP_LOGI(SYSTEM_TAG, "retry to connect to the AP"); } else { xEventGroupSetBits(s_wifi_event_group, WIFI_FAIL_BIT); } ESP_LOGI(SYSTEM_TAG, "connect to the AP fail"); } else if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP) { ip_event_got_ip_t* event = (ip_event_got_ip_t*) event_data; ESP_LOGI(SYSTEM_TAG, "got ip:" IPSTR, IP2STR(&event->ip_info.ip)); s_retry_num = 0; xEventGroupSetBits(s_wifi_event_group, WIFI_CONNECTED_BIT); } } void configure_gpio_pins(void) { ESP_LOGI(SYSTEM_TAG, "Configuring GPIO pins..."); uint64_t pin_mask = (1ULL << LED_PIN) | (1ULL << MOTOR_R_EN) | (1ULL << MOTOR_L_EN); gpio_config_t io_conf = { .pin_bit_mask = pin_mask, .mode = GPIO_MODE_OUTPUT, .pull_up_en = GPIO_PULLUP_DISABLE, .pull_down_en = GPIO_PULLDOWN_DISABLE, .intr_type = GPIO_INTR_DISABLE }; gpio_config(&io_conf); gpio_set_level(LED_PIN, 0); gpio_set_level(MOTOR_R_EN, 0); gpio_set_level(MOTOR_L_EN, 0); ESP_LOGI(SYSTEM_TAG, "GPIO pins configured"); } void configure_pwm(void) { ESP_LOGI(SYSTEM_TAG, "Configuring PWM..."); ledc_timer_config_t timer_conf = { .speed_mode = PWM_SPEED_MODE, .timer_num = PWM_TIMER, .duty_resolution = PWM_RESOLUTION, .freq_hz = PWM_FREQUENCY, .clk_cfg = LEDC_AUTO_CLK }; ledc_timer_config(&timer_conf); ledc_channel_config_t channel_conf = { .channel = PWM_R_CHANNEL, .duty = 0, .gpio_num = PWM_R_PIN, .speed_mode = PWM_SPEED_MODE, .hpoint = 0, .timer_sel = PWM_TIMER }; ledc_channel_config(&channel_conf); channel_conf.channel = PWM_L_CHANNEL; channel_conf.gpio_num = PWM_L_PIN; ledc_channel_config(&channel_conf); ESP_LOGI(SYSTEM_TAG, "PWM configured"); } // Apply PWM to motor based on current mode and speed static void apply_motor_pwm(int speed_percent) { // Clamp speed to valid range using config macro speed_percent = CLAMP_SPEED(speed_percent); uint32_t duty = SPEED_TO_DUTY(speed_percent); if (motor_state.mode == MOTOR_OFF || speed_percent == 0) { gpio_set_level(LED_PIN, 0); gpio_set_level(MOTOR_R_EN, 0); gpio_set_level(MOTOR_L_EN, 0); ledc_set_duty(PWM_SPEED_MODE, PWM_R_CHANNEL, 0); ledc_set_duty(PWM_SPEED_MODE, PWM_L_CHANNEL, 0); ledc_update_duty(PWM_SPEED_MODE, PWM_R_CHANNEL); ledc_update_duty(PWM_SPEED_MODE, PWM_L_CHANNEL); } else if (motor_state.mode == MOTOR_EXHAUST) { gpio_set_level(LED_PIN, 1); gpio_set_level(MOTOR_R_EN, 1); gpio_set_level(MOTOR_L_EN, 1); ledc_set_duty(PWM_SPEED_MODE, PWM_R_CHANNEL, duty); ledc_set_duty(PWM_SPEED_MODE, PWM_L_CHANNEL, 0); ledc_update_duty(PWM_SPEED_MODE, PWM_R_CHANNEL); ledc_update_duty(PWM_SPEED_MODE, PWM_L_CHANNEL); } else if (motor_state.mode == MOTOR_INTAKE) { gpio_set_level(LED_PIN, 1); gpio_set_level(MOTOR_R_EN, 1); gpio_set_level(MOTOR_L_EN, 1); ledc_set_duty(PWM_SPEED_MODE, PWM_R_CHANNEL, 0); ledc_set_duty(PWM_SPEED_MODE, PWM_L_CHANNEL, duty); ledc_update_duty(PWM_SPEED_MODE, PWM_R_CHANNEL); ledc_update_duty(PWM_SPEED_MODE, PWM_L_CHANNEL); } } // Motor ramp timer callback static void motor_ramp_timer_callback(TimerHandle_t xTimer) { if (motor_state.state != MOTOR_STATE_RAMPING) { return; } int speed_diff = motor_state.target_speed - motor_state.current_speed; if (abs(speed_diff) <= RAMP_STEP_SIZE) { // Close enough to target, finish ramping motor_state.current_speed = motor_state.target_speed; motor_state.ramping = false; motor_state.state = MOTOR_STATE_IDLE; // Stop the timer xTimerStop(motor_state.ramp_timer, 0); ESP_LOGI(SYSTEM_TAG, "Ramping complete - Final speed: %d%%", motor_state.current_speed); } else { // Continue ramping if (speed_diff > 0) { motor_state.current_speed += RAMP_STEP_SIZE; } else { motor_state.current_speed -= RAMP_STEP_SIZE; } MOTOR_LOGD(SYSTEM_TAG, "Ramping: %d%% (target: %d%%)", motor_state.current_speed, motor_state.target_speed); } apply_motor_pwm(motor_state.current_speed); } // Motor cooldown timer callback static void motor_cooldown_timer_callback(TimerHandle_t xTimer) { ESP_LOGI(SYSTEM_TAG, "Cooldown complete - Starting motor in %s mode at %d%%", motor_state.pending_mode == MOTOR_EXHAUST ? "EXHAUST" : "INTAKE", motor_state.pending_speed); // Reset cooldown tracking motor_state.cooldown_remaining_ms = 0; // Start the motor in the pending mode start_motor_operation(motor_state.pending_mode, motor_state.pending_speed); } // Update cooldown remaining time (called periodically) static void update_cooldown_time(void) { if (motor_state.state == MOTOR_STATE_COOLDOWN && motor_state.cooldown_remaining_ms > 0) { if (motor_state.cooldown_remaining_ms >= STATUS_UPDATE_INTERVAL_MS) { motor_state.cooldown_remaining_ms -= STATUS_UPDATE_INTERVAL_MS; } else { motor_state.cooldown_remaining_ms = 0; } } } // Start motor operation (internal function) static void start_motor_operation(motor_mode_t mode, int speed_percent) { // Clamp speed using config macro speed_percent = CLAMP_SPEED(speed_percent); motor_state.mode = mode; motor_state.target_speed = speed_percent; motor_state.state = MOTOR_STATE_RAMPING; motor_state.ramping = true; if (mode == MOTOR_OFF || speed_percent == 0) { // Immediate stop motor_state.current_speed = 0; motor_state.target_speed = 0; motor_state.state = MOTOR_STATE_IDLE; motor_state.ramping = false; apply_motor_pwm(0); ESP_LOGI(SYSTEM_TAG, "Motor stopped immediately"); } else { // Save last ON state for future ON button use save_last_on_state(mode, speed_percent); // Start from minimum speed if currently off if (motor_state.current_speed == 0) { int start_speed = (speed_percent < MIN_MOTOR_SPEED) ? speed_percent : MIN_MOTOR_SPEED; motor_state.current_speed = start_speed; apply_motor_pwm(start_speed); ESP_LOGI(SYSTEM_TAG, "Motor starting at %d%%, ramping to %d%%", start_speed, speed_percent); } // Start ramping if needed if (motor_state.current_speed != motor_state.target_speed) { xTimerStart(motor_state.ramp_timer, 0); } else { motor_state.state = MOTOR_STATE_IDLE; motor_state.ramping = false; } } // Save state to NVS after any change save_motor_state_to_nvs(); } // Initialize motor ramping system void init_motor_ramping(void) { motor_state.ramp_timer = xTimerCreate( "MotorRampTimer", // Timer name pdMS_TO_TICKS(RAMP_STEP_MS), // Timer period pdTRUE, // Auto-reload (void*)0, // Timer ID motor_ramp_timer_callback // Callback function ); motor_state.cooldown_timer = xTimerCreate( "MotorCooldownTimer", // Timer name pdMS_TO_TICKS(DIRECTION_CHANGE_COOLDOWN_MS), // Timer period pdFALSE, // One-shot (void*)0, // Timer ID motor_cooldown_timer_callback // Callback function ); if (motor_state.ramp_timer == NULL || motor_state.cooldown_timer == NULL) { ESP_LOGE(SYSTEM_TAG, "Failed to create motor timers"); } else { ESP_LOGI(SYSTEM_TAG, "Motor control system initialized with direction change safety"); } } void set_motor_speed(motor_mode_t mode, int speed_percent) { // Clamp speed to valid range using config macro speed_percent = CLAMP_SPEED(speed_percent); ESP_LOGI(SYSTEM_TAG, "Motor command: %s - Speed: %d%% (Current mode: %s, Current speed: %d%%, State: %d)", mode == MOTOR_OFF ? "OFF" : (mode == MOTOR_EXHAUST ? "EXHAUST" : "INTAKE"), speed_percent, motor_state.mode == MOTOR_OFF ? "OFF" : (motor_state.mode == MOTOR_EXHAUST ? "EXHAUST" : "INTAKE"), motor_state.current_speed, motor_state.state); // Track if user manually turned off if (mode == MOTOR_OFF && motor_state.mode != MOTOR_OFF) { motor_state.user_turned_off = true; ESP_LOGI(SYSTEM_TAG, "User manually turned OFF - will stay off after restart"); } else if (mode != MOTOR_OFF) { motor_state.user_turned_off = false; ESP_LOGI(SYSTEM_TAG, "Motor turned ON - will resume after power loss"); } // If we're in cooldown, update the pending command if (motor_state.state == MOTOR_STATE_COOLDOWN) { motor_state.pending_mode = mode; motor_state.pending_speed = speed_percent; ESP_LOGI(SYSTEM_TAG, "Motor in cooldown - command queued for execution"); save_motor_state_to_nvs(); // Save the pending state return; } // Check if this is a direction change that requires cooldown using config macro bool requires_cooldown = false; if (motor_state.current_speed > 0 && motor_state.mode != MOTOR_OFF) { requires_cooldown = IS_DIRECTION_CHANGE(motor_state.mode, mode); } if (requires_cooldown) { ESP_LOGI(SYSTEM_TAG, "Direction change detected - initiating safety cooldown sequence"); // Stop any current ramping if (motor_state.ramping) { xTimerStop(motor_state.ramp_timer, 0); motor_state.ramping = false; } // Stop the motor immediately motor_state.mode = MOTOR_OFF; motor_state.current_speed = 0; motor_state.target_speed = 0; motor_state.state = MOTOR_STATE_COOLDOWN; motor_state.cooldown_remaining_ms = DIRECTION_CHANGE_COOLDOWN_MS; apply_motor_pwm(0); // Store the pending command motor_state.pending_mode = mode; motor_state.pending_speed = speed_percent; // Start cooldown timer xTimerStart(motor_state.cooldown_timer, 0); ESP_LOGI(SYSTEM_TAG, "Motor stopped for direction change - %d second cooldown started", DIRECTION_CHANGE_COOLDOWN_MS / 1000); // Save state including pending command save_motor_state_to_nvs(); } else { // No direction change required, proceed normally // Stop any current ramping if (motor_state.ramping) { xTimerStop(motor_state.ramp_timer, 0); motor_state.ramping = false; } // Stop cooldown timer if running if (motor_state.state == MOTOR_STATE_COOLDOWN) { xTimerStop(motor_state.cooldown_timer, 0); motor_state.cooldown_remaining_ms = 0; } start_motor_operation(mode, speed_percent); } } // Helper function to set CORS headers static void set_cors_headers(httpd_req_t *req) { httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*"); httpd_resp_set_hdr(req, "Access-Control-Allow-Methods", "GET, POST, OPTIONS"); httpd_resp_set_hdr(req, "Access-Control-Allow-Headers", "Content-Type, Accept"); httpd_resp_set_hdr(req, "Cache-Control", "no-cache"); } // HTTP handler for the main web page static esp_err_t root_get_handler(httpd_req_t *req) { set_cors_headers(req); httpd_resp_set_type(req, "text/html"); httpd_resp_send(req, html_page, HTTPD_RESP_USE_STRLEN); return ESP_OK; } // HTTP handler for fan status (GET /status) static esp_err_t status_get_handler(httpd_req_t *req) { // Update cooldown time before reporting update_cooldown_time(); ESP_LOGI(SYSTEM_TAG, "Status request - Mode: %d, Current: %d%%, Target: %d%%, State: %d, Ramping: %s", motor_state.mode, motor_state.current_speed, motor_state.target_speed, motor_state.state, motor_state.ramping ? "YES" : "NO"); set_cors_headers(req); httpd_resp_set_type(req, "application/json"); cJSON *json = cJSON_CreateObject(); const char* mode_str = "off"; if (motor_state.mode == MOTOR_EXHAUST) mode_str = "exhaust"; else if (motor_state.mode == MOTOR_INTAKE) mode_str = "intake"; const char* state_str = "idle"; switch (motor_state.state) { case MOTOR_STATE_RAMPING: state_str = "ramping"; break; case MOTOR_STATE_STOPPING: state_str = "stopping"; break; case MOTOR_STATE_COOLDOWN: state_str = "cooldown"; break; case MOTOR_STATE_RESTARTING: state_str = "restarting"; break; default: state_str = "idle"; break; } const char* last_on_mode_str = "exhaust"; if (motor_state.last_on_mode == MOTOR_INTAKE) last_on_mode_str = "intake"; cJSON_AddStringToObject(json, "mode", mode_str); cJSON_AddNumberToObject(json, "current_speed", motor_state.current_speed); cJSON_AddNumberToObject(json, "target_speed", motor_state.target_speed); cJSON_AddStringToObject(json, "state", state_str); cJSON_AddBoolToObject(json, "ramping", motor_state.ramping); cJSON_AddNumberToObject(json, "cooldown_remaining", motor_state.cooldown_remaining_ms); cJSON_AddStringToObject(json, "last_on_mode", last_on_mode_str); cJSON_AddNumberToObject(json, "last_on_speed", motor_state.last_on_speed); // Add pending command info if in cooldown if (motor_state.state == MOTOR_STATE_COOLDOWN) { const char* pending_mode_str = "off"; if (motor_state.pending_mode == MOTOR_EXHAUST) pending_mode_str = "exhaust"; else if (motor_state.pending_mode == MOTOR_INTAKE) pending_mode_str = "intake"; cJSON_AddStringToObject(json, "pending_mode", pending_mode_str); cJSON_AddNumberToObject(json, "pending_speed", motor_state.pending_speed); } char *json_string = cJSON_Print(json); if (json_string) { httpd_resp_send(req, json_string, strlen(json_string)); free(json_string); } else { httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "JSON creation failed"); } cJSON_Delete(json); return ESP_OK; } // HTTP handler for fan control (POST /fan) static esp_err_t fan_post_handler(httpd_req_t *req) { char buf[MAX_JSON_BUFFER_SIZE]; int ret, remaining = req->content_len; if (remaining >= sizeof(buf)) { httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "Content too long"); return ESP_FAIL; } ret = httpd_req_recv(req, buf, remaining); if (ret <= 0) { if (ret == HTTPD_SOCK_ERR_TIMEOUT) { httpd_resp_send_err(req, HTTPD_408_REQ_TIMEOUT, "Request timeout"); } return ESP_FAIL; } buf[ret] = '\0'; ESP_LOGI(SYSTEM_TAG, "Received POST data: %s", buf); cJSON *json = cJSON_Parse(buf); if (json == NULL) { ESP_LOGE(SYSTEM_TAG, "JSON parsing failed"); httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "Invalid JSON"); return ESP_FAIL; } cJSON *mode_json = cJSON_GetObjectItem(json, "mode"); cJSON *speed_json = cJSON_GetObjectItem(json, "speed"); if (!cJSON_IsString(mode_json) || (!cJSON_IsNumber(speed_json) && !cJSON_IsString(speed_json))) { ESP_LOGE(SYSTEM_TAG, "JSON parsing failed - mode: %s, speed: %s", mode_json ? (cJSON_IsString(mode_json) ? mode_json->valuestring : "not_string") : "null", speed_json ? (cJSON_IsNumber(speed_json) ? "number" : (cJSON_IsString(speed_json) ? speed_json->valuestring : "not_number_or_string")) : "null"); cJSON_Delete(json); httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "Missing mode or speed"); return ESP_FAIL; } const char* mode_str = mode_json->valuestring; int speed; // Handle both number and string speed values if (cJSON_IsNumber(speed_json)) { speed = (int)speed_json->valuedouble; } else if (cJSON_IsString(speed_json)) { speed = atoi(speed_json->valuestring); } else { speed = 0; } motor_mode_t mode = MOTOR_OFF; // Handle special "ON" command - resume last settings if (strcmp(mode_str, "on") == 0) { mode = motor_state.last_on_mode; speed = motor_state.last_on_speed; ESP_LOGI(SYSTEM_TAG, "ON button pressed - resuming %s @ %d%%", mode == MOTOR_EXHAUST ? "EXHAUST" : "INTAKE", speed); } else if (strcmp(mode_str, "exhaust") == 0) { mode = MOTOR_EXHAUST; } else if (strcmp(mode_str, "intake") == 0) { mode = MOTOR_INTAKE; } ESP_LOGI(SYSTEM_TAG, "HTTP Request: mode=%s, speed=%d", mode_str, speed); set_motor_speed(mode, speed); cJSON_Delete(json); // Send response with updated status return status_get_handler(req); } // HTTP handler for OPTIONS requests (CORS preflight) static esp_err_t options_handler(httpd_req_t *req) { set_cors_headers(req); httpd_resp_set_status(req, "200 OK"); httpd_resp_send(req, NULL, 0); return ESP_OK; } // Start HTTP server static httpd_handle_t start_webserver(void) { httpd_config_t config = HTTPD_DEFAULT_CONFIG(); config.server_port = HTTP_SERVER_PORT; config.max_uri_handlers = HTTP_MAX_URI_HANDLERS; config.recv_wait_timeout = HTTP_RECV_TIMEOUT_SEC; config.send_wait_timeout = HTTP_SEND_TIMEOUT_SEC; ESP_LOGI(SYSTEM_TAG, "Starting server on port: '%d'", config.server_port); if (httpd_start(&server, &config) == ESP_OK) { ESP_LOGI(SYSTEM_TAG, "Registering URI handlers"); // Root handler httpd_uri_t root = { .uri = "/", .method = HTTP_GET, .handler = root_get_handler, .user_ctx = NULL }; httpd_register_uri_handler(server, &root); // Status handler httpd_uri_t status = { .uri = "/status", .method = HTTP_GET, .handler = status_get_handler, .user_ctx = NULL }; httpd_register_uri_handler(server, &status); // Fan control handler httpd_uri_t fan = { .uri = "/fan", .method = HTTP_POST, .handler = fan_post_handler, .user_ctx = NULL }; httpd_register_uri_handler(server, &fan); // OPTIONS handler for CORS preflight httpd_uri_t options_status = { .uri = "/status", .method = HTTP_OPTIONS, .handler = options_handler, .user_ctx = NULL }; httpd_register_uri_handler(server, &options_status); httpd_uri_t options_fan = { .uri = "/fan", .method = HTTP_OPTIONS, .handler = options_handler, .user_ctx = NULL }; httpd_register_uri_handler(server, &options_fan); return server; } ESP_LOGI(SYSTEM_TAG, "Error starting server!"); return NULL; } void wifi_init_sta(void) { s_wifi_event_group = xEventGroupCreate(); ESP_ERROR_CHECK(esp_netif_init()); ESP_ERROR_CHECK(esp_event_loop_create_default()); esp_netif_create_default_wifi_sta(); wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT(); ESP_ERROR_CHECK(esp_wifi_init(&cfg)); esp_event_handler_instance_t instance_any_id; esp_event_handler_instance_t instance_got_ip; ESP_ERROR_CHECK(esp_event_handler_instance_register(WIFI_EVENT, ESP_EVENT_ANY_ID, &event_handler, NULL, &instance_any_id)); ESP_ERROR_CHECK(esp_event_handler_instance_register(IP_EVENT, IP_EVENT_STA_GOT_IP, &event_handler, NULL, &instance_got_ip)); wifi_config_t wifi_config = { .sta = { .ssid = WIFI_SSID, .password = WIFI_PASS, .threshold.authmode = WIFI_AUTH_WPA2_PSK, .pmf_cfg = { .capable = true, .required = false }, }, }; ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA)); ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &wifi_config)); ESP_ERROR_CHECK(esp_wifi_start()); ESP_LOGI(SYSTEM_TAG, "wifi_init_sta finished."); EventBits_t bits = xEventGroupWaitBits(s_wifi_event_group, WIFI_CONNECTED_BIT | WIFI_FAIL_BIT, pdFALSE, pdFALSE, portMAX_DELAY); if (bits & WIFI_CONNECTED_BIT) { ESP_LOGI(SYSTEM_TAG, "connected to ap SSID:%s", WIFI_SSID); } else if (bits & WIFI_FAIL_BIT) { ESP_LOGI(SYSTEM_TAG, "Failed to connect to SSID:%s", WIFI_SSID); } else { ESP_LOGE(SYSTEM_TAG, "UNEXPECTED EVENT"); } } void app_main(void) { ESP_LOGI(SYSTEM_TAG, "Starting Maxxfan HTTP Controller with State Preservation!"); // Initialize NVS esp_err_t ret = nvs_flash_init(); if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) { ESP_ERROR_CHECK(nvs_flash_erase()); ret = nvs_flash_init(); } ESP_ERROR_CHECK(ret); // Initialize watchdog timer init_watchdog(); // Configure hardware configure_gpio_pins(); configure_pwm(); // Initialize motor ramping system init_motor_ramping(); // Load saved state from NVS ESP_LOGI(SYSTEM_TAG, "Loading saved state..."); load_motor_state_from_nvs(); ESP_LOGI(SYSTEM_TAG, "Connecting to WiFi network: %s", WIFI_SSID); wifi_init_sta(); // Start HTTP server start_webserver(); // Restore motor state if needed (after WiFi is connected and server is running) ESP_LOGI(SYSTEM_TAG, "=== MOTOR STATE RESTORATION ==="); ESP_LOGI(SYSTEM_TAG, "Current motor state: mode=%d, target=%d%%, current=%d%%", motor_state.mode, motor_state.target_speed, motor_state.current_speed); if (motor_state.mode != MOTOR_OFF && motor_state.target_speed > 0) { ESP_LOGI(SYSTEM_TAG, "Restoring motor state: %s @ %d%%", motor_state.mode == MOTOR_EXHAUST ? "EXHAUST" : "INTAKE", motor_state.target_speed); // Start the motor with current settings motor_state.current_speed = 0; // Start from 0 and ramp up start_motor_operation(motor_state.mode, motor_state.target_speed); ESP_LOGI(SYSTEM_TAG, "Motor restoration initiated"); } else { ESP_LOGI(SYSTEM_TAG, "No motor state to restore - staying OFF"); } ESP_LOGI(SYSTEM_TAG, "==============================="); ESP_LOGI(SYSTEM_TAG, "=== Enhanced Maxxfan Controller Ready! ==="); ESP_LOGI(SYSTEM_TAG, "Features: State Preservation, Direction Safety, Motor Ramping, ON Button"); ESP_LOGI(SYSTEM_TAG, "Safety: 10-second cooldown for direction changes"); ESP_LOGI(SYSTEM_TAG, "Memory: Remembers settings after power loss (except watchdog resets)"); ESP_LOGI(SYSTEM_TAG, "Open your browser and go to: http://[ESP32_IP_ADDRESS]"); ESP_LOGI(SYSTEM_TAG, "Check the monitor output above for your IP address"); // Main loop - reset watchdog periodically while (1) { feed_watchdog(); vTaskDelay(pdMS_TO_TICKS(WATCHDOG_FEED_INTERVAL_MS)); } }