703 lines
24 KiB
C
Executable File
703 lines
24 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 "driver/gpio.h"
|
|
#include "driver/ledc.h"
|
|
#include "cJSON.h"
|
|
|
|
// WiFi credentials - CHANGE THESE TO YOUR NETWORK
|
|
#define WIFI_SSID "GL-AXT1800-0c2"
|
|
#define WIFI_PASS "CR7W25FM8S"
|
|
#define WIFI_MAXIMUM_RETRY 5
|
|
|
|
// Pin definitions
|
|
#define LED_PIN GPIO_NUM_13
|
|
#define MOTOR_R_EN GPIO_NUM_18
|
|
#define MOTOR_L_EN GPIO_NUM_19
|
|
#define PWM_R_PIN GPIO_NUM_21
|
|
#define PWM_L_PIN GPIO_NUM_22
|
|
|
|
// PWM configuration
|
|
#define PWM_FREQUENCY 1000
|
|
#define PWM_RESOLUTION LEDC_TIMER_8_BIT
|
|
#define PWM_R_CHANNEL LEDC_CHANNEL_0
|
|
#define PWM_L_CHANNEL LEDC_CHANNEL_1
|
|
|
|
// Motor ramping configuration
|
|
#define RAMP_STEP_MS 50 // 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
|
|
|
|
// Watchdog configuration
|
|
#define WATCHDOG_TIMEOUT_S 10 // Watchdog timeout in seconds
|
|
|
|
static const char* TAG = "HTTP_MOTOR";
|
|
|
|
// WiFi event group
|
|
static EventGroupHandle_t s_wifi_event_group;
|
|
#define WIFI_CONNECTED_BIT BIT0
|
|
#define WIFI_FAIL_BIT BIT1
|
|
|
|
static int s_retry_num = 0;
|
|
|
|
// Motor control
|
|
typedef enum {
|
|
MOTOR_OFF,
|
|
MOTOR_EXHAUST,
|
|
MOTOR_INTAKE
|
|
} motor_mode_t;
|
|
|
|
typedef struct {
|
|
motor_mode_t mode;
|
|
int target_speed;
|
|
int current_speed;
|
|
bool ramping;
|
|
TimerHandle_t ramp_timer;
|
|
} motor_state_t;
|
|
|
|
static motor_state_t motor_state = {
|
|
.mode = MOTOR_OFF,
|
|
.target_speed = 0,
|
|
.current_speed = 0,
|
|
.ramping = false,
|
|
.ramp_timer = NULL
|
|
};
|
|
|
|
// HTTP server handle
|
|
static httpd_handle_t server = NULL;
|
|
|
|
// Task handles for watchdog
|
|
static TaskHandle_t main_task_handle = NULL;
|
|
|
|
// HTML web page for control (same as before)
|
|
static const char* html_page =
|
|
"<!DOCTYPE html>"
|
|
"<html>"
|
|
"<head>"
|
|
" <title>Maxxfan Controller</title>"
|
|
" <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">"
|
|
" <style>"
|
|
" body { font-family: Arial, sans-serif; margin: 40px; background: #f0f0f0; }"
|
|
" .container { max-width: 500px; margin: 0 auto; background: white; padding: 30px; border-radius: 10px; box-shadow: 0 4px 6px rgba(0,0,0,0.1); }"
|
|
" h1 { color: #333; text-align: center; }"
|
|
" .control-group { margin: 20px 0; padding: 20px; border: 1px solid #ddd; border-radius: 5px; }"
|
|
" .control-group h3 { margin-top: 0; color: #555; }"
|
|
" button { padding: 15px 25px; margin: 5px; border: none; border-radius: 5px; cursor: pointer; font-size: 16px; }"
|
|
" .btn-off { background: #f44336; color: white; }"
|
|
" .btn-exhaust { background: #ff9800; color: white; }"
|
|
" .btn-intake { background: #4CAF50; color: white; }"
|
|
" .btn-off:hover { background: #d32f2f; }"
|
|
" .btn-exhaust:hover { background: #f57c00; }"
|
|
" .btn-intake:hover { background: #388e3c; }"
|
|
" .speed-control { margin: 20px 0; }"
|
|
" .speed-slider { width: 100%; height: 40px; }"
|
|
" .status { background: #e3f2fd; padding: 15px; border-radius: 5px; margin: 20px 0; }"
|
|
" .status h4 { margin: 0 0 10px 0; color: #1976d2; }"
|
|
" .ramping { background: #fff3e0; border-left: 4px solid #ff9800; padding: 10px; margin: 10px 0; }"
|
|
" </style>"
|
|
"</head>"
|
|
"<body>"
|
|
" <div class=\"container\">"
|
|
" <h1>Maxxfan Controller</h1>"
|
|
" "
|
|
" <div class=\"status\">"
|
|
" <h4>Current Status</h4>"
|
|
" <p><strong>Mode:</strong> <span id=\"mode\">OFF</span></p>"
|
|
" <p><strong>Speed:</strong> <span id=\"speed\">0</span>%</p>"
|
|
" <p><strong>Target:</strong> <span id=\"target\">0</span>%</p>"
|
|
" <div id=\"rampStatus\" class=\"ramping\" style=\"display: none;\">"
|
|
" <strong>Ramping in progress...</strong>"
|
|
" </div>"
|
|
" </div>"
|
|
" "
|
|
" <div class=\"control-group\">"
|
|
" <h3>Fan Control</h3>"
|
|
" <button class=\"btn-off\" onclick=\"setFan('off', 0)\">Turn OFF</button>"
|
|
" <button class=\"btn-exhaust\" onclick=\"setFan('exhaust', 50)\">Exhaust (50%)</button>"
|
|
" <button class=\"btn-intake\" onclick=\"setFan('intake', 50)\">Intake (50%)</button>"
|
|
" </div>"
|
|
" "
|
|
" <div class=\"control-group\">"
|
|
" <h3>Speed Control</h3>"
|
|
" <div class=\"speed-control\">"
|
|
" <label for=\"speedSlider\">Speed: <span id=\"speedValue\">50</span>%</label><br>"
|
|
" <input type=\"range\" id=\"speedSlider\" class=\"speed-slider\" min=\"0\" max=\"100\" value=\"50\" oninput=\"updateSpeed(this.value)\">"
|
|
" </div>"
|
|
" <button class=\"btn-exhaust\" onclick=\"setFanSpeed('exhaust')\">Set Exhaust Speed</button>"
|
|
" <button class=\"btn-intake\" onclick=\"setFanSpeed('intake')\">Set Intake Speed</button>"
|
|
" </div>"
|
|
" </div>"
|
|
""
|
|
" <script>"
|
|
" let currentSpeed = 50;"
|
|
" "
|
|
" function updateSpeed(value) {"
|
|
" currentSpeed = parseInt(value);"
|
|
" document.getElementById('speedValue').textContent = value;"
|
|
" }"
|
|
" "
|
|
" function setFan(mode, speed) {"
|
|
" 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(response => response.json())"
|
|
" .then(data => updateStatus(data))"
|
|
" .catch(error => console.error('Error:', error));"
|
|
" }"
|
|
" "
|
|
" function setFanSpeed(mode) {"
|
|
" fetch('/fan', {"
|
|
" method: 'POST',"
|
|
" headers: { 'Content-Type': 'application/json' },"
|
|
" body: JSON.stringify({ mode: mode, speed: parseInt(currentSpeed) })"
|
|
" })"
|
|
" .then(response => response.json())"
|
|
" .then(data => updateStatus(data))"
|
|
" .catch(error => console.error('Error:', error));"
|
|
" }"
|
|
" "
|
|
" function updateStatus(data) {"
|
|
" document.getElementById('mode').textContent = data.mode.toUpperCase();"
|
|
" document.getElementById('speed').textContent = data.current_speed;"
|
|
" document.getElementById('target').textContent = data.target_speed;"
|
|
" "
|
|
" const rampStatus = document.getElementById('rampStatus');"
|
|
" if (data.ramping) {"
|
|
" rampStatus.style.display = 'block';"
|
|
" } else {"
|
|
" rampStatus.style.display = 'none';"
|
|
" }"
|
|
" }"
|
|
" "
|
|
" function getStatus() {"
|
|
" fetch('/status')"
|
|
" .then(response => response.json())"
|
|
" .then(data => updateStatus(data))"
|
|
" .catch(error => console.error('Error:', error));"
|
|
" }"
|
|
" "
|
|
" // Update status every 1 second (faster to show ramping)"
|
|
" setInterval(getStatus, 1000);"
|
|
" "
|
|
" // Get initial status"
|
|
" getStatus();"
|
|
" </script>"
|
|
"</body>"
|
|
"</html>";
|
|
|
|
// Forward declarations
|
|
static void motor_ramp_timer_callback(TimerHandle_t xTimer);
|
|
static void apply_motor_pwm(int speed_percent);
|
|
|
|
// Initialize watchdog timer
|
|
void init_watchdog(void) {
|
|
ESP_LOGI(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(TAG, "Main task added to watchdog monitoring");
|
|
} else if (result == ESP_ERR_INVALID_ARG) {
|
|
ESP_LOGI(TAG, "Task already monitored by watchdog");
|
|
} else {
|
|
ESP_LOGW(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) {
|
|
ESP_LOGD(TAG, "Watchdog reset failed: %s", esp_err_to_name(result));
|
|
}
|
|
}
|
|
}
|
|
|
|
// 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(TAG, "retry to connect to the AP");
|
|
} else {
|
|
xEventGroupSetBits(s_wifi_event_group, WIFI_FAIL_BIT);
|
|
}
|
|
ESP_LOGI(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(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(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(TAG, "GPIO pins configured");
|
|
}
|
|
|
|
void configure_pwm(void)
|
|
{
|
|
ESP_LOGI(TAG, "Configuring PWM...");
|
|
|
|
ledc_timer_config_t timer_conf = {
|
|
.speed_mode = LEDC_LOW_SPEED_MODE,
|
|
.timer_num = LEDC_TIMER_0,
|
|
.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 = LEDC_LOW_SPEED_MODE,
|
|
.hpoint = 0,
|
|
.timer_sel = LEDC_TIMER_0
|
|
};
|
|
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(TAG, "PWM configured");
|
|
}
|
|
|
|
// Apply PWM to motor based on current mode and speed
|
|
static void apply_motor_pwm(int speed_percent) {
|
|
if (speed_percent < 0) speed_percent = 0;
|
|
if (speed_percent > 100) speed_percent = 100;
|
|
|
|
uint32_t duty = (speed_percent * 255) / 100;
|
|
|
|
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(LEDC_LOW_SPEED_MODE, PWM_R_CHANNEL, 0);
|
|
ledc_set_duty(LEDC_LOW_SPEED_MODE, PWM_L_CHANNEL, 0);
|
|
ledc_update_duty(LEDC_LOW_SPEED_MODE, PWM_R_CHANNEL);
|
|
ledc_update_duty(LEDC_LOW_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, 0);
|
|
ledc_set_duty(LEDC_LOW_SPEED_MODE, PWM_R_CHANNEL, duty);
|
|
ledc_set_duty(LEDC_LOW_SPEED_MODE, PWM_L_CHANNEL, 0);
|
|
ledc_update_duty(LEDC_LOW_SPEED_MODE, PWM_R_CHANNEL);
|
|
ledc_update_duty(LEDC_LOW_SPEED_MODE, PWM_L_CHANNEL);
|
|
|
|
} else if (motor_state.mode == MOTOR_INTAKE) {
|
|
gpio_set_level(LED_PIN, 1);
|
|
gpio_set_level(MOTOR_R_EN, 0);
|
|
gpio_set_level(MOTOR_L_EN, 1);
|
|
ledc_set_duty(LEDC_LOW_SPEED_MODE, PWM_R_CHANNEL, 0);
|
|
ledc_set_duty(LEDC_LOW_SPEED_MODE, PWM_L_CHANNEL, duty);
|
|
ledc_update_duty(LEDC_LOW_SPEED_MODE, PWM_R_CHANNEL);
|
|
ledc_update_duty(LEDC_LOW_SPEED_MODE, PWM_L_CHANNEL);
|
|
}
|
|
}
|
|
|
|
// Motor ramp timer callback
|
|
static void motor_ramp_timer_callback(TimerHandle_t xTimer) {
|
|
if (!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;
|
|
|
|
// Stop the timer
|
|
xTimerStop(motor_state.ramp_timer, 0);
|
|
|
|
ESP_LOGI(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;
|
|
}
|
|
|
|
ESP_LOGD(TAG, "Ramping: %d%% -> %d%% (target: %d%%)",
|
|
motor_state.current_speed - (speed_diff > 0 ? RAMP_STEP_SIZE : -RAMP_STEP_SIZE),
|
|
motor_state.current_speed, motor_state.target_speed);
|
|
}
|
|
|
|
apply_motor_pwm(motor_state.current_speed);
|
|
}
|
|
|
|
// 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
|
|
);
|
|
|
|
if (motor_state.ramp_timer == NULL) {
|
|
ESP_LOGE(TAG, "Failed to create motor ramp timer");
|
|
} else {
|
|
ESP_LOGI(TAG, "Motor ramping system initialized");
|
|
}
|
|
}
|
|
|
|
void set_motor_speed(motor_mode_t mode, int speed_percent)
|
|
{
|
|
if (speed_percent < 0) speed_percent = 0;
|
|
if (speed_percent > 100) speed_percent = 100;
|
|
|
|
// Stop any current ramping
|
|
if (motor_state.ramping) {
|
|
xTimerStop(motor_state.ramp_timer, 0);
|
|
motor_state.ramping = false;
|
|
}
|
|
|
|
motor_mode_t previous_mode = motor_state.mode;
|
|
motor_state.mode = mode;
|
|
motor_state.target_speed = speed_percent;
|
|
|
|
ESP_LOGI(TAG, "Motor command: %s - Target: %d%% (Current: %d%%)",
|
|
mode == MOTOR_OFF ? "OFF" : (mode == MOTOR_EXHAUST ? "EXHAUST" : "INTAKE"),
|
|
speed_percent, motor_state.current_speed);
|
|
|
|
// Handle different scenarios
|
|
if (mode == MOTOR_OFF || speed_percent == 0) {
|
|
// Immediate stop
|
|
motor_state.current_speed = 0;
|
|
motor_state.target_speed = 0;
|
|
apply_motor_pwm(0);
|
|
ESP_LOGI(TAG, "Motor stopped immediately");
|
|
|
|
} else if (previous_mode == MOTOR_OFF || motor_state.current_speed == 0) {
|
|
// Starting from stop - apply minimum speed first, then ramp
|
|
int start_speed = (speed_percent < MIN_MOTOR_SPEED) ? speed_percent : MIN_MOTOR_SPEED;
|
|
motor_state.current_speed = start_speed;
|
|
apply_motor_pwm(start_speed);
|
|
|
|
if (speed_percent > start_speed) {
|
|
// Start ramping to target
|
|
motor_state.ramping = true;
|
|
xTimerStart(motor_state.ramp_timer, 0);
|
|
ESP_LOGI(TAG, "Motor starting at %d%%, ramping to %d%%", start_speed, speed_percent);
|
|
} else {
|
|
ESP_LOGI(TAG, "Motor started at %d%% (no ramping needed)", start_speed);
|
|
}
|
|
|
|
} else if (previous_mode != mode) {
|
|
// Direction change - ramp down to minimum, change direction, then ramp up
|
|
motor_state.target_speed = MIN_MOTOR_SPEED;
|
|
motor_state.ramping = true;
|
|
xTimerStart(motor_state.ramp_timer, 0);
|
|
ESP_LOGI(TAG, "Direction change - ramping down first");
|
|
|
|
// Note: In a real implementation, you might want to implement a state machine
|
|
// to handle the direction change sequence properly
|
|
|
|
} else {
|
|
// Same mode, just speed change - ramp to new speed
|
|
motor_state.ramping = true;
|
|
xTimerStart(motor_state.ramp_timer, 0);
|
|
ESP_LOGI(TAG, "Speed change - ramping from %d%% to %d%%",
|
|
motor_state.current_speed, speed_percent);
|
|
}
|
|
}
|
|
|
|
// HTTP handler for the main web page
|
|
static esp_err_t root_get_handler(httpd_req_t *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)
|
|
{
|
|
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";
|
|
|
|
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_AddBoolToObject(json, "ramping", motor_state.ramping);
|
|
|
|
char *json_string = cJSON_Print(json);
|
|
httpd_resp_set_type(req, "application/json");
|
|
httpd_resp_send(req, json_string, strlen(json_string));
|
|
|
|
free(json_string);
|
|
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[100];
|
|
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';
|
|
|
|
cJSON *json = cJSON_Parse(buf);
|
|
if (json == NULL) {
|
|
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(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;
|
|
if (strcmp(mode_str, "exhaust") == 0) {
|
|
mode = MOTOR_EXHAUST;
|
|
} else if (strcmp(mode_str, "intake") == 0) {
|
|
mode = MOTOR_INTAKE;
|
|
}
|
|
|
|
ESP_LOGI(TAG, "HTTP Request: mode=%s, speed=%d", mode_str, speed);
|
|
set_motor_speed(mode, speed);
|
|
|
|
cJSON_Delete(json);
|
|
|
|
// Send response
|
|
return status_get_handler(req);
|
|
}
|
|
|
|
// Start HTTP server
|
|
static httpd_handle_t start_webserver(void)
|
|
{
|
|
httpd_config_t config = HTTPD_DEFAULT_CONFIG();
|
|
config.max_uri_handlers = 10;
|
|
|
|
ESP_LOGI(TAG, "Starting server on port: '%d'", config.server_port);
|
|
if (httpd_start(&server, &config) == ESP_OK) {
|
|
ESP_LOGI(TAG, "Registering URI handlers");
|
|
|
|
httpd_uri_t root = {
|
|
.uri = "/",
|
|
.method = HTTP_GET,
|
|
.handler = root_get_handler,
|
|
.user_ctx = NULL
|
|
};
|
|
httpd_register_uri_handler(server, &root);
|
|
|
|
httpd_uri_t status = {
|
|
.uri = "/status",
|
|
.method = HTTP_GET,
|
|
.handler = status_get_handler,
|
|
.user_ctx = NULL
|
|
};
|
|
httpd_register_uri_handler(server, &status);
|
|
|
|
httpd_uri_t fan = {
|
|
.uri = "/fan",
|
|
.method = HTTP_POST,
|
|
.handler = fan_post_handler,
|
|
.user_ctx = NULL
|
|
};
|
|
httpd_register_uri_handler(server, &fan);
|
|
|
|
return server;
|
|
}
|
|
|
|
ESP_LOGI(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(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(TAG, "connected to ap SSID:%s", WIFI_SSID);
|
|
} else if (bits & WIFI_FAIL_BIT) {
|
|
ESP_LOGI(TAG, "Failed to connect to SSID:%s", WIFI_SSID);
|
|
} else {
|
|
ESP_LOGE(TAG, "UNEXPECTED EVENT");
|
|
}
|
|
}
|
|
|
|
// 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 improvements!");
|
|
|
|
// 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();
|
|
|
|
ESP_LOGI(TAG, "Connecting to WiFi network: %s", WIFI_SSID);
|
|
wifi_init_sta();
|
|
|
|
// Start HTTP server
|
|
start_webserver();
|
|
|
|
ESP_LOGI(TAG, "=== Enhanced Maxxfan Controller Ready! ===");
|
|
ESP_LOGI(TAG, "Features: Motor Ramping, Optimized Performance");
|
|
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");
|
|
|
|
// Main loop - reset watchdog periodically
|
|
while (1) {
|
|
feed_watchdog();
|
|
vTaskDelay(pdMS_TO_TICKS(3000)); // Feed every 3 seconds (system default is usually 5s timeout)
|
|
}
|
|
} |