arrow-firmware/main/bt_spp.c

/*
 * Project: Arrow
 * Author: 	curiousmuch
 */

#include <stdint.h>
#include <string.h>
#include <stdbool.h>
#include <stdio.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"

// TODO: Remove and add call back functions to tie to main
#include "kiss.c"


// Why are these global? Should I move this to a .h settings file?
#define DEVICE_NAME		"Arrow"
#define SPP_TAG			"BT SPP"
#define SPP_SERVER_NAME	"Arrow_TNC"

static const esp_spp_mode_t esp_spp_mode = ESP_SPP_MODE_CB;
static const esp_spp_sec_t sec_mask = ESP_SPP_SEC_AUTHENTICATE;//ESP_SPP_SEC_AUTHENTICATE;
static const esp_spp_role_t role_slave = ESP_SPP_ROLE_SLAVE;

typedef void (* receive_cb_t)(uint8_t *p, uint16_t p_len);

receive_cb_t receive_cb;

void esp_set_rx_cb(void (*rx_cb)(uint8_t *p, uint16_t p_len) )
{
	receive_cb = rx_cb;
}

uint32_t handle = 0;

// SPP Callback
static void esp_spp_cb(esp_spp_cb_event_t event, esp_spp_cb_param_t *param)
{
	switch(event) {
	case ESP_SPP_INIT_EVT:
		// called when SPP initialize
		ESP_LOGI(SPP_TAG, "ESP_SPP_INIT_ESP");
		esp_bt_dev_set_device_name(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:
		// called with SPP discovery is complete
		ESP_LOGI(SPP_TAG, "ESP_SPP_DISCOVERY_COMP_EVT");
		break;
	case ESP_SPP_OPEN_EVT:
		// called when SPP client connection opens
		ESP_LOGI(SPP_TAG, "ESP_SPP_OPEN_EVT");
		break;
	case ESP_SPP_CLOSE_EVT:
		// called when SPP client connection closes
		ESP_LOGI(SPP_TAG, "ESP_SPP_START_EVT");
		break;
	case ESP_SPP_CL_INIT_EVT:
		// called when SPP client initiated a connection
		ESP_LOGI(SPP_TAG, "ESP_SPP_CL_INIT_EVT handle=%d", param->open.handle);
		handle = param->open.handle;
		break;
	case ESP_SPP_DATA_IND_EVT:
		// called when SPP connection receives data
		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);
		kiss_receive(param->data_ind.data, param->data_ind.len);

		// [DEBUGING] echo received data
		// esp_spp_write(param->data_ind.handle, param->data_ind.len, param->data_ind.data);
		break;
	case ESP_SPP_CONG_EVT:
		// called when SPP connection congestion status changes
		ESP_LOGI(SPP_TAG, "ESP_SPP_CONG_EVT");
		break;
	case ESP_SPP_WRITE_EVT:
		// called when SPP write operation completes
		ESP_LOGI(SPP_TAG, "ESP_SPP_WRITE_EVT");
		// remove the need to write from the write queue
		break;
	case ESP_SPP_SRV_OPEN_EVT:
		// called when SPP server connection opens
		ESP_LOGI(SPP_TAG, "ESP_SPP_SRV_OPEN_EVT");
		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:{
		// called with authentication process complete
		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:{
		// called when legacy pairing pin code requested
		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:
		// called for simple pairing user confirmation
		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:
		// called during simple pairing passkey notification
		ESP_LOGI(SPP_TAG, "ESP_BT_GAP_KEY_NOTIF_EVT passkey:%d", param->key_notif.passkey);
		break;
	case ESP_BT_GAP_KEY_REQ_EVT:
		// called during simple pairing passkey request
		ESP_LOGI(SPP_TAG, "ESP_BT_GAP_KEY_REQ_EVT Please enter passkey!");
		break;
	default:
		ESP_LOGI(SPP_TAG, "event: %d", event);
		break;
	}
	return;
}


void bt_spp_tx(uint8_t *buf, uint32_t len)
{
	esp_spp_write(handle, len, buf);
}

void bt_spp_init(void)
{
    // Bluetooth Controller Initialization
    ESP_ERROR_CHECK(esp_bt_controller_mem_release(ESP_BT_MODE_BLE));

    esp_bt_controller_config_t bt_cfg = BT_CONTROLLER_INIT_CONFIG_DEFAULT();
    esp_err_t ret;
    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;
    }

    // Bluetooth Stack Initialization
    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;
    }

    // Set Bluetooth GAT Callback
    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;
    }

    // Set Bluetooth SPP Callback
    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;
    }

	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);
}