mirror of
https://github.com/0xFEEDC0DE64/arduino-esp32.git
synced 2025-07-02 21:41:01 +02:00
Update IDF to 3.2-3276a13 and esptool.py to 2.5.0 (#1878)
* TX Flow Control and Code cleanup * Use semaphore instead of delay TX functionality is done. * Use single buffer and empty queue on exit * Fix compile issues because of LwIP code relocation * Add temporary header to fix Azure not compiling * Fix AsyncUDP early init * AsyncUDP Multicast fixes * Add source mac address and rework multicast * Allow redefinition of default pins for Serials 1 and 2 * Update IDF to 3276a13 * Update esptool.py to 2.5.0 * Fix sketches * Fix log level in BluetoothSetial
This commit is contained in:
Me No Dev
GitHub
@ -40,11 +40,115 @@
|
||||
#include "esp32-hal-log.h"
|
||||
#endif
|
||||
|
||||
const char * _spp_server_name = "ESP32_SPP_SERVER";
|
||||
const char * _spp_server_name = "ESP32SPP";
|
||||
|
||||
#define QUEUE_SIZE 256
|
||||
#define RX_QUEUE_SIZE 512
|
||||
#define TX_QUEUE_SIZE 32
|
||||
static uint32_t _spp_client = 0;
|
||||
static xQueueHandle _spp_queue = NULL;
|
||||
static xQueueHandle _spp_rx_queue = NULL;
|
||||
static xQueueHandle _spp_tx_queue = NULL;
|
||||
static SemaphoreHandle_t _spp_tx_done = NULL;
|
||||
static TaskHandle_t _spp_task_handle = NULL;
|
||||
static EventGroupHandle_t _spp_event_group = NULL;
|
||||
|
||||
#define SPP_RUNNING 0x01
|
||||
#define SPP_CONNECTED 0x02
|
||||
#define SPP_CONGESTED 0x04
|
||||
|
||||
typedef struct {
|
||||
size_t len;
|
||||
uint8_t data[];
|
||||
} spp_packet_t;
|
||||
|
||||
static esp_err_t _spp_queue_packet(uint8_t *data, size_t len){
|
||||
if(!data || !len){
|
||||
log_w("No data provided");
|
||||
return ESP_OK;
|
||||
}
|
||||
spp_packet_t * packet = (spp_packet_t*)malloc(sizeof(spp_packet_t) + len);
|
||||
if(!packet){
|
||||
log_e("SPP TX Packet Malloc Failed!");
|
||||
return ESP_FAIL;
|
||||
}
|
||||
packet->len = len;
|
||||
memcpy(packet->data, data, len);
|
||||
if (xQueueSend(_spp_tx_queue, &packet, portMAX_DELAY) != pdPASS) {
|
||||
log_e("SPP TX Queue Send Failed!");
|
||||
free(packet);
|
||||
return ESP_FAIL;
|
||||
}
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
const uint16_t SPP_TX_MAX = 330;
|
||||
static uint8_t _spp_tx_buffer[SPP_TX_MAX];
|
||||
static uint16_t _spp_tx_buffer_len = 0;
|
||||
|
||||
static bool _spp_send_buffer(){
|
||||
if((xEventGroupWaitBits(_spp_event_group, SPP_CONGESTED, pdFALSE, pdTRUE, portMAX_DELAY) & SPP_CONGESTED)){
|
||||
esp_err_t err = esp_spp_write(_spp_client, _spp_tx_buffer_len, _spp_tx_buffer);
|
||||
if(err != ESP_OK){
|
||||
log_e("SPP Write Failed! [0x%X]", err);
|
||||
return false;
|
||||
}
|
||||
_spp_tx_buffer_len = 0;
|
||||
if(xSemaphoreTake(_spp_tx_done, portMAX_DELAY) != pdTRUE){
|
||||
log_e("SPP Ack Failed!");
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
static void _spp_tx_task(void * arg){
|
||||
spp_packet_t *packet = NULL;
|
||||
size_t len = 0, to_send = 0;
|
||||
uint8_t * data = NULL;
|
||||
for (;;) {
|
||||
if(_spp_tx_queue && xQueueReceive(_spp_tx_queue, &packet, portMAX_DELAY) == pdTRUE && packet){
|
||||
if(packet->len <= (SPP_TX_MAX - _spp_tx_buffer_len)){
|
||||
memcpy(_spp_tx_buffer+_spp_tx_buffer_len, packet->data, packet->len);
|
||||
_spp_tx_buffer_len+=packet->len;
|
||||
free(packet);
|
||||
packet = NULL;
|
||||
if(SPP_TX_MAX == _spp_tx_buffer_len || uxQueueMessagesWaiting(_spp_tx_queue) == 0){
|
||||
_spp_send_buffer();
|
||||
}
|
||||
} else {
|
||||
len = packet->len;
|
||||
data = packet->data;
|
||||
to_send = SPP_TX_MAX - _spp_tx_buffer_len;
|
||||
memcpy(_spp_tx_buffer+_spp_tx_buffer_len, data, to_send);
|
||||
_spp_tx_buffer_len = SPP_TX_MAX;
|
||||
data += to_send;
|
||||
len -= to_send;
|
||||
_spp_send_buffer();
|
||||
while(len >= SPP_TX_MAX){
|
||||
memcpy(_spp_tx_buffer, data, SPP_TX_MAX);
|
||||
_spp_tx_buffer_len = SPP_TX_MAX;
|
||||
data += SPP_TX_MAX;
|
||||
len -= SPP_TX_MAX;
|
||||
_spp_send_buffer();
|
||||
}
|
||||
if(len){
|
||||
memcpy(_spp_tx_buffer, data, len);
|
||||
_spp_tx_buffer_len += len;
|
||||
free(packet);
|
||||
packet = NULL;
|
||||
if(uxQueueMessagesWaiting(_spp_tx_queue) == 0){
|
||||
_spp_send_buffer();
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
log_e("Something went horribly wrong");
|
||||
}
|
||||
}
|
||||
vTaskDelete(NULL);
|
||||
_spp_task_handle = NULL;
|
||||
}
|
||||
|
||||
|
||||
static void esp_spp_cb(esp_spp_cb_event_t event, esp_spp_cb_param_t *param)
|
||||
{
|
||||
@ -54,44 +158,66 @@ static void esp_spp_cb(esp_spp_cb_event_t event, esp_spp_cb_param_t *param)
|
||||
log_i("ESP_SPP_INIT_EVT");
|
||||
esp_bt_gap_set_scan_mode(ESP_BT_SCAN_MODE_CONNECTABLE_DISCOVERABLE);
|
||||
esp_spp_start_srv(ESP_SPP_SEC_NONE, ESP_SPP_ROLE_SLAVE, 0, _spp_server_name);
|
||||
xEventGroupSetBits(_spp_event_group, SPP_RUNNING);
|
||||
break;
|
||||
|
||||
case ESP_SPP_SRV_OPEN_EVT://Server connection open
|
||||
_spp_client = param->open.handle;
|
||||
xEventGroupSetBits(_spp_event_group, SPP_CONNECTED);
|
||||
log_i("ESP_SPP_SRV_OPEN_EVT");
|
||||
break;
|
||||
|
||||
case ESP_SPP_CLOSE_EVT://Client connection closed
|
||||
_spp_client = 0;
|
||||
xEventGroupClearBits(_spp_event_group, SPP_CONNECTED);
|
||||
log_i("ESP_SPP_CLOSE_EVT");
|
||||
break;
|
||||
|
||||
case ESP_SPP_CONG_EVT://connection congestion status changed
|
||||
if(param->cong.cong){
|
||||
xEventGroupClearBits(_spp_event_group, SPP_CONGESTED);
|
||||
} else {
|
||||
xEventGroupSetBits(_spp_event_group, SPP_CONGESTED);
|
||||
}
|
||||
log_v("ESP_SPP_CONG_EVT: %s", param->cong.cong?"CONGESTED":"FREE");
|
||||
break;
|
||||
|
||||
case ESP_SPP_WRITE_EVT://write operation completed
|
||||
if(param->write.cong){
|
||||
xEventGroupClearBits(_spp_event_group, SPP_CONGESTED);
|
||||
}
|
||||
xSemaphoreGive(_spp_tx_done);//we can try to send another packet
|
||||
log_v("ESP_SPP_WRITE_EVT: %u %s", param->write.len, param->write.cong?"CONGESTED":"FREE");
|
||||
break;
|
||||
|
||||
case ESP_SPP_DATA_IND_EVT://connection received data
|
||||
log_v("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); //for low level debug
|
||||
//ets_printf("r:%u\n", param->data_ind.len);
|
||||
|
||||
if (_spp_rx_queue != NULL){
|
||||
for (int i = 0; i < param->data_ind.len; i++){
|
||||
if(xQueueSend(_spp_rx_queue, param->data_ind.data + i, (TickType_t)0) != pdTRUE){
|
||||
log_e("RX Full! Discarding %u bytes", param->data_ind.len - i);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
//should maybe delete those.
|
||||
case ESP_SPP_DISCOVERY_COMP_EVT://discovery complete
|
||||
log_i("ESP_SPP_DISCOVERY_COMP_EVT");
|
||||
break;
|
||||
case ESP_SPP_OPEN_EVT://Client connection open
|
||||
log_i("ESP_SPP_OPEN_EVT");
|
||||
break;
|
||||
case ESP_SPP_CLOSE_EVT://Client connection closed
|
||||
_spp_client = 0;
|
||||
log_i("ESP_SPP_CLOSE_EVT");
|
||||
break;
|
||||
case ESP_SPP_START_EVT://server started
|
||||
log_i("ESP_SPP_START_EVT");
|
||||
break;
|
||||
case ESP_SPP_CL_INIT_EVT://client initiated a connection
|
||||
log_i("ESP_SPP_CL_INIT_EVT");
|
||||
break;
|
||||
case ESP_SPP_DATA_IND_EVT://connection received data
|
||||
log_v("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); //for low level debug
|
||||
|
||||
if (_spp_queue != NULL){
|
||||
for (int i = 0; i < param->data_ind.len; i++)
|
||||
xQueueSend(_spp_queue, param->data_ind.data + i, (TickType_t)0);
|
||||
} else {
|
||||
log_e("SerialQueueBT ERROR");
|
||||
}
|
||||
break;
|
||||
case ESP_SPP_CONG_EVT://connection congestion status changed
|
||||
log_i("ESP_SPP_CONG_EVT");
|
||||
break;
|
||||
case ESP_SPP_WRITE_EVT://write operation completed
|
||||
log_v("ESP_SPP_WRITE_EVT");
|
||||
break;
|
||||
case ESP_SPP_SRV_OPEN_EVT://Server connection open
|
||||
_spp_client = param->open.handle;
|
||||
log_i("ESP_SPP_SRV_OPEN_EVT");
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
@ -99,41 +225,76 @@ static void esp_spp_cb(esp_spp_cb_event_t event, esp_spp_cb_param_t *param)
|
||||
|
||||
static bool _init_bt(const char *deviceName)
|
||||
{
|
||||
if(!_spp_event_group){
|
||||
_spp_event_group = xEventGroupCreate();
|
||||
if(!_spp_event_group){
|
||||
log_e("SPP Event Group Create Failed!");
|
||||
return false;
|
||||
}
|
||||
xEventGroupClearBits(_spp_event_group, 0xFFFFFF);
|
||||
xEventGroupSetBits(_spp_event_group, SPP_CONGESTED);
|
||||
}
|
||||
if (_spp_rx_queue == NULL){
|
||||
_spp_rx_queue = xQueueCreate(RX_QUEUE_SIZE, sizeof(uint8_t)); //initialize the queue
|
||||
if (_spp_rx_queue == NULL){
|
||||
log_e("RX Queue Create Failed");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
if (_spp_tx_queue == NULL){
|
||||
_spp_tx_queue = xQueueCreate(TX_QUEUE_SIZE, sizeof(spp_packet_t*)); //initialize the queue
|
||||
if (_spp_tx_queue == NULL){
|
||||
log_e("TX Queue Create Failed");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
if(_spp_tx_done == NULL){
|
||||
_spp_tx_done = xSemaphoreCreateBinary();
|
||||
if (_spp_tx_done == NULL){
|
||||
log_e("TX Semaphore Create Failed");
|
||||
return false;
|
||||
}
|
||||
xSemaphoreTake(_spp_tx_done, 0);
|
||||
}
|
||||
|
||||
if(!_spp_task_handle){
|
||||
xTaskCreate(_spp_tx_task, "spp_tx", 4096, NULL, 2, &_spp_task_handle);
|
||||
if(!_spp_task_handle){
|
||||
log_e("Network Event Task Start Failed!");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
if (!btStarted() && !btStart()){
|
||||
log_e("%s initialize controller failed\n", __func__);
|
||||
log_e("initialize controller failed");
|
||||
return false;
|
||||
}
|
||||
|
||||
esp_bluedroid_status_t bt_state = esp_bluedroid_get_status();
|
||||
if (bt_state == ESP_BLUEDROID_STATUS_UNINITIALIZED){
|
||||
if (esp_bluedroid_init()) {
|
||||
log_e("%s initialize bluedroid failed\n", __func__);
|
||||
log_e("initialize bluedroid failed");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
if (bt_state != ESP_BLUEDROID_STATUS_ENABLED){
|
||||
if (esp_bluedroid_enable()) {
|
||||
log_e("%s enable bluedroid failed\n", __func__);
|
||||
log_e("enable bluedroid failed");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
if (esp_spp_register_callback(esp_spp_cb) != ESP_OK){
|
||||
log_e("%s spp register failed\n", __func__);
|
||||
log_e("spp register failed");
|
||||
return false;
|
||||
}
|
||||
|
||||
if (esp_spp_init(ESP_SPP_MODE_CB) != ESP_OK){
|
||||
log_e("%s spp init failed\n", __func__);
|
||||
log_e("spp init failed");
|
||||
return false;
|
||||
}
|
||||
|
||||
_spp_queue = xQueueCreate(QUEUE_SIZE, sizeof(uint8_t)); //initialize the queue
|
||||
if (_spp_queue == NULL){
|
||||
log_e("%s Queue creation error\n", __func__);
|
||||
return false;
|
||||
}
|
||||
esp_bt_dev_set_device_name(deviceName);
|
||||
|
||||
// the default BTA_DM_COD_LOUDSPEAKER does not work with the macOS BT stack
|
||||
@ -142,7 +303,7 @@ static bool _init_bt(const char *deviceName)
|
||||
cod.minor = 0b000100;
|
||||
cod.service = 0b00000010110;
|
||||
if (esp_bt_gap_set_cod(cod, ESP_BT_INIT_COD) != ESP_OK) {
|
||||
log_e("%s set cod failed\n", __func__);
|
||||
log_e("set cod failed");
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -159,6 +320,32 @@ static bool _stop_bt()
|
||||
esp_bluedroid_deinit();
|
||||
btStop();
|
||||
}
|
||||
_spp_client = 0;
|
||||
if(_spp_task_handle){
|
||||
vTaskDelete(_spp_task_handle);
|
||||
_spp_task_handle = NULL;
|
||||
}
|
||||
if(_spp_event_group){
|
||||
vEventGroupDelete(_spp_event_group);
|
||||
_spp_event_group = NULL;
|
||||
}
|
||||
if(_spp_rx_queue){
|
||||
vQueueDelete(_spp_rx_queue);
|
||||
//ToDo: clear RX queue when in packet mode
|
||||
_spp_rx_queue = NULL;
|
||||
}
|
||||
if(_spp_tx_queue){
|
||||
spp_packet_t *packet = NULL;
|
||||
while(xQueueReceive(_spp_tx_queue, &packet, 0) == pdTRUE){
|
||||
free(packet);
|
||||
}
|
||||
vQueueDelete(_spp_tx_queue);
|
||||
_spp_tx_queue = NULL;
|
||||
}
|
||||
if (_spp_tx_done) {
|
||||
vSemaphoreDelete(_spp_tx_done);
|
||||
_spp_tx_done = NULL;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
@ -175,7 +362,6 @@ BluetoothSerial::BluetoothSerial()
|
||||
BluetoothSerial::~BluetoothSerial(void)
|
||||
{
|
||||
_stop_bt();
|
||||
vQueueDelete(_spp_queue);
|
||||
}
|
||||
|
||||
bool BluetoothSerial::begin(String localName)
|
||||
@ -188,60 +374,39 @@ bool BluetoothSerial::begin(String localName)
|
||||
|
||||
int BluetoothSerial::available(void)
|
||||
{
|
||||
if (!_spp_client || _spp_queue == NULL){
|
||||
if (_spp_rx_queue == NULL){
|
||||
return 0;
|
||||
}
|
||||
return uxQueueMessagesWaiting(_spp_queue);
|
||||
return uxQueueMessagesWaiting(_spp_rx_queue);
|
||||
}
|
||||
|
||||
int BluetoothSerial::peek(void)
|
||||
{
|
||||
if (available()){
|
||||
if (!_spp_client || _spp_queue == NULL){
|
||||
return 0;
|
||||
}
|
||||
|
||||
uint8_t c;
|
||||
if (xQueuePeek(_spp_queue, &c, 0)){
|
||||
return c;
|
||||
}
|
||||
uint8_t c;
|
||||
if (_spp_rx_queue && xQueuePeek(_spp_rx_queue, &c, 0)){
|
||||
return c;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
bool BluetoothSerial::hasClient(void)
|
||||
{
|
||||
if (_spp_client)
|
||||
return true;
|
||||
|
||||
return false;
|
||||
return _spp_client > 0;
|
||||
}
|
||||
|
||||
int BluetoothSerial::read(void)
|
||||
{
|
||||
if (available()){
|
||||
if (!_spp_client || _spp_queue == NULL){
|
||||
return 0;
|
||||
}
|
||||
|
||||
uint8_t c;
|
||||
if (xQueueReceive(_spp_queue, &c, 0)){
|
||||
return c;
|
||||
}
|
||||
uint8_t c = 0;
|
||||
if (_spp_rx_queue && xQueueReceive(_spp_rx_queue, &c, 0)){
|
||||
return c;
|
||||
}
|
||||
return 0;
|
||||
return -1;
|
||||
}
|
||||
|
||||
size_t BluetoothSerial::write(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;
|
||||
return write(&c, 1);
|
||||
}
|
||||
|
||||
size_t BluetoothSerial::write(const uint8_t *buffer, size_t size)
|
||||
@ -249,24 +414,17 @@ size_t BluetoothSerial::write(const uint8_t *buffer, size_t size)
|
||||
if (!_spp_client){
|
||||
return 0;
|
||||
}
|
||||
|
||||
esp_err_t err = esp_spp_write(_spp_client, size, (uint8_t *)buffer);
|
||||
return (err == ESP_OK) ? size : 0;
|
||||
return (_spp_queue_packet((uint8_t *)buffer, size) == ESP_OK) ? size : 0;
|
||||
}
|
||||
|
||||
void BluetoothSerial::flush()
|
||||
{
|
||||
if (_spp_client){
|
||||
int qsize = available();
|
||||
uint8_t buffer[qsize];
|
||||
esp_spp_write(_spp_client, qsize, buffer);
|
||||
}
|
||||
while(read() >= 0){}
|
||||
}
|
||||
|
||||
void BluetoothSerial::end()
|
||||
{
|
||||
_stop_bt();
|
||||
vQueueDelete(_spp_queue);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
Reference in New Issue
Block a user