/* 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" /* ADC */ #include "rc.h" //#include "driver/adc.h" //#include "esp_adc_cal.h" //#include "esp_adc/adc_oneshot.h" //#include "esp_adc/adc_cali.h" //#include "esp_adc/adc_cali_scheme.h" #include "esp_adc/adc_continuous.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 // ADC #define ADC_ATTEN ADC_ATTEN_DB_11 #define ADC_BIT_WIDTH SOC_ADC_DIGI_MAX_BITWIDTH #define ADC_UNIT ADC_UNIT_1 #define ADC_CONV_MODE ADC_CONV_BOTH_UNIT// ADC_CONV_SINGLE_UNIT_1 #define ADC_OUTPUT_TYPE ADC_DIGI_OUTPUT_FORMAT_TYPE2 // ESP32C3 #define READ_LEN 1024//256 #define ADC_GET_CHANNEL(p_data) ((p_data)->type2.channel) #define ADC_GET_DATA(p_data) ((p_data)->type2.data) #define PROJ_X (0) // ADC1_CH0; 0 GPIO joystick, x-axis #define PROJ_Y (1) // ADC1_CH1; 1 GPIO joystick, y-axis #define NAV_BTN (8) // 8 GPIO joystick button #define _ADC_UNIT_STR(unit) #unit #define ADC_UNIT_STR(unit) _ADC_UNIT_STR(unit) uint32_t x_avg = 0, y_avg = 0; static TaskHandle_t s_task_handle; //static adc_channel_t channel[2] = {ADC_CHANNEL_2, ADC_CHANNEL_3}; static adc_channel_t channel[2] = {ADC_CHANNEL_0, ADC_CHANNEL_1}; //static int adc_raw[2][10]; //static int voltage[2][10]; //static bool adc_calibration_init(adc_unit_t unit, adc_channel_t channel, adc_atten_t atten, adc_cali_handle_t *out_handle); //static void adc_calibration_deinit(adc_cali_handle_t handle); #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 = ESPNOW_RECV_CB; memcpy(recv_cb->mac_addr, mac_addr, ESP_NOW_ETH_ALEN); recv_cb->data = malloc(len); // Display payload received. ESP_LOGW(TAG, "Received payload: %x", (unsigned int)recv_cb->data); 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 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); // Display received data. ESP_LOGW(TAG, "Received data size: %d", data_len); ESP_LOGW(TAG, "Payload: %x", (uint8_t)buf->payload); ESP_LOGW(TAG, "payload[0] = %x", (uint8_t)buf->payload[0]); ESP_LOGW(TAG, "payload[1] = %x", (uint8_t)buf->payload[1]); if (crc_cal == crc) { return buf->type; } return -1; } void espnow_data_prepare(espnow_send_param_t *send_param) { // Data struct 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 */ buf->payload[0] = (uint8_t)3; buf->payload[1] = (uint8_t)3; //esp_fill_random(buf->payload, send_param->len - sizeof(espnow_data_t)); ESP_LOGW(TAG, "payload[0]: %x", buf->payload[0]); ESP_LOGW(TAG, "payload[1]: %x", buf->payload[1]); 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; esp_err_t task_status; vTaskDelay(5000 / portTICK_PERIOD_MS); ESP_LOGI(TAG, "Start sending broadcast data"); /* Start sending broadcast ESPNOW data. */ // Retrieve send parameters passed as reference. espnow_send_param_t *send_param = (espnow_send_param_t *)pvParameter; // Send data to the destination MAC address. 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) { // Send Callback case 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)); // Copy destination MAC address to the parameters struct. memcpy(send_param->dest_mac, send_cb->mac_addr, ESP_NOW_ETH_ALEN); // Append data struct to the parameters struct. 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); } /* task_status = esp_now_send(send_param->dest_mac, send_param->buffer, send_param->len); if (task_status != ESP_OK) { ESP_LOGE(TAG, "Send error"); espnow_deinit(send_param); vTaskDelete(NULL); }*/ break; } // Receive callback. case ESPNOW_RECV_CB: { espnow_event_recv_cb_t *recv_cb = &evt.info.recv_cb; ret = espnow_data_parse(recv_cb->data, recv_cb->data_len, &recv_state, &recv_seq, &recv_magic); free(recv_cb->data); /* ======== BROADCAST ======== */ // If data was sent to all devices (broadcast) 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; } } } } /* ======== UNICAST ======== */ // If data was sent to the specific device (unicast) 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; // The higher the magic number is, the lower the priority of the device is // higher number -> receiver send_param->magic = 55;//esp_random(); // Arbitrary number that determines which device is sender/receiver. send_param->count = CONFIG_ESPNOW_SEND_COUNT; send_param->delay = CONFIG_ESPNOW_SEND_DELAY; send_param->len = CONFIG_ESPNOW_SEND_LEN; // Maximum data length is ESP_NOW_MAX_DATA_LEN = 250 send_param->buffer = malloc(CONFIG_ESPNOW_SEND_LEN); // malloc(sizeof(message)); // malloc(CONFIG_ESPNOW_SEND_LEN); // Data to be sent? 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, "robot_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(); } /*--------------------------------------------------------------- ADC Calibration ---------------------------------------------------------------*/ /*static bool adc_calibration_init(adc_unit_t unit, adc_channel_t channel, adc_atten_t atten, adc_cali_handle_t *out_handle) { adc_cali_handle_t handle = NULL; esp_err_t ret = ESP_FAIL; bool calibrated = false; #if ADC_CALI_SCHEME_CURVE_FITTING_SUPPORTED if (!calibrated) { ESP_LOGI(TAG, "calibration scheme version is %s", "Curve Fitting"); adc_cali_curve_fitting_config_t cali_config = { .unit_id = unit, .chan = channel, .atten = atten, .bitwidth = ADC_BITWIDTH_DEFAULT, }; ret = adc_cali_create_scheme_curve_fitting(&cali_config, &handle); if (ret == ESP_OK) { calibrated = true; } } #endif #if ADC_CALI_SCHEME_LINE_FITTING_SUPPORTED if (!calibrated) { ESP_LOGI(TAG, "calibration scheme version is %s", "Line Fitting"); adc_cali_line_fitting_config_t cali_config = { .unit_id = unit, .atten = atten, .bitwidth = ADC_BITWIDTH_DEFAULT, }; ret = adc_cali_create_scheme_line_fitting(&cali_config, &handle); if (ret == ESP_OK) { calibrated = true; } } #endif *out_handle = handle; if (ret == ESP_OK) { ESP_LOGI(TAG, "Calibration Success"); } else if (ret == ESP_ERR_NOT_SUPPORTED || !calibrated) { ESP_LOGW(TAG, "eFuse not burnt, skip software calibration"); } else { ESP_LOGE(TAG, "Invalid arg or no memory"); } return calibrated; } static void adc_calibration_deinit(adc_cali_handle_t handle) { #if ADC_CALI_SCHEME_CURVE_FITTING_SUPPORTED ESP_LOGI(TAG, "deregister %s calibration scheme", "Curve Fitting"); ESP_ERROR_CHECK(adc_cali_delete_scheme_curve_fitting(handle)); #elif ADC_CALI_SCHEME_LINE_FITTING_SUPPORTED ESP_LOGI(TAG, "deregister %s calibration scheme", "Line Fitting"); ESP_ERROR_CHECK(adc_cali_delete_scheme_line_fitting(handle)); #endif }*/ static bool IRAM_ATTR s_conv_done_cb(adc_continuous_handle_t handle, const adc_continuous_evt_data_t *edata, void *user_data) { BaseType_t mustYield = pdFALSE; //Notify that ADC continuous driver has done enough number of conversions vTaskNotifyGiveFromISR(s_task_handle, &mustYield); return (mustYield == pdTRUE); } static void continuous_adc_init(adc_channel_t *channel, uint8_t channel_num, adc_continuous_handle_t *out_handle) { adc_continuous_handle_t handle = NULL; adc_continuous_handle_cfg_t adc_config = { .max_store_buf_size = 1024, .conv_frame_size = READ_LEN, }; ESP_ERROR_CHECK(adc_continuous_new_handle(&adc_config, &handle)); adc_continuous_config_t dig_cfg = { .sample_freq_hz = 20 * 1000, .conv_mode = ADC_CONV_MODE, .format = ADC_OUTPUT_TYPE, }; adc_digi_pattern_config_t adc_pattern[SOC_ADC_PATT_LEN_MAX] = {0}; dig_cfg.pattern_num = channel_num; for (int i = 0; i < channel_num; i++) { adc_pattern[i].atten = ADC_ATTEN; adc_pattern[i].channel = channel[i] & 0x7; adc_pattern[i].unit = ADC_UNIT; adc_pattern[i].bit_width = ADC_BIT_WIDTH; ESP_LOGI(TAG, "adc_pattern[%d].atten is :%"PRIx8, i, adc_pattern[i].atten); ESP_LOGI(TAG, "adc_pattern[%d].channel is :%"PRIx8, i, adc_pattern[i].channel); ESP_LOGI(TAG, "adc_pattern[%d].unit is :%"PRIx8, i, adc_pattern[i].unit); } dig_cfg.adc_pattern = adc_pattern; ESP_ERROR_CHECK(adc_continuous_config(handle, &dig_cfg)); *out_handle = handle; } 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 navigation button io_conf.intr_type = GPIO_INTR_NEGEDGE; 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 navigation button interrupt gpio_set_intr_type(NAV_BTN, 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(NAV_BTN, gpio_isr_handler, (void*) NAV_BTN); configure_button(); //configure_dc_mc(); printf("Added button interrupt"); // ESP-NOW // 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 ); wifi_init(); espnow_init(); //esp_now_add_peer(&peerInfo); /* ADC */ rc_adc_init(); rc_get_raw_data(); /* esp_err_t adc_ret; uint32_t ret_num = 0; uint8_t result[READ_LEN] = {0}; memset(result, 0xcc, READ_LEN); s_task_handle = xTaskGetCurrentTaskHandle(); adc_continuous_handle_t handle = NULL; continuous_adc_init(channel, sizeof(channel) / sizeof(adc_channel_t), &handle); adc_continuous_evt_cbs_t cbs = { .on_conv_done = s_conv_done_cb, }; ESP_ERROR_CHECK(adc_continuous_register_event_callbacks(handle, &cbs, NULL)); ESP_ERROR_CHECK(adc_continuous_start(handle)); ulTaskNotifyTake(pdTRUE, portMAX_DELAY); char unit[] = ADC_UNIT_STR(ADC_UNIT);*/ 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; // ADC // Display GPIOs used //ESP_LOGI(TAG, "ADC1_CH0: %d", ADC1_CHANNEL_0); //ESP_LOGI(TAG, "ADC1_CH1: %d", ADC1_CHANNEL_1); /*adc_ret = adc_continuous_read(handle, result, READ_LEN, &ret_num, 0); if (ret == ESP_OK) { ESP_LOGI("TASK", "ret is %x, ret_num is %"PRIu32" bytes", ret, ret_num); for (int i = 0; i < ret_num; i += SOC_ADC_DIGI_RESULT_BYTES) { adc_digi_output_data_t *p = (adc_digi_output_data_t*)&result[i]; uint32_t chan_num = ADC_GET_CHANNEL(p); uint32_t data = ADC_GET_DATA(p); // Check the channel number validation, the data is invalid if the channel num exceed the maximum channel if (chan_num < SOC_ADC_CHANNEL_NUM(ADC_UNIT)) { ESP_LOGI(TAG, "Unit: %s, Channel: %"PRIu32", Value: %"PRIx32, unit, chan_num, data); } else { ESP_LOGW(TAG, "Invalid data [%s_%"PRIu32"_%"PRIx32"]", unit, chan_num, data); } } //vTaskDelay(1); vTaskDelay(CONFIG_BLINK_PERIOD / portTICK_PERIOD_MS); } else if (ret == ESP_ERR_TIMEOUT) { //We try to read `EXAMPLE_READ_LEN` until API returns timeout, which means there's no available data break; }*/ vTaskDelay(CONFIG_BLINK_PERIOD / portTICK_PERIOD_MS); } //ESP_ERROR_CHECK(adc_continuous_stop(handle)); //ESP_ERROR_CHECK(adc_continuous_deinit(handle)); }