mirror of
https://github.com/alexandrebobkov/ESP-Nodes.git
synced 2025-08-08 07:56:15 +00:00
222 lines
6.8 KiB
C
222 lines
6.8 KiB
C
/* Robot Controls
|
|
Generate PWM signals to control motors.
|
|
|
|
By: Alexander Bobkov
|
|
Date: Dec 21, 2024
|
|
|
|
built-in LED GPIO: 10
|
|
build-in push button GPIO: 3
|
|
*/
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <inttypes.h>
|
|
#include "freertos/FreeRTOS.h"
|
|
#include "freertos/task.h"
|
|
#include "freertos/queue.h"
|
|
#include "driver/gpio.h"
|
|
#include "driver/ledc.h"
|
|
#include "driver/mcpwm.h"
|
|
#include "esp_log.h"
|
|
#include "led_strip.h"
|
|
#include "sdkconfig.h"
|
|
|
|
static const char *TAG = "ESP IDF Robot";
|
|
|
|
// LED
|
|
#define LEDC_TIMER LEDC_TIMER_0
|
|
#define LEDC_MODE LEDC_LOW_SPEED_MODE // LEDC_LOW_SPEED_MODE
|
|
#define LEDC_OUTPUT_IO (5) // Define the output GPIO
|
|
#define LEDC_CHANNEL LEDC_CHANNEL_0
|
|
#define LEDC_DUTY_RES LEDC_TIMER_10_BIT // Set duty resolution to 13 bits
|
|
#define LEDC_DUTY (4096) // Set duty to 50%. (2 ** 13) * 50% = 4096 1024
|
|
#define LEDC_FREQUENCY (5000) // For LED the freuqncy of 500Hz seemed to be sufficient. // Frequency in Hertz. For DC motor, set frequency at 5 kHz
|
|
|
|
/* Use project configuration menu (idf.py menuconfig) to choose the GPIO to blink,
|
|
or you can edit the following line and set a number here.
|
|
*/
|
|
|
|
// Retrieve values from configuration menu
|
|
#define BLINK_GPIO CONFIG_BLINK_GPIO // 10 GPIO of on-board LED
|
|
#define PUSH_BTN_GPIO CONFIG_BUTTON_GPIO // 3 GPIO of on-board push-button
|
|
#define MTR_FL_GPIO CONFIG_MOTOR_FRONT_LEFT_GPIO
|
|
|
|
#define ESP_INTR_FLAG_DEFAULT 0
|
|
|
|
#define GPIO_INPUT_PIN_SEL ((1ULL<<PUSH_BTN_GPIO))
|
|
#define GPIO_OUTPUT_PIN_SEL ((1ULL<<BLINK_GPIO))
|
|
|
|
static QueueHandle_t gpio_evt_queue = NULL;
|
|
|
|
static uint8_t s_led_state = 0;
|
|
|
|
#ifdef CONFIG_BLINK_LED_STRIP
|
|
|
|
static led_strip_handle_t led_strip;
|
|
|
|
static void blink_led(void)
|
|
{
|
|
/* If the addressable LED is enabled */
|
|
if (s_led_state) {
|
|
/* Set the LED pixel using RGB from 0 (0%) to 255 (100%) for each color */
|
|
led_strip_set_pixel(led_strip, 0, 16, 16, 16);
|
|
/* Refresh the strip to send data */
|
|
led_strip_refresh(led_strip);
|
|
} else {
|
|
/* Set all LED off to clear all pixels */
|
|
led_strip_clear(led_strip);
|
|
}
|
|
}
|
|
|
|
static void configure_led(void)
|
|
{
|
|
ESP_LOGI(TAG, "Example configured to blink addressable LED!");
|
|
/* LED strip initialization with the GPIO and pixels number*/
|
|
led_strip_config_t strip_config = {
|
|
.strip_gpio_num = BLINK_GPIO,
|
|
.max_leds = 1, // at least one LED on board
|
|
};
|
|
#if CONFIG_BLINK_LED_STRIP_BACKEND_RMT
|
|
led_strip_rmt_config_t rmt_config = {
|
|
.resolution_hz = 10 * 1000 * 1000, // 10MHz
|
|
.flags.with_dma = false,
|
|
};
|
|
ESP_ERROR_CHECK(led_strip_new_rmt_device(&strip_config, &rmt_config, &led_strip));
|
|
#elif CONFIG_BLINK_LED_STRIP_BACKEND_SPI
|
|
led_strip_spi_config_t spi_config = {
|
|
.spi_bus = SPI2_HOST,
|
|
.flags.with_dma = true,
|
|
};
|
|
ESP_ERROR_CHECK(led_strip_new_spi_device(&strip_config, &spi_config, &led_strip));
|
|
#else
|
|
#error "unsupported LED strip backend"
|
|
#endif
|
|
/* Set all LED off to clear all pixels */
|
|
led_strip_clear(led_strip);
|
|
}
|
|
|
|
#elif CONFIG_BLINK_LED_GPIO
|
|
|
|
static void blink_led(void)
|
|
{
|
|
/* Set the GPIO level according to the state (LOW or HIGH)*/
|
|
gpio_set_level(BLINK_GPIO, s_led_state);
|
|
}
|
|
|
|
static void IRAM_ATTR gpio_isr_handler (void* arg) {
|
|
uint32_t gpio_num = (uint32_t) arg;
|
|
xQueueSendFromISR(gpio_evt_queue, &gpio_num, NULL);
|
|
}
|
|
|
|
static void gpio_task (void* arg) {
|
|
uint32_t io_num;
|
|
for (;;) {
|
|
if (xQueueReceive(gpio_evt_queue, &io_num, portMAX_DELAY)) {
|
|
printf("GPIO[%"PRIu32"] intr, val: %d\n", io_num, gpio_get_level(io_num));
|
|
}
|
|
}
|
|
}
|
|
static void configure_led(void)
|
|
{
|
|
ESP_LOGI(TAG, "Configured to blink GPIO LED!");
|
|
gpio_reset_pin(BLINK_GPIO);
|
|
/* Set the GPIO as a push/pull output */
|
|
gpio_set_direction(BLINK_GPIO, GPIO_MODE_OUTPUT);
|
|
}
|
|
|
|
static void configure_button (void) {
|
|
ESP_LOGI(TAG, "Configured on-board push button");
|
|
//gpio_reset_pin(PUSH_BTN_GPIO);
|
|
//gpio_set_direction(PUSH_BTN_GPIO, GPIO_MODE_INPUT);
|
|
}
|
|
|
|
static void configure_dc_mc (void) {
|
|
|
|
mcpwm_gpio_init(MCPWM_UNIT_0, MCPWM0A, MTR_FL_GPIO);
|
|
|
|
mcpwm_config_t mcpwm_config;
|
|
|
|
mcpwm_config.frequency = 4000;
|
|
mcpwm_config.cmpr_a = 50;
|
|
mcpwm_config.counter_mode = MCPWM_UP_COUNTER;
|
|
mcpwm_config.duty_mode = MCPWM_DUTY_MODE_0;
|
|
mcpwm_init(MCPWM_UNIT_0, MCPWM_TIMER_0, &mcpwm_config);
|
|
|
|
mcpwm_set_duty_type(MCPWM_UNIT_0, MCPWM_TIMER_0, MCPWM_OPR_A, MCPWM_DUTY_MODE_0);
|
|
mcpwm_set_duty(MCPWM_UNIT_0, MCPWM_TIMER_0, MCPWM_OPR_A,50);
|
|
}
|
|
|
|
#else
|
|
#error "unsupported LED type"
|
|
#endif
|
|
|
|
static void ledc_init (void) {
|
|
ledc_timer_config_t ledc_timer = {
|
|
.speed_mode = LEDC_MODE,//MODE,
|
|
.duty_resolution = LEDC_DUTY_RES,
|
|
.timer_num = LEDC_TIMER,
|
|
.freq_hz = LEDC_FREQUENCY,
|
|
.clk_cfg = LEDC_AUTO_CLK
|
|
};
|
|
ESP_ERROR_CHECK(ledc_timer_config(&ledc_timer));
|
|
|
|
ledc_channel_config_t ledc_channel = {
|
|
.speed_mode = LEDC_MODE,
|
|
.channel = LEDC_CHANNEL,
|
|
.timer_sel = LEDC_TIMER,
|
|
.intr_type = LEDC_INTR_DISABLE,
|
|
.gpio_num = LEDC_OUTPUT_IO,
|
|
.duty = LEDC_DUTY,//0,
|
|
.hpoint = 1,
|
|
};
|
|
ESP_ERROR_CHECK(ledc_channel_config(&ledc_channel));
|
|
}
|
|
|
|
void app_main(void)
|
|
{
|
|
// Initialize LED
|
|
ledc_init();
|
|
ESP_ERROR_CHECK(ledc_set_duty(LEDC_MODE, LEDC_CHANNEL, LEDC_DUTY));
|
|
ESP_ERROR_CHECK(ledc_update_duty(LEDC_MODE, LEDC_CHANNEL));
|
|
// Initialize the config structure.
|
|
gpio_config_t io_conf = {};
|
|
|
|
/* Configure the peripheral according to the LED type */
|
|
//configure_led();
|
|
|
|
// Configure on-board LED
|
|
io_conf.intr_type = GPIO_INTR_DISABLE;
|
|
io_conf.mode = GPIO_MODE_OUTPUT;
|
|
io_conf.pin_bit_mask = GPIO_OUTPUT_PIN_SEL;
|
|
io_conf.pull_down_en = 0;
|
|
io_conf.pull_up_en = 0;
|
|
gpio_config(&io_conf);
|
|
|
|
// Configure on-board push button
|
|
io_conf.intr_type = GPIO_INTR_POSEDGE;
|
|
io_conf.pin_bit_mask = GPIO_INPUT_PIN_SEL;
|
|
io_conf.mode = GPIO_MODE_INPUT;
|
|
io_conf.pull_up_en = 1;
|
|
gpio_config(&io_conf);
|
|
|
|
// Set push button interrupt
|
|
gpio_set_intr_type(PUSH_BTN_GPIO, GPIO_INTR_NEGEDGE);//ANYEDGE);
|
|
gpio_evt_queue = xQueueCreate(10, sizeof(uint32_t));
|
|
xTaskCreate(gpio_task, "GPIO task", 2048, NULL, 10, NULL);
|
|
gpio_install_isr_service(ESP_INTR_FLAG_DEFAULT);
|
|
gpio_isr_handler_add(PUSH_BTN_GPIO, gpio_isr_handler, (void*) PUSH_BTN_GPIO);
|
|
|
|
configure_button();
|
|
configure_dc_mc();
|
|
|
|
printf("Added button interrupt");
|
|
|
|
while (1) {
|
|
ESP_LOGI(TAG, "Turning the LED %s!", s_led_state == true ? "ON" : "OFF");
|
|
//blink_led();
|
|
/* Toggle the LED state */
|
|
gpio_set_level(BLINK_GPIO, s_led_state);
|
|
s_led_state = !s_led_state;
|
|
vTaskDelay(CONFIG_BLINK_PERIOD / portTICK_PERIOD_MS);
|
|
}
|
|
}
|