ESP32 esp-idf Serial Over Bluetooth サンプルプログラム #3

どうやら、テキストファイルの先頭２行目以降が、送られない事が判りました。

細かい解説は、後で書くとして取り敢えず、バグ修正をしたコードを記載します。

example_spp_acceptor_demo.c
/* This example code is in the Public Domain (or CC0 licensed, at your option.) Unless required by applicable law or agreed to in writing, this software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */ #include <stdint.h> #include <string.h> #include <stdbool.h> #include <stdio.h> #include "osi/fixed_queue.h" #include "osi/allocator.h" #include "nvs.h" #include "nvs_flash.h" #include "freertos/FreeRTOS.h" #include "freertos/task.h" #include "esp_log.h" #include "esp_bt.h" #include "esp_bt_main.h" #include "esp_gap_bt_api.h" #include "esp_bt_device.h" #include "esp_spp_api.h" #include "time.h" #include "sys/time.h" #define SPP_TAG "SPP_ACCEPTOR_DEMO" #define SPP_SERVER_NAME "SPP_SERVER" #define EXCAMPLE_DEVICE_NAME "ESP_SPP_ACCEPTOR" // add by nishi start #include "driver/uart.h" #include "freertos/queue.h" #define QUEUE_SIZE 256 //#define ECHO_BACK_ON static uint32_t _spp_client = 0; static xQueueHandle _spp_queue = NULL; static xTaskHandle spp_uart_task_dr_hdl = NULL; static xTaskHandle uart_event_task_dr_hdl = NULL; #define MY_QUEUE_SIZE_MAX 30 fixed_queue_t *spp_rdata_fxq; static const char *TAG = "uart_events"; typedef struct{ uint16_t len; /*!< The length of data */ uint8_t data[]; /*!< The data received */ } SPP_UART_DT_BUF; /*!< SPP callback param of ESP_SPP_DATA_IND_EVT */ /** * This example shows how to use the UART driver to handle special UART events. * * It also reads data from UART0 directly, and echoes it to console. * * - Port: UART0 * - Receive (Rx) buffer: on * - Transmit (Tx) buffer: off * - Flow control: off * - Event queue: on * - Pin assignment: TxD (default), RxD (default) */ //#define EX_UART_NUM UART_NUM_0 #define EX_UART_NUM UART_NUM_2 #define PATTERN_CHR_NUM (3) /*!< Set the number of consecutive and identical characters received by receiver which defines a UART pattern*/ #define ECHO_TEST_TXD (17) #define ECHO_TEST_RXD (16) #define ECHO_TEST_RTS (UART_PIN_NO_CHANGE) #define ECHO_TEST_CTS (UART_PIN_NO_CHANGE) #define BUF_SIZE (1024) #define RD_BUF_SIZE (BUF_SIZE) static QueueHandle_t uart0_queue; size_t BluetoothSerial_write(const uint8_t *src,size_t size); /* * Uart2 Event Task */ static void uart_event_task(void *pvParameters) { uart_event_t event; size_t buffered_size; uint8_t* dtmp = (uint8_t*) malloc(RD_BUF_SIZE); for(;;) { //Waiting for UART event. if(xQueueReceive(uart0_queue, (void * )&event, (portTickType)portMAX_DELAY)) { bzero(dtmp, RD_BUF_SIZE); ESP_LOGI(TAG, "uart[%d] event:", EX_UART_NUM); switch(event.type) { //Event of UART receiving data /*We'd better handler data event fast, there would be much more data events than other types of events. If we take too much time on data event, the queue might be full.*/ case UART_DATA: ESP_LOGI(TAG, "[UART DATA]: %d", event.size); uart_read_bytes(EX_UART_NUM, dtmp, event.size, portMAX_DELAY); ESP_LOGI(TAG, "[DATA EVT]:"); #ifdef ECHO_BACK_ON // Echo Back to Uart2 uart_write_bytes(EX_UART_NUM, (const char*) dtmp, event.size); #endif // Send data to Serial Terminal Over Bluetooth BluetoothSerial_write((const uint8_t*)dtmp,event.size); break; //Event of HW FIFO overflow detected case UART_FIFO_OVF: ESP_LOGI(TAG, "hw fifo overflow"); // If fifo overflow happened, you should consider adding flow control for your application. // The ISR has already reset the rx FIFO, // As an example, we directly flush the rx buffer here in order to read more data. uart_flush_input(EX_UART_NUM); xQueueReset(uart0_queue); break; //Event of UART ring buffer full case UART_BUFFER_FULL: ESP_LOGI(TAG, "ring buffer full"); // If buffer full happened, you should consider encreasing your buffer size // As an example, we directly flush the rx buffer here in order to read more data. uart_flush_input(EX_UART_NUM); xQueueReset(uart0_queue); break; //Event of UART RX break detected case UART_BREAK: ESP_LOGI(TAG, "uart rx break"); break; //Event of UART parity check error case UART_PARITY_ERR: ESP_LOGI(TAG, "uart parity error"); break; //Event of UART frame error case UART_FRAME_ERR: ESP_LOGI(TAG, "uart frame error"); break; //UART_PATTERN_DET case UART_PATTERN_DET: uart_get_buffered_data_len(EX_UART_NUM, &buffered_size); int pos = uart_pattern_pop_pos(EX_UART_NUM); ESP_LOGI(TAG, "[UART PATTERN DETECTED] pos: %d, buffered size: %d", pos, buffered_size); if (pos == -1) { // There used to be a UART_PATTERN_DET event, but the pattern position queue is full so that it can not // record the position. We should set a larger queue size. // As an example, we directly flush the rx buffer here. uart_flush_input(EX_UART_NUM); } else { uart_read_bytes(EX_UART_NUM, dtmp, pos, 100 / portTICK_PERIOD_MS); uint8_t pat[PATTERN_CHR_NUM + 1]; memset(pat, 0, sizeof(pat)); uart_read_bytes(EX_UART_NUM, pat, PATTERN_CHR_NUM, 100 / portTICK_PERIOD_MS); ESP_LOGI(TAG, "read data: %s", dtmp); ESP_LOGI(TAG, "read pat : %s", pat); } break; //Others default: ESP_LOGI(TAG, "uart event type: %d", event.type); break; } } } free(dtmp); dtmp = NULL; vTaskDelete(NULL); } // add by nishi end static const esp_spp_mode_t esp_spp_mode = ESP_SPP_MODE_CB; static struct timeval time_new, time_old; static long data_num = 0; static const esp_spp_sec_t sec_mask = ESP_SPP_SEC_AUTHENTICATE; static const esp_spp_role_t role_slave = ESP_SPP_ROLE_SLAVE; static void print_speed(void) { float time_old_s = time_old.tv_sec + time_old.tv_usec / 1000000.0; float time_new_s = time_new.tv_sec + time_new.tv_usec / 1000000.0; float time_interval = time_new_s - time_old_s; float speed = data_num * 8 / time_interval / 1000.0; ESP_LOGI(SPP_TAG, "speed(%fs ~ %fs): %f kbit/s" , time_old_s, time_new_s, speed); data_num = 0; time_old.tv_sec = time_new.tv_sec; time_old.tv_usec = time_new.tv_usec; } /* * SPP Uart Event Call Back Routine */ static void esp_spp_cb(esp_spp_cb_event_t event, esp_spp_cb_param_t *param) { SPP_UART_DT_BUF* spp_uart_dt_bufp; switch (event) { case ESP_SPP_INIT_EVT: ESP_LOGI(SPP_TAG, "ESP_SPP_INIT_EVT"); esp_bt_dev_set_device_name(EXCAMPLE_DEVICE_NAME); esp_bt_gap_set_scan_mode(ESP_BT_SCAN_MODE_CONNECTABLE_DISCOVERABLE); esp_spp_start_srv(sec_mask,role_slave, 0, SPP_SERVER_NAME); break; case ESP_SPP_DISCOVERY_COMP_EVT: ESP_LOGI(SPP_TAG, "ESP_SPP_DISCOVERY_COMP_EVT"); break; case ESP_SPP_OPEN_EVT: ESP_LOGI(SPP_TAG, "ESP_SPP_OPEN_EVT"); break; case ESP_SPP_CLOSE_EVT: ESP_LOGI(SPP_TAG, "ESP_SPP_CLOSE_EVT"); _spp_client = 0; // add byy nishi break; case ESP_SPP_START_EVT: ESP_LOGI(SPP_TAG, "ESP_SPP_START_EVT"); break; case ESP_SPP_CL_INIT_EVT: ESP_LOGI(SPP_TAG, "ESP_SPP_CL_INIT_EVT"); break; case ESP_SPP_DATA_IND_EVT: // SPP Recived data Event ESP_LOGI(SPP_TAG, "ESP_SPP_DATA_IND_EVT len=%d handle=%d", param->data_ind.len, param->data_ind.handle); //esp_log_buffer_hex("",param->data_ind.data,param->data_ind.len); if (_spp_queue != NULL){ if (fixed_queue_length(spp_rdata_fxq) >= MY_QUEUE_SIZE_MAX) { ESP_LOGW(SPP_TAG,"SPP Recieve data over run"); //break; } if((spp_uart_dt_bufp = (SPP_UART_DT_BUF*)osi_malloc(param->data_ind.len+sizeof(SPP_UART_DT_BUF))) != NULL){ spp_uart_dt_bufp->len = param->data_ind.len; memcpy(spp_uart_dt_bufp->data, param->data_ind.data, param->data_ind.len); // data -> fixed_queue enque // もしかして、キューが一杯だったら、待たされるのか? fixed_queue_enqueue(spp_rdata_fxq, spp_uart_dt_bufp); // task -> event enque xQueueSend(_spp_queue, param->data_ind.data, (TickType_t)0); //for (int i = 0; i < param->data_ind.len; i++) // xQueueSend(_spp_queue, param->data_ind.data + i, (TickType_t)0); } else{ ESP_LOGE(SPP_TAG, "%s malloc ERROR",__func__); } } else { ESP_LOGE(SPP_TAG, "%s SerialQueueBT ERROR",__func__); } break; case ESP_SPP_CONG_EVT: ESP_LOGI(SPP_TAG, "ESP_SPP_CONG_EVT"); break; case ESP_SPP_WRITE_EVT: ESP_LOGI(SPP_TAG, "ESP_SPP_WRITE_EVT"); break; case ESP_SPP_SRV_OPEN_EVT: ESP_LOGI(SPP_TAG, "ESP_SPP_SRV_OPEN_EVT"); _spp_client = param->open.handle; // add b nishi gettimeofday(&time_old, NULL); break; default: break; } } void esp_bt_gap_cb(esp_bt_gap_cb_event_t event, esp_bt_gap_cb_param_t *param) { switch (event) { case ESP_BT_GAP_AUTH_CMPL_EVT:{ if (param->auth_cmpl.stat == ESP_BT_STATUS_SUCCESS) { ESP_LOGI(SPP_TAG, "authentication success: %s", param->auth_cmpl.device_name); esp_log_buffer_hex(SPP_TAG, param->auth_cmpl.bda, ESP_BD_ADDR_LEN); } else { ESP_LOGE(SPP_TAG, "authentication failed, status:%d", param->auth_cmpl.stat); } break; } case ESP_BT_GAP_PIN_REQ_EVT:{ ESP_LOGI(SPP_TAG, "ESP_BT_GAP_PIN_REQ_EVT min_16_digit:%d", param->pin_req.min_16_digit); if (param->pin_req.min_16_digit) { ESP_LOGI(SPP_TAG, "Input pin code: 0000 0000 0000 0000"); esp_bt_pin_code_t pin_code = {0}; esp_bt_gap_pin_reply(param->pin_req.bda, true, 16, pin_code); } else { ESP_LOGI(SPP_TAG, "Input pin code: 1234"); esp_bt_pin_code_t pin_code; pin_code[0] = '1'; pin_code[1] = '2'; pin_code[2] = '3'; pin_code[3] = '4'; esp_bt_gap_pin_reply(param->pin_req.bda, true, 4, pin_code); } break; } case ESP_BT_GAP_CFM_REQ_EVT: ESP_LOGI(SPP_TAG, "ESP_BT_GAP_CFM_REQ_EVT Please compare the numeric value: %d", param->cfm_req.num_val); esp_bt_gap_ssp_confirm_reply(param->cfm_req.bda, true); break; case ESP_BT_GAP_KEY_NOTIF_EVT: ESP_LOGI(SPP_TAG, "ESP_BT_GAP_KEY_NOTIF_EVT passkey:%d", param->key_notif.passkey); break; case ESP_BT_GAP_KEY_REQ_EVT: ESP_LOGI(SPP_TAG, "ESP_BT_GAP_KEY_REQ_EVT Please enter passkey!"); break; default: { ESP_LOGI(SPP_TAG, "event: %d", event); break; } } return; } /* * Uart put char */ size_t Uart_put(uint8_t c){ uint8_t buffer[1]; buffer[0] = c; return uart_write_bytes(EX_UART_NUM, (const char*) buffer, 1); } /* * SPP Uart put char */ size_t BluetoothSerial_put(uint8_t c){ if (!_spp_client){ return 0; } uint8_t buffer[1]; buffer[0] = c; esp_err_t err = esp_spp_write(_spp_client, 1, buffer); return (err == ESP_OK) ? 1 : 0; } /* * SPP Uart Write Data */ size_t BluetoothSerial_write(const uint8_t *src,size_t size){ if (!_spp_client){ return 0; } esp_err_t err = esp_spp_write(_spp_client, size, src); return (err == ESP_OK) ? 1 : 0; } /* * SPP Uart Recieve Task */ void spp_uart_task( void * pvParameters ){ uint8_t c; int rc; SPP_UART_DT_BUF* spp_uart_dt_bufp; for( ;; ){ // Task code goes here. if (xQueueReceive(_spp_queue, &c, portMAX_DELAY)){ //ESP_LOGI(SPP_TAG, "%s():#3 c=%x",__func__,c); while(1){ spp_uart_dt_bufp = (SPP_UART_DT_BUF *)fixed_queue_try_dequeue(spp_rdata_fxq); if ( spp_uart_dt_bufp == NULL ) { //ESP_LOGD(SPP_TAG,"%s():#6 Insufficient data in que ",__func__); break; } // DEBUG by nishi ESP_LOGI(SPP_TAG,"%s():#5 passed!",__func__); uart_write_bytes(EX_UART_NUM, (const char*)(spp_uart_dt_bufp->data),spp_uart_dt_bufp->len); #ifdef ECHO_BACK_ON // Echo Back to Serial Terminal Over Blutoth esp_spp_write(_spp_client, spp_uart_dt_bufp->len, spp_uart_dt_bufp->data); #endif osi_free(spp_uart_dt_bufp); } } } } /* * Bluetooth Classic GAP Profile SPP Uart Init */ static void spp_uart_init(void){ static uint8_t ucParameterToPass; //xTaskCreate(uart_task, "uTask", 2048, (void*)UART_NUM_0, 8, NULL); //xTaskCreate( vTaskCode, "NAME", STACK_SIZE, &ucParameterToPass, tskIDLE_PRIORITY, &xHandle ); xTaskCreate(spp_uart_task, "uTask", 2048, &ucParameterToPass, tskIDLE_PRIORITY, &spp_uart_task_dr_hdl ); configASSERT(spp_uart_task_dr_hdl); // fixed_queue allocate spp_rdata_fxq = fixed_queue_new(MY_QUEUE_SIZE_MAX); } /* * Uart2 Init */ static void uart_init(void){ /* Configure parameters of an UART driver, * communication pins and install the driver */ uart_config_t uart_config = { .baud_rate = 115200, .data_bits = UART_DATA_8_BITS, .parity = UART_PARITY_DISABLE, .stop_bits = UART_STOP_BITS_1, .flow_ctrl = UART_HW_FLOWCTRL_DISABLE }; uart_param_config(EX_UART_NUM, &uart_config); //Set UART pins (using UART0 default pins ie no changes.) //uart_set_pin(EX_UART_NUM, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE); uart_set_pin(EX_UART_NUM, ECHO_TEST_TXD, ECHO_TEST_RXD, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE); //Install UART driver, and get the queue. uart_driver_install(EX_UART_NUM, BUF_SIZE * 2, BUF_SIZE * 2, 20, &uart0_queue, 0); //Set uart pattern detect function. uart_enable_pattern_det_intr(EX_UART_NUM, '+', PATTERN_CHR_NUM, 10000, 10, 10); //Reset the pattern queue length to record at most 20 pattern positions. uart_pattern_queue_reset(EX_UART_NUM, 20); //Create a task to handler UART event from ISR xTaskCreate(uart_event_task, "uart_event_task", 2048, NULL, 12, &uart_event_task_dr_hdl); configASSERT(uart_event_task_dr_hdl); } void app_main() { esp_log_level_set(TAG, ESP_LOG_INFO); 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 ); ESP_ERROR_CHECK(esp_bt_controller_mem_release(ESP_BT_MODE_BLE)); esp_bt_controller_config_t bt_cfg = BT_CONTROLLER_INIT_CONFIG_DEFAULT(); if ((ret = esp_bt_controller_init(&bt_cfg)) != ESP_OK) { ESP_LOGE(SPP_TAG, "%s initialize controller failed: %s\n", __func__, esp_err_to_name(ret)); return; } if ((ret = esp_bt_controller_enable(ESP_BT_MODE_CLASSIC_BT)) != ESP_OK) { ESP_LOGE(SPP_TAG, "%s enable controller failed: %s\n", __func__, esp_err_to_name(ret)); return; } if ((ret = esp_bluedroid_init()) != ESP_OK) { ESP_LOGE(SPP_TAG, "%s initialize bluedroid failed: %s\n", __func__, esp_err_to_name(ret)); return; } if ((ret = esp_bluedroid_enable()) != ESP_OK) { ESP_LOGE(SPP_TAG, "%s enable bluedroid failed: %s\n", __func__, esp_err_to_name(ret)); return; } if ((ret = esp_bt_gap_register_callback(esp_bt_gap_cb)) != ESP_OK) { ESP_LOGE(SPP_TAG, "%s gap register failed: %s\n", __func__, esp_err_to_name(ret)); return; } if ((ret = esp_spp_register_callback(esp_spp_cb)) != ESP_OK) { ESP_LOGE(SPP_TAG, "%s spp register failed: %s\n", __func__, esp_err_to_name(ret)); return; } if ((ret = esp_spp_init(esp_spp_mode)) != ESP_OK) { ESP_LOGE(SPP_TAG, "%s spp init failed: %s\n", __func__, esp_err_to_name(ret)); return; } // add by nishi start _spp_queue = xQueueCreate(QUEUE_SIZE, sizeof(uint8_t)); //initialize the queue if (_spp_queue == NULL){ ESP_LOGE(SPP_TAG,"%s Queue creation error\n", __func__); return; } // add by nishi end /* Set default parameters for Secure Simple Pairing */ esp_bt_sp_param_t param_type = ESP_BT_SP_IOCAP_MODE; esp_bt_io_cap_t iocap = ESP_BT_IO_CAP_IO; esp_bt_gap_set_security_param(param_type, &iocap, sizeof(uint8_t)); /* * Set default parameters for Legacy Pairing * Use variable pin, input pin code when pairing */ esp_bt_pin_type_t pin_type = ESP_BT_PIN_TYPE_VARIABLE; esp_bt_pin_code_t pin_code; esp_bt_gap_set_pin(pin_type, 0, pin_code); // add by nishi spp_uart_init(); uart_init(); }

注) 現在、テキストファイルの転送ができるのは、 Bluetoooth Serial -> UART2 TTL-Serial
だけです。
逆の Bluetoooth Serial <- UART2 TTL-Serial の部分は、まだ組み込んでいません。
プログラムを追えば、簡単に追加できるので、ご自由にトライしてみとうせ。

一応、当初の目的の、 ESP32 esp-idf でSerial Over Bluetooth -> RS232C シリアル通信
コンバータが作れるのが判ったので、これでお終いにします。

その後の検証で判った事ですが、
UART の部分は、uart_echo を使った方が、uart_event を使うよりも簡単で、確実です。
uart_event は、UART2 TTL-Serial の方から、TeraTerm でファイル転送を試すと、"ring buffer full"、"hw fifo overflow" が生じてなんともなりません。

以上、オンちゃんからの後書きでした。

その後、ESP32 に RS232-TTLコンバータモジュール と、USB to RS232 アダプタ  を
繋げて、テストしてみました。

RS232-TTLコンバータモジュール は、 RX,TX のピンを間違えなければ、大丈夫でした。

実際に使った物は、こちら。
RS232-TTLコンバータモジュール
USB to RS232 アダプタ