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

PWM motor control

Browse Source
This commit is contained in:
Stephen Minakian
2025-07-09 09:10:05 -06:00
parent 5aedf53175
commit 9df678702a
1 changed files with 163 additions and 62 deletions
Download Patch File Download Diff File Expand all files Collapse all files

225
main/maxxfan-controller.c
View File

@ -2,32 +2,46 @@
#include "freertos/FreeRTOS.h" #include "freertos/FreeRTOS.h"
#include "freertos/task.h" #include "freertos/task.h"
#include "driver/gpio.h" #include "driver/gpio.h"
#include "driver/ledc.h"
#include "esp_log.h" #include "esp_log.h"
// Pin definitions for BTS7960 motor driver // Pin definitions
#define LED_PIN GPIO_NUM_13 // Onboard LED for status #define LED_PIN GPIO_NUM_13 // Onboard LED for status
#define MOTOR_R_EN GPIO_NUM_18 // BTS7960 R_EN pin #define MOTOR_R_EN GPIO_NUM_18 // BTS7960 R_EN pin
#define MOTOR_L_EN GPIO_NUM_19 // BTS7960 L_EN pin #define MOTOR_L_EN GPIO_NUM_19 // BTS7960 L_EN pin
#define PWM_R_PIN GPIO_NUM_21 // BTS7960 R_PWM pin (we'll just use as GPIO for now) #define PWM_R_PIN GPIO_NUM_21 // BTS7960 R_PWM pin
#define PWM_L_PIN GPIO_NUM_22 // BTS7960 L_PWM pin (we'll just use as GPIO for now) #define PWM_L_PIN GPIO_NUM_22 // BTS7960 L_PWM pin
static const char* TAG = "MULTI_GPIO"; // PWM configuration
#define PWM_FREQUENCY 1000 // 1kHz PWM frequency
#define PWM_RESOLUTION LEDC_TIMER_8_BIT // 8-bit resolution (0-255)
#define PWM_R_CHANNEL LEDC_CHANNEL_0
#define PWM_L_CHANNEL LEDC_CHANNEL_1
static const char* TAG = "PWM_MOTOR";
// Motor state
typedef enum {
MOTOR_OFF,
MOTOR_EXHAUST,
MOTOR_INTAKE
} motor_mode_t;
static motor_mode_t current_mode = MOTOR_OFF;
static int current_speed = 0; // 0-100%
// Function to configure all GPIO pins
void configure_gpio_pins(void) void configure_gpio_pins(void)
{ {
ESP_LOGI(TAG, "Configuring GPIO pins..."); ESP_LOGI(TAG, "Configuring GPIO pins...");
// Create bit mask for all our output pins // Configure enable pins as regular GPIO
uint64_t pin_mask = (1ULL << LED_PIN) | uint64_t pin_mask = (1ULL << LED_PIN) |
(1ULL << MOTOR_R_EN) | (1ULL << MOTOR_R_EN) |
(1ULL << MOTOR_L_EN) | (1ULL << MOTOR_L_EN);
(1ULL << PWM_R_PIN) |
(1ULL << PWM_L_PIN);
gpio_config_t io_conf = { gpio_config_t io_conf = {
.pin_bit_mask = pin_mask, // Set all pins at once .pin_bit_mask = pin_mask,
.mode = GPIO_MODE_OUTPUT, // All are outputs .mode = GPIO_MODE_OUTPUT,
.pull_up_en = GPIO_PULLUP_DISABLE, .pull_up_en = GPIO_PULLUP_DISABLE,
.pull_down_en = GPIO_PULLDOWN_DISABLE, .pull_down_en = GPIO_PULLDOWN_DISABLE,
.intr_type = GPIO_INTR_DISABLE .intr_type = GPIO_INTR_DISABLE
@ -35,85 +49,172 @@ void configure_gpio_pins(void)
gpio_config(&io_conf); gpio_config(&io_conf);
// Initialize all pins to LOW (off) // Initialize enable pins to LOW
gpio_set_level(LED_PIN, 0); gpio_set_level(LED_PIN, 0);
gpio_set_level(MOTOR_R_EN, 0); gpio_set_level(MOTOR_R_EN, 0);
gpio_set_level(MOTOR_L_EN, 0); gpio_set_level(MOTOR_L_EN, 0);
gpio_set_level(PWM_R_PIN, 0);
gpio_set_level(PWM_L_PIN, 0);
ESP_LOGI(TAG, "All GPIO pins configured and initialized to LOW"); ESP_LOGI(TAG, "GPIO pins configured");
} }
// Simulate turning motor on (enable pins HIGH, direction set) void configure_pwm(void)
void motor_enable_exhaust(void)
{ {
ESP_LOGI(TAG, "Motor ENABLE - Exhaust Mode"); ESP_LOGI(TAG, "Configuring PWM...");
gpio_set_level(LED_PIN, 1); // LED on for status
// For exhaust: only enable R side, disable L side // Configure PWM timer
gpio_set_level(MOTOR_R_EN, 1); // Enable R half-bridge for exhaust ledc_timer_config_t timer_conf = {
gpio_set_level(MOTOR_L_EN, 0); // Disable L half-bridge (not needed) .speed_mode = LEDC_LOW_SPEED_MODE,
vTaskDelay(pdMS_TO_TICKS(50)); // Small delay for enable to settle .timer_num = LEDC_TIMER_0,
.duty_resolution = PWM_RESOLUTION,
.freq_hz = PWM_FREQUENCY,
.clk_cfg = LEDC_AUTO_CLK
};
ledc_timer_config(&timer_conf);
gpio_set_level(PWM_R_PIN, 1); // "PWM" on for exhaust direction // Configure PWM channel for R_PWM
gpio_set_level(PWM_L_PIN, 0); // Other direction off 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);
// Configure PWM channel for L_PWM
channel_conf.channel = PWM_L_CHANNEL;
channel_conf.gpio_num = PWM_L_PIN;
ledc_channel_config(&channel_conf);
ESP_LOGI(TAG, "PWM configured - Frequency: %dHz, Resolution: %d-bit",
PWM_FREQUENCY, PWM_RESOLUTION);
} }
// Simulate changing to intake mode void set_motor_speed(motor_mode_t mode, int speed_percent)
void motor_enable_intake(void)
{ {
ESP_LOGI(TAG, "Motor ENABLE - Intake Mode"); if (speed_percent < 0) speed_percent = 0;
gpio_set_level(LED_PIN, 1); // LED on for status if (speed_percent > 100) speed_percent = 100;
// For intake: only enable L side, disable R side current_mode = mode;
gpio_set_level(MOTOR_R_EN, 0); // Disable R half-bridge (not needed) current_speed = speed_percent;
gpio_set_level(MOTOR_L_EN, 1); // Enable L half-bridge for intake
vTaskDelay(pdMS_TO_TICKS(50));
gpio_set_level(PWM_R_PIN, 0); // Switch directions // Convert percentage to PWM duty value (0-255 for 8-bit)
gpio_set_level(PWM_L_PIN, 1); // "PWM" on for intake direction uint32_t duty = (speed_percent * 255) / 100;
}
if (mode == MOTOR_OFF || speed_percent == 0) {
// Turn motor completely off ESP_LOGI(TAG, "Motor OFF");
void motor_disable(void)
{ // Turn off LED
ESP_LOGI(TAG, "Motor DISABLE"); gpio_set_level(LED_PIN, 0);
gpio_set_level(LED_PIN, 0); // LED off for status
gpio_set_level(MOTOR_R_EN, 0); // Disable motor driver // Disable both enables
gpio_set_level(MOTOR_L_EN, 0); gpio_set_level(MOTOR_R_EN, 0);
gpio_set_level(PWM_R_PIN, 0); // Turn off both "PWM" pins gpio_set_level(MOTOR_L_EN, 0);
gpio_set_level(PWM_L_PIN, 0);
// Set both PWM to 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 (mode == MOTOR_EXHAUST) {
ESP_LOGI(TAG, "Motor EXHAUST - Speed: %d%% (PWM duty: %d/255)",
speed_percent, duty);
// Turn on LED
gpio_set_level(LED_PIN, 1);
// Enable R side, disable L side
gpio_set_level(MOTOR_R_EN, 1);
gpio_set_level(MOTOR_L_EN, 0);
// Small delay for enables to settle
vTaskDelay(pdMS_TO_TICKS(10));
// Set PWM: R side active, L side off
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 (mode == MOTOR_INTAKE) {
ESP_LOGI(TAG, "Motor INTAKE - Speed: %d%% (PWM duty: %d/255)",
speed_percent, duty);
// Turn on LED
gpio_set_level(LED_PIN, 1);
// Enable L side, disable R side
gpio_set_level(MOTOR_R_EN, 0);
gpio_set_level(MOTOR_L_EN, 1);
// Small delay for enables to settle
vTaskDelay(pdMS_TO_TICKS(10));
// Set PWM: L side active, R side off
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);
}
} }
void app_main(void) void app_main(void)
{ {
ESP_LOGI(TAG, "Starting multi-GPIO motor control test!"); ESP_LOGI(TAG, "Starting PWM motor control test!");
// Configure all our pins // Configure hardware
configure_gpio_pins(); configure_gpio_pins();
configure_pwm();
ESP_LOGI(TAG, "Starting motor control sequence..."); ESP_LOGI(TAG, "Starting motor speed test sequence...");
while(1) { while(1) {
// Test sequence: Off -> Exhaust -> Off -> Intake -> Off // Test sequence: demonstrate variable speed control
ESP_LOGI(TAG, "=== Motor OFF ==="); ESP_LOGI(TAG, "\n=== EXHAUST MODE SPEED TEST ===");
motor_disable();
vTaskDelay(pdMS_TO_TICKS(2000)); // Wait 2 seconds
ESP_LOGI(TAG, "=== Motor EXHAUST Mode ==="); // Exhaust: ramp up from 0 to 100%
motor_enable_exhaust(); for (int speed = 0; speed <= 100; speed += 25) {
vTaskDelay(pdMS_TO_TICKS(3000)); // Run for 3 seconds set_motor_speed(MOTOR_EXHAUST, speed);
vTaskDelay(pdMS_TO_TICKS(2000)); // 2 seconds at each speed
}
ESP_LOGI(TAG, "=== Motor OFF ==="); // Turn off
motor_disable(); set_motor_speed(MOTOR_OFF, 0);
vTaskDelay(pdMS_TO_TICKS(2000)); vTaskDelay(pdMS_TO_TICKS(2000));
ESP_LOGI(TAG, "=== Motor INTAKE Mode ==="); ESP_LOGI(TAG, "\n=== INTAKE MODE SPEED TEST ===");
motor_enable_intake();
vTaskDelay(pdMS_TO_TICKS(3000)); // Run for 3 seconds
ESP_LOGI(TAG, "=== Cycle Complete - Restarting ==="); // Intake: ramp up from 0 to 100%
for (int speed = 0; speed <= 100; speed += 25) {
set_motor_speed(MOTOR_INTAKE, speed);
vTaskDelay(pdMS_TO_TICKS(2000)); // 2 seconds at each speed
}
// Turn off
set_motor_speed(MOTOR_OFF, 0);
vTaskDelay(pdMS_TO_TICKS(2000));
ESP_LOGI(TAG, "\n=== SMOOTH SPEED CHANGES ===");
// Demonstrate smooth speed changes in exhaust mode
set_motor_speed(MOTOR_EXHAUST, 30);
vTaskDelay(pdMS_TO_TICKS(2000));
set_motor_speed(MOTOR_EXHAUST, 60);
vTaskDelay(pdMS_TO_TICKS(2000));
set_motor_speed(MOTOR_EXHAUST, 90);
vTaskDelay(pdMS_TO_TICKS(2000));
set_motor_speed(MOTOR_EXHAUST, 40);
vTaskDelay(pdMS_TO_TICKS(2000));
set_motor_speed(MOTOR_OFF, 0);
vTaskDelay(pdMS_TO_TICKS(3000));
ESP_LOGI(TAG, "\n=== Cycle Complete - Restarting ===");
} }
} }