/* 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 #include #include #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" /* ESP-NOW */ #include #include #include "freertos/semphr.h" #include "freertos/timers.h" #include "nvs_flash.h" #include "esp_random.h" #include "esp_event.h" #include "esp_log.h" #include "esp_crc.h" #include "esp_netif.h" #include "esp_now.h" #include "esp_mac.h" //#include "espnow_utils.h" #include "esp_wifi.h" #include "esp_system.h" #include "espnow_config.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_13_BIT // /* TIMER RESOLUTION MAX VALUE HALF-DUTY 10 1023 511 13 8191 4095 */ #define LEDC_DUTY (7820) // 8068, 7944, 7820, 7696, 7572, *7680*, 7424, 7168, 6144, 512, 768 #define LEDC_FREQUENCY (4000) // For LED the freuqncy of 500Hz seems 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 0 //CONFIG_MOTOR_FRONT_LEFT_GPIO #define ESP_INTR_FLAG_DEFAULT 0 #define GPIO_INPUT_PIN_SEL ((1ULL<mac_addr, mac_addr, ESP_NOW_ETH_ALEN); send_cb->status = status; if (xQueueSend(espnow_queue, &evt, ESPNOW_MAXDELAY) != pdTRUE) { ESP_LOGW(TAG, "Send send queue fail"); } } static void espnow_recv_cb (const esp_now_recv_info_t *recv_info, const uint8_t *data, int len) { espnow_event_t evt; espnow_event_recv_cb_t *recv_cb = &evt.info.recv_cb; uint8_t * mac_addr = recv_info->src_addr; uint8_t * des_addr = recv_info->des_addr; if (mac_addr == NULL || data == NULL || len <= 0) { ESP_LOGE(TAG, "Receive cb arg error"); return; } if (IS_BROADCAST_ADDR(des_addr)) { /* If added a peer with encryption before, the receive packets may be * encrypted as peer-to-peer message or unencrypted over the broadcast channel. * Users can check the destination address to distinguish it. */ ESP_LOGD(TAG, "Receive broadcast ESPNOW data"); } else { ESP_LOGD(TAG, "Receive unicast ESPNOW data"); } evt.id = EXAMPLE_ESPNOW_RECV_CB; memcpy(recv_cb->mac_addr, mac_addr, ESP_NOW_ETH_ALEN); recv_cb->data = malloc(len); if (recv_cb->data == NULL) { ESP_LOGE(TAG, "Malloc receive data fail"); return; } memcpy(recv_cb->data, data, len); recv_cb->data_len = len; if (xQueueSend(espnow_queue, &evt, ESPNOW_MAXDELAY) != pdTRUE) { ESP_LOGW(TAG, "Send receive queue fail"); free(recv_cb->data); } } /* Parse received ESPNOW data. */ int example_espnow_data_parse(uint8_t *data, uint16_t data_len, uint8_t *state, uint16_t *seq, uint32_t *magic) { espnow_data_t *buf = (espnow_data_t *)data; uint16_t crc, crc_cal = 0; if (data_len < sizeof(espnow_data_t)) { ESP_LOGE(TAG, "Receive ESPNOW data too short, len:%d", data_len); return -1; } *state = buf->state; *seq = buf->seq_num; *magic = buf->magic; crc = buf->crc; buf->crc = 0; crc_cal = esp_crc16_le(UINT16_MAX, (uint8_t const *)buf, data_len); if (crc_cal == crc) { return buf->type; } return -1; } void espnow_data_prepare(espnow_send_param_t *send_param) { espnow_data_t *buf = (espnow_data_t *)send_param->buffer; assert(send_param->len >= sizeof(espnow_data_t)); buf->type = IS_BROADCAST_ADDR(send_param->dest_mac) ? ESPNOW_DATA_BROADCAST : ESPNOW_DATA_UNICAST; buf->state = send_param->state; buf->seq_num = espnow_seq[buf->type]++; buf->crc = 0; buf->magic = send_param->magic; /* Fill all remaining bytes after the data with random values */ esp_fill_random(buf->payload, send_param->len - sizeof(espnow_data_t)); buf->crc = esp_crc16_le(UINT16_MAX, (uint8_t const *)buf, send_param->len); } static void espnow_task (void *pvParameter) { espnow_event_t evt; uint8_t recv_state = 0; uint16_t recv_seq = 0; uint32_t recv_magic = 0; bool is_broadcast = false; int ret; vTaskDelay(5000 / portTICK_PERIOD_MS); ESP_LOGI(TAG, "Start sending broadcast data"); /* Start sending broadcast ESPNOW data. */ espnow_send_param_t *send_param = (espnow_send_param_t *)pvParameter; if (esp_now_send(send_param->dest_mac, send_param->buffer, send_param->len) != ESP_OK) { ESP_LOGE(TAG, "Send error"); espnow_deinit(send_param); vTaskDelete(NULL); } while (xQueueReceive(espnow_queue, &evt, portMAX_DELAY) == pdTRUE) { switch (evt.id) { case EXAMPLE_ESPNOW_SEND_CB: { espnow_event_send_cb_t *send_cb = &evt.info.send_cb; is_broadcast = IS_BROADCAST_ADDR(send_cb->mac_addr); ESP_LOGD(TAG, "Send data to "MACSTR", status1: %d", MAC2STR(send_cb->mac_addr), send_cb->status); if (is_broadcast && (send_param->broadcast == false)) { break; } if (!is_broadcast) { send_param->count--; if (send_param->count == 0) { ESP_LOGI(TAG, "Send done"); espnow_deinit(send_param); vTaskDelete(NULL); } } /* Delay a while before sending the next data. */ if (send_param->delay > 0) { vTaskDelay(send_param->delay/portTICK_PERIOD_MS); } ESP_LOGI(TAG, "send data to "MACSTR"", MAC2STR(send_cb->mac_addr)); memcpy(send_param->dest_mac, send_cb->mac_addr, ESP_NOW_ETH_ALEN); espnow_data_prepare(send_param); /* Send the next data after the previous data is sent. */ if (esp_now_send(send_param->dest_mac, send_param->buffer, send_param->len) != ESP_OK) { ESP_LOGE(TAG, "Send error"); espnow_deinit(send_param); vTaskDelete(NULL); } break; } case EXAMPLE_ESPNOW_RECV_CB: { espnow_event_recv_cb_t *recv_cb = &evt.info.recv_cb; ret = example_espnow_data_parse(recv_cb->data, recv_cb->data_len, &recv_state, &recv_seq, &recv_magic); free(recv_cb->data); if (ret == ESPNOW_DATA_BROADCAST) { ESP_LOGI(TAG, "Receive %dth broadcast data from: "MACSTR", len: %d", recv_seq, MAC2STR(recv_cb->mac_addr), recv_cb->data_len); /* If MAC address does not exist in peer list, add it to peer list. */ if (esp_now_is_peer_exist(recv_cb->mac_addr) == false) { esp_now_peer_info_t *peer = malloc(sizeof(esp_now_peer_info_t)); if (peer == NULL) { ESP_LOGE(TAG, "Malloc peer information fail"); espnow_deinit(send_param); vTaskDelete(NULL); } memset(peer, 0, sizeof(esp_now_peer_info_t)); peer->channel = CONFIG_ESPNOW_CHANNEL; peer->ifidx = ESPNOW_WIFI_IF; peer->encrypt = true; memcpy(peer->lmk, CONFIG_ESPNOW_LMK, ESP_NOW_KEY_LEN); memcpy(peer->peer_addr, recv_cb->mac_addr, ESP_NOW_ETH_ALEN); ESP_ERROR_CHECK( esp_now_add_peer(peer) ); free(peer); } /* Indicates that the device has received broadcast ESPNOW data. */ if (send_param->state == 0) { send_param->state = 1; } /* If receive broadcast ESPNOW data which indicates that the other device has received * broadcast ESPNOW data and the local magic number is bigger than that in the received * broadcast ESPNOW data, stop sending broadcast ESPNOW data and start sending unicast * ESPNOW data. */ if (recv_state == 1) { /* The device which has the bigger magic number sends ESPNOW data, the other one * receives ESPNOW data. */ if (send_param->unicast == false && send_param->magic >= recv_magic) { ESP_LOGI(TAG, "Start sending unicast data"); ESP_LOGI(TAG, "send data to "MACSTR"", MAC2STR(recv_cb->mac_addr)); /* Start sending unicast ESPNOW data. */ memcpy(send_param->dest_mac, recv_cb->mac_addr, ESP_NOW_ETH_ALEN); espnow_data_prepare(send_param); if (esp_now_send(send_param->dest_mac, send_param->buffer, send_param->len) != ESP_OK) { ESP_LOGE(TAG, "Send error"); espnow_deinit(send_param); vTaskDelete(NULL); } else { send_param->broadcast = false; send_param->unicast = true; } } } } else if (ret == ESPNOW_DATA_UNICAST) { ESP_LOGI(TAG, "Receive %dth unicast data from: "MACSTR", len: %d", recv_seq, MAC2STR(recv_cb->mac_addr), recv_cb->data_len); /* If receive unicast ESPNOW data, also stop sending broadcast ESPNOW data. */ send_param->broadcast = false; } else { ESP_LOGI(TAG, "Receive error data from: "MACSTR"", MAC2STR(recv_cb->mac_addr)); } break; } default: ESP_LOGE(TAG, "Callback type error: %d", evt.id); break; } } } static esp_err_t espnow_init(void) { espnow_send_param_t *send_param; espnow_queue = xQueueCreate(ESPNOW_QUEUE_SIZE, sizeof(espnow_event_t)); // Confirm that queue exists, and continue if so. if (espnow_queue == NULL) { ESP_LOGE(TAG, "Create ESP-NOW mutex failed."); return ESP_FAIL; } /* Initialize ESPNOW and register sending and receiving callback function. */ ESP_ERROR_CHECK( esp_now_init() ); ESP_ERROR_CHECK( esp_now_register_send_cb(espnow_send_cb) ); ESP_ERROR_CHECK( esp_now_register_recv_cb(espnow_recv_cb) ); #if CONFIG_ESPNOW_ENABLE_POWER_SAVE ESP_ERROR_CHECK( esp_now_set_wake_window(CONFIG_ESPNOW_WAKE_WINDOW) ); ESP_ERROR_CHECK( esp_wifi_connectionless_module_set_wake_interval(CONFIG_ESPNOW_WAKE_INTERVAL) ); #endif /* Set primary master key in menuconfig. */ ESP_ERROR_CHECK( esp_now_set_pmk((uint8_t *)CONFIG_ESPNOW_PMK) ); /* Add broadcast peer information to peer list. */ esp_now_peer_info_t *peer = malloc(sizeof(esp_now_peer_info_t)); if (peer == NULL) { ESP_LOGE(TAG, "Malloc peer information fail"); vSemaphoreDelete(espnow_queue); esp_now_deinit(); return ESP_FAIL; } memset(peer, 0, sizeof(esp_now_peer_info_t)); peer->channel = CONFIG_ESPNOW_CHANNEL; peer->ifidx = ESPNOW_WIFI_IF; peer->encrypt = false; memcpy(peer->peer_addr, broadcast_mac, ESP_NOW_ETH_ALEN); ESP_ERROR_CHECK( esp_now_add_peer(peer) ); free(peer); /* Initialize sending parameters. */ send_param = malloc(sizeof(espnow_send_param_t)); if (send_param == NULL) { ESP_LOGE(TAG, "Malloc send parameter fail"); vSemaphoreDelete(espnow_queue); esp_now_deinit(); return ESP_FAIL; } memset(send_param, 0, sizeof(espnow_send_param_t)); send_param->unicast = false; send_param->broadcast = true; send_param->state = 0; send_param->magic = esp_random(); send_param->count = CONFIG_ESPNOW_SEND_COUNT; send_param->delay = CONFIG_ESPNOW_SEND_DELAY; send_param->len = CONFIG_ESPNOW_SEND_LEN; send_param->buffer = malloc(CONFIG_ESPNOW_SEND_LEN); if (send_param->buffer == NULL) { ESP_LOGE(TAG, "Malloc send buffer fail"); free(send_param); vSemaphoreDelete(espnow_queue); esp_now_deinit(); return ESP_FAIL; } memcpy(send_param->dest_mac, broadcast_mac, ESP_NOW_ETH_ALEN); espnow_data_prepare(send_param); xTaskCreate(espnow_task, "example_espnow_task", 2048, send_param, 4, NULL); return ESP_OK; } static void espnow_deinit(espnow_send_param_t *send_param) { free(send_param->buffer); free(send_param); vSemaphoreDelete(espnow_queue); esp_now_deinit(); } void app_main(void) { // Initialize LED ledc_init(); // 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"); // ESP-NOW wifi_init(); espnow_init(); //esp_now_add_peer(&peerInfo); 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); } }