1013 lines
40 KiB
C
Executable File
1013 lines
40 KiB
C
Executable File
#include <stdio.h>
|
|
#include <string.h>
|
|
#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 =
|
|
"<!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}.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>"
|
|
"<input type=\"range\" id=\"speedSlider\" class=\"slider\" min=\"0\" max=\"100\" value=\"50\" oninput=\"updateSpeed(this.value)\">"
|
|
"<button class=\"exhaust\" onclick=\"setFanSpeed('exhaust')\">Set Exhaust</button>"
|
|
"<button class=\"intake\" onclick=\"setFanSpeed('intake')\">Set Intake</button></div></div>"
|
|
"<script>let currentSpeed=50,updateInterval=null,errorCount=0;"
|
|
"function updateSpeed(v){currentSpeed=parseInt(v);document.getElementById('speedValue').textContent=v}"
|
|
"function showError(m){document.getElementById('errorStatus').innerHTML='Error: '+m;document.getElementById('errorStatus').style.display='block';"
|
|
"document.getElementById('connectionStatus').textContent='Error'}"
|
|
"function hideError(){document.getElementById('errorStatus').style.display='none';"
|
|
"document.getElementById('connectionStatus').textContent='Connected';errorCount=0}"
|
|
"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()})"
|
|
".then(d=>{updateStatus(d);hideError()}).catch(e=>{console.error(e);showError(e.message)})}"
|
|
"function setFanSpeed(mode){fetch('/fan',{method:'POST',headers:{'Content-Type':'application/json'},"
|
|
"body:JSON.stringify({mode:mode,speed:parseInt(currentSpeed)})})"
|
|
".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)})}"
|
|
"function updateStatus(data){document.getElementById('mode').textContent=data.mode.toUpperCase();"
|
|
"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';"
|
|
"document.getElementById('cooldownTime').textContent=Math.ceil(data.cooldown_remaining/1000);}else{cooldownDiv.style.display='none';}}"
|
|
"function getStatus(){fetch('/status').then(r=>{if(!r.ok)throw new Error('HTTP '+r.status);return r.json()})"
|
|
".then(d=>{updateStatus(d);hideError()}).catch(e=>{errorCount++;if(errorCount>=3)showError('Connection lost')})}"
|
|
"function startUpdates(){if(updateInterval)clearInterval(updateInterval);updateInterval=setInterval(getStatus,1000)}"
|
|
"document.addEventListener('DOMContentLoaded',function(){getStatus();startUpdates()})</script></body></html>";
|
|
|
|
// 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));
|
|
}
|
|
} |