stephen/maxxfan-controller
1
0
Fork 0
Code Issues 10 Pull Requests Actions Releases Wiki Activity

Resume state after power cycle

Browse Source
This commit is contained in:
Stephen Minakian
2025-07-09 15:13:18 -06:00
parent c96d0bedef
commit a9b2a7a829
1 changed files with 259 additions and 18 deletions
Download Patch File Download Diff File Expand all files Collapse all files

277
main/maxxfan-controller.c
View File

@ -11,6 +11,7 @@
#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"
@ -34,14 +35,22 @@
#define PWM_L_CHANNEL LEDC_CHANNEL_1
// Motor ramping configuration
#define RAMP_STEP_MS 200 // Time between ramp steps (milliseconds)
#define RAMP_STEP_SIZE 2 // PWM duty change per step (0-255)
#define RAMP_STEP_MS 150 // Time between ramp steps (milliseconds)
#define RAMP_STEP_SIZE 5 // PWM duty change per step (0-255)
#define MIN_MOTOR_SPEED 10 // Minimum speed to overcome motor inertia
#define DIRECTION_CHANGE_COOLDOWN_MS 10000 // 10 seconds cooldown for direction changes
// Watchdog configuration
#define WATCHDOG_TIMEOUT_S 10 // Watchdog timeout in seconds
// State preservation configuration
#define NVS_NAMESPACE "fan_state"
#define NVS_KEY_MODE "mode"
#define NVS_KEY_SPEED "speed"
#define NVS_KEY_LAST_ON_MODE "last_mode"
#define NVS_KEY_LAST_ON_SPEED "last_speed"
#define NVS_KEY_POWER_STATE "power_state"
static const char* TAG = "HTTP_MOTOR";
// WiFi event group
@ -77,6 +86,11 @@ typedef struct {
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 = {
@ -89,7 +103,10 @@ static motor_state_t motor_state = {
.ramping = false,
.ramp_timer = NULL,
.cooldown_timer = NULL,
.cooldown_remaining_ms = 0
.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
@ -103,17 +120,19 @@ static const char* html_page =
"<!DOCTYPE html><html><head><title>Maxxfan</title><meta name=\"viewport\" content=\"width=device-width,initial-scale=1\"><style>"
"body{font-family:Arial;margin:20px;background:#f0f0f0}.container{max-width:500px;margin:0 auto;background:white;padding:20px;border-radius:8px}"
"h1{color:#333;text-align:center;margin:0 0 20px}button{padding:12px 20px;margin:5px;border:none;border-radius:4px;cursor:pointer;font-size:14px}"
".off{background:#f44336;color:white}.exhaust{background:#ff9800;color:white}.intake{background:#4CAF50;color:white}"
".off{background:#f44336;color:white}.exhaust{background:#ff9800;color:white}.intake{background:#4CAF50;color:white}.on{background:#2196F3;color:white}"
".status{background:#e3f2fd;padding:15px;border-radius:4px;margin:15px 0}.ramping{background:#fff3e0;padding:8px;margin:8px 0;display:none}"
".cooldown{background:#ffebee;padding:8px;margin:8px 0;color:#c62828;display:none}"
".error{background:#ffebee;padding:8px;margin:8px 0;color:#c62828;display:none}.slider{width:100%;height:30px;margin:10px 0}"
"</style></head><body><div class=\"container\"><h1>Maxxfan Controller</h1>"
"<div class=\"status\"><h4>Status</h4><p>Mode: <span id=\"mode\">OFF</span></p><p>Speed: <span id=\"speed\">0</span>%</p>"
"<p>Target: <span id=\"target\">0</span>%</p><p>State: <span id=\"state\">IDLE</span></p>"
"<p>Last ON: <span id=\"lastOn\">EXHAUST @ 50%</span></p>"
"<div id=\"rampStatus\" class=\"ramping\">Ramping...</div>"
"<div id=\"cooldownStatus\" class=\"cooldown\">Direction change cooldown: <span id=\"cooldownTime\">0</span>s</div>"
"<div id=\"errorStatus\" class=\"error\">Error</div><small id=\"connectionStatus\">Connecting...</small></div>"
"<div><h3>Fan Control</h3><button class=\"off\" onclick=\"setFan('off',0)\">OFF</button>"
"<button class=\"on\" onclick=\"setFan('on',0)\">ON (Resume Last)</button>"
"<button class=\"exhaust\" onclick=\"setFan('exhaust',50)\">Exhaust 50%</button>"
"<button class=\"intake\" onclick=\"setFan('intake',50)\">Intake 50%</button></div>"
"<div><h3>Speed Control</h3><label>Speed: <span id=\"speedValue\">50</span>%</label>"
@ -126,7 +145,11 @@ static const char* html_page =
"document.getElementById('connectionStatus').textContent='Error'}"
"function hideError(){document.getElementById('errorStatus').style.display='none';"
"document.getElementById('connectionStatus').textContent='Connected';errorCount=0}"
"function setFan(mode,speed){currentSpeed=speed;document.getElementById('speedSlider').value=speed;"
"function setFan(mode,speed){if(mode==='on'){fetch('/fan',{method:'POST',headers:{'Content-Type':'application/json'},"
"body:JSON.stringify({mode:'on',speed:0})})"
".then(r=>{if(!r.ok)throw new Error('HTTP '+r.status);return r.json()})"
".then(d=>{updateStatus(d);hideError()}).catch(e=>{console.error(e);showError(e.message)});return;}"
"currentSpeed=speed;document.getElementById('speedSlider').value=speed;"
"document.getElementById('speedValue').textContent=speed;fetch('/fan',{method:'POST',"
"headers:{'Content-Type':'application/json'},body:JSON.stringify({mode:mode,speed:parseInt(speed)})})"
".then(r=>{if(!r.ok)throw new Error('HTTP '+r.status);return r.json()})"
@ -139,6 +162,7 @@ static const char* html_page =
"document.getElementById('speed').textContent=data.current_speed;"
"document.getElementById('target').textContent=data.target_speed;"
"document.getElementById('state').textContent=data.state.toUpperCase();"
"if(data.last_on_mode&&data.last_on_speed){document.getElementById('lastOn').textContent=data.last_on_mode.toUpperCase()+' @ '+data.last_on_speed+'%';}"
"document.getElementById('rampStatus').style.display=data.ramping?'block':'none';"
"let cooldownDiv=document.getElementById('cooldownStatus');"
"if(data.cooldown_remaining>0){cooldownDiv.style.display='block';"
@ -153,6 +177,10 @@ 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) {
@ -182,6 +210,174 @@ void feed_watchdog(void) {
}
}
// 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(TAG, "Error opening NVS handle: %s", esp_err_to_name(err));
return err;
}
ESP_LOGI(TAG, "=== SAVING STATE TO NVS ===");
ESP_LOGI(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(TAG, "✓ Motor state successfully saved to NVS");
} else {
ESP_LOGE(TAG, "✗ NVS commit failed: %s", esp_err_to_name(err));
}
} else {
ESP_LOGE(TAG, "✗ Error saving to NVS: %s", esp_err_to_name(err));
}
ESP_LOGI(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(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
if (stored_mode > MOTOR_INTAKE) stored_mode = MOTOR_OFF;
if (stored_speed > 100) stored_speed = 0;
if (stored_last_mode < MOTOR_EXHAUST || stored_last_mode > MOTOR_INTAKE) stored_last_mode = MOTOR_EXHAUST;
if (stored_last_speed > 100) 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(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(TAG, "=== RESET ANALYSIS ===");
ESP_LOGI(TAG, "Reset reason: %d", reset_reason);
ESP_LOGI(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(TAG, "Watchdog reset: %s", was_watchdog_reset ? "YES" : "NO");
ESP_LOGI(TAG, "Stored mode: %d, speed: %d", stored_mode, stored_speed);
ESP_LOGI(TAG, "User turned off: %s", motor_state.user_turned_off ? "YES" : "NO");
ESP_LOGI(TAG, "====================");
if (was_watchdog_reset) {
// True watchdog reset (TASK_WDT or INT_WDT) - don't restore state, start fresh
ESP_LOGI(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(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(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(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(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(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)
@ -368,6 +564,9 @@ static void start_motor_operation(motor_mode_t mode, int speed_percent) {
apply_motor_pwm(0);
ESP_LOGI(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;
@ -384,6 +583,9 @@ static void start_motor_operation(motor_mode_t mode, int speed_percent) {
motor_state.ramping = false;
}
}
// Save state to NVS after any change
save_motor_state_to_nvs();
}
// Initialize motor ramping system
@ -423,11 +625,21 @@ void set_motor_speed(motor_mode_t mode, int speed_percent)
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(TAG, "User manually turned OFF - will stay off after restart");
} else if (mode != MOTOR_OFF) {
motor_state.user_turned_off = false;
ESP_LOGI(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(TAG, "Motor in cooldown - command queued for execution");
save_motor_state_to_nvs(); // Save the pending state
return;
}
@ -466,6 +678,9 @@ void set_motor_speed(motor_mode_t mode, int speed_percent)
ESP_LOGI(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
@ -530,12 +745,17 @@ static esp_err_t status_get_handler(httpd_req_t *req)
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) {
@ -613,7 +833,14 @@ static esp_err_t fan_post_handler(httpd_req_t *req)
}
motor_mode_t mode = MOTOR_OFF;
if (strcmp(mode_str, "exhaust") == 0) {
// 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(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;
@ -756,19 +983,9 @@ void wifi_init_sta(void)
}
}
// Main application task with watchdog feeding
void main_task(void *pvParameters) {
ESP_LOGI(TAG, "Main task started");
while (1) {
feed_watchdog();
vTaskDelay(pdMS_TO_TICKS(5000)); // Feed watchdog every 5 seconds
}
}
void app_main(void)
{
ESP_LOGI(TAG, "Starting Maxxfan HTTP Controller with Direction Change Safety!");
ESP_LOGI(TAG, "Starting Maxxfan HTTP Controller with State Preservation!");
// Initialize NVS
esp_err_t ret = nvs_flash_init();
@ -788,15 +1005,39 @@ void app_main(void)
// Initialize motor ramping system
init_motor_ramping();
// Load saved state from NVS
ESP_LOGI(TAG, "Loading saved state...");
load_motor_state_from_nvs();
ESP_LOGI(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(TAG, "=== MOTOR STATE RESTORATION ===");
ESP_LOGI(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(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(TAG, "Motor restoration initiated");
} else {
ESP_LOGI(TAG, "No motor state to restore - staying OFF");
}
ESP_LOGI(TAG, "===============================");
ESP_LOGI(TAG, "=== Enhanced Maxxfan Controller Ready! ===");
ESP_LOGI(TAG, "Features: Motor Ramping, Direction Change Safety, Real-time Updates");
ESP_LOGI(TAG, "Features: State Preservation, Direction Safety, Motor Ramping, ON Button");
ESP_LOGI(TAG, "Safety: 10-second cooldown for direction changes");
ESP_LOGI(TAG, "Memory: Remembers settings after power loss (except watchdog resets)");
ESP_LOGI(TAG, "Open your browser and go to: http://[ESP32_IP_ADDRESS]");
ESP_LOGI(TAG, "Check the monitor output above for your IP address");