(*callback_func)(rt_uint8_t cmd, rt_uint8_t *msg, uint8_t len)

(*callback_func)(rt_uint8_t cmd, rt_uint8_t *msg, uint8_t len)是一个函数指针，它指向一个函数，该函数有三个参数：一个无符号8位整数cmd，一个指向无符号8位整数数组的指针msg，以及一个无符号8位整数len。这个函数指针可以用来回调一个函数，以便在需要时执行特定的操作。

相关问题

void ApaService::onSettingAPAInfoInfChanged(const ADCU_HmiServiceCommonTypes::SettingAPAInfo &_data) { SettingAPAInfo msg; m_APASwitch = static_cast<ADCU_HmiServiceCommonTypes::OnOff::Literal>(_data.getAPASwitchSeN().value_); msg.set_apaswitchsen(_data.getAPASwitchSeN().value_); LOGD("AdcuService %s, APASwitchSeN = %d, ", __func__, msg.apaswitchsen()); APA_MSG apa_msg; apa_msg.mutable_m_adcusettingapainfo()->CopyFrom(msg); Notify(ADCU_EVENT_ID::APA_E_SETTINGINFOINF, apa_msg); if(apa_callback_handle || !(LOGI("apa_callback_handle is NULL!!!!!"))) { apa_callback_handle(m_APASwitch); } } int VehicleBusProxy::Notify( uint32_t nId, CVehicleBusMsg& _bus_msg ) { int result = 0; uint32_t key = nId; if( 0 == m_veh_bus_notify_list.count( key ) ) { result = -1; } else { m_veh_bus_notify_list[key]->RecvBusValue( _bus_msg ); } return result; }

这段代码展示了两个函数的实现。

第一个函数是`ApaService::onSettingAPAInfoInfChanged`，该函数接收一个类型为`ADCU_HmiServiceCommonTypes::SettingAPAInfo`的引用参数`_data`。

函数内部首先创建了一个名为`msg`的`SettingAPAInfo`对象，并通过使用`_data`对象的成员函数获取相关数据进行设置。

接着，代码使用`static_cast`将`_data.getAPASwitchSeN().value_`转换为`ADCU_HmiServiceCommonTypes::OnOff::Literal`类型，并将结果赋值给成员变量`m_APASwitch`。

然后，代码使用`msg.set_apaswitchsen()`将`_data.getAPASwitchSeN().value_`设置到`msg`对象中。

接下来，代码调用了一个名为`LOGD()`的函数，用于输出日志信息，其中包括了`msg.apaswitchsen()`的值。

然后，代码创建了一个名为`apa_msg`的`APA_MSG`对象，并通过调用`apa_msg.mutable_m_adcusettingapainfo()->CopyFrom(msg)`将`msg`对象复制到`apa_msg`对象中。

接着，代码调用了一个名为`Notify()`的函数，将消息ID和`apa_msg`对象作为参数传递给该函数。

最后，代码通过条件判断语句检查是否存在`apa_callback_handle`的回调函数，如果存在则调用该回调函数，并将`m_APASwitch`作为参数传递给它。

第二个函数是`VehicleBusProxy::Notify`，该函数接收一个类型为`uint32_t`的参数`nId`和一个类型为`CVehicleBusMsg`的引用参数`_bus_msg`。

函数内部首先声明了一个名为`result`的整型变量，并初始化为0。

然后，代码将`nId`赋值给一个名为`key`的变量。

接着，代码使用条件语句判断在名为`m_veh_bus_notify_list`的映射容器中是否存在键为`key`的元素。如果不存在，则将`result`赋值为-1，表示发送失败。

如果存在对应的键值对，则通过指针调用相应的接收者对象的`RecvBusValue`函数，并将`_bus_msg`作为参数传递给该函数。

最后，函数返回`result`，表示发送结果。如果`result`为-1，则表示发送失败，否则表示发送成功。

需要注意的是，这段代码中涉及到了一些特定的类和函数，例如`ADCU_HmiServiceCommonTypes::SettingAPAInfo`、`SettingAPAInfo`、`LOGD()`、`APA_MSG`、`mutable_m_adcusettingapainfo()`、`CopyFrom()`等。这些具体的实现细节可能需要查看更多的上下文信息才能提供更准确的解释。如果您有任何其他问题，请随时提问。

esp32 蓝牙启动流程_ESP32教你简单进行蓝牙串口调试

ESP32的蓝牙启动流程如下：

1. 初始化蓝牙协议栈

2. 配置蓝牙参数，如设备名称、服务UUID等

3. 注册蓝牙事件回调函数

4. 启动蓝牙广播

5. 开启蓝牙可见性

6. 等待连接

以下是一个简单的ESP32蓝牙串口调试的示例：

#include "esp_bt.h"
#include "esp_bt_main.h"
#include "esp_gap_ble_api.h"

#define GATTS_TAG "GATTS_DEMO"
#define TEST_DEVICE_NAME "ESP32_BLE_UART"
#define TEST_MANUFACTURER_DATA_LEN 17

/* The max length of characteristic value. When the gatt client write or prepare write,
*  the data length must be less than MAX_VALUE_LENGTH.
*/
#define MAX_VALUE_LENGTH 500

/* Declare global variable */
static uint8_t test_manufacturer[TEST_MANUFACTURER_DATA_LEN] = {0x4c, 0x00, 0x02, 0x15, 0xE2, 0x0A, 0x39, 0xF4, 0x73, 0xF5, 0x4B, 0xC4, 0xA1, 0x2F, 0x17, 0xD1, 0xAD};
static uint8_t test_service_uuid128[32] = {
    /* LSB <--------------------------------------------------------------------------------> MSB */
    //first uuid, 16bit, [12],[13] is the value
    0x13, 0x2B, 0x01, 0x00, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB,
    //second uuid, 32bit, [12], [13], [14], [15] is the value
    0x14, 0x2B, 0x01, 0x00, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB,
};

static uint8_t test_service_uuid[16] = {
    /* LSB <--------------------------------------------------------------------------------> MSB */
    //first uuid, 16bit, [12],[13] is the value
    0x01, 0x2B,
    //second uuid, 32bit, [12], [13], [14], [15] is the value
    0x01, 0x2B, 0x01, 0x00, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB,
};

static uint8_t test_char_uuid[16] = {
    /* LSB <--------------------------------------------------------------------------------> MSB */
    //first uuid, 16bit, [12],[13] is the value
    0x02, 0x2B,
    //second uuid, 32bit, [12], [13], [14], [15] is the value
    0x02, 0x2B, 0x01, 0x00, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB,
};

static esp_gatt_char_prop_t test_property = 0;

static uint8_t char1_str[] = {0x11,0x22,0x33};
static esp_attr_value_t gatts_demo_char1_val = {
    .attr_max_len = MAX_VALUE_LENGTH,
    .attr_len     = sizeof(char1_str),
    .attr_value   = char1_str,
};

static uint16_t gatts_demo_handle_table[3];

/* Full Database Description - Used to add attributes into the database */
static const esp_gatts_attr_db_t gatt_db[HRS_IDX_NB] =
{
    // Service Declaration
    [IDX_SVC]        =
    {
        {ESP_GATT_AUTO_RSP},
        {ESP_UUID_LEN_16, (uint8_t *)&primary_service_uuid, ESP_GATT_PERM_READ,
            sizeof(test_service_uuid), sizeof(test_service_uuid), (uint8_t *)&test_service_uuid},
        ESP_GATT_UUID_PRI_SERVICE,
        ESP_GATT_PERM_READ,
        sizeof(test_service_uuid),
        sizeof(test_service_uuid),
        (uint8_t *)&test_service_uuid,
        0
    },
    /* Characteristic Declaration */
    [IDX_CHAR_READ]  =
    {
        {ESP_GATT_AUTO_RSP},
        {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ,
            CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, (uint8_t *)&test_property},
        ESP_GATT_UUID_CHAR_DECLARE,
        ESP_GATT_PERM_READ,
        CHAR_DECLARATION_SIZE,
        CHAR_DECLARATION_SIZE,
        (uint8_t *)&test_property,
        0
    },
    /* Characteristic Value */
    [IDX_CHAR_VAL_READ] =
    {
        {ESP_GATT_AUTO_RSP},
        {ESP_UUID_LEN_128, (uint8_t *)&test_char_uuid, ESP_GATT_PERM_READ,
            MAX_VALUE_LENGTH, sizeof(gatts_demo_char1_val), gatts_demo_char1_val.attr_value},
        ESP_UUID_LEN_128,
        ESP_GATT_PERM_READ,
        MAX_VALUE_LENGTH,
        sizeof(gatts_demo_char1_val),
        gatts_demo_char1_val.attr_value,
        0
    },
};

static esp_ble_adv_data_t adv_data = {
    .set_scan_rsp        = false,
    .include_name        = true,
    .include_txpower     = true,
    .min_interval        = 0x20,
    .max_interval        = 0x40,
    .appearance          = 0x00,
    .manufacturer_len    = TEST_MANUFACTURER_DATA_LEN,
    .p_manufacturer_data = test_manufacturer,
    .service_data_len    = 0,
    .p_service_data      = NULL,
    .service_uuid_len    = sizeof(test_service_uuid),
    .p_service_uuid      = test_service_uuid,
    .flag = (ESP_BLE_ADV_FLAG_GEN_DISC | ESP_BLE_ADV_FLAG_BREDR_NOT_SPT),
};

static esp_ble_adv_params_t adv_params = {
    .adv_int_min         = 0x20,
    .adv_int_max         = 0x40,
    .adv_type            = ADV_TYPE_IND,
    .own_addr_type       = BLE_ADDR_TYPE_PUBLIC,
    .peer_addr           = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
    .peer_addr_type      = BLE_ADDR_TYPE_PUBLIC,
    .channel_map         = ADV_CHNL_ALL,
    .adv_filter_policy   = ADV_FILTER_ALLOW_SCAN_ANY_CON_ANY,
};

static void gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param)
{
    switch (event) {
    case ESP_GAP_BLE_ADV_DATA_SET_COMPLETE_EVT:
        esp_ble_gap_start_advertising(&adv_params);
        break;
    case ESP_GAP_BLE_ADV_START_COMPLETE_EVT:
        if (param->adv_start_cmpl.status != ESP_BT_STATUS_SUCCESS) {
            ESP_LOGE(GATTS_TAG, "advertising start failed");
        }
        break;
    default:
        break;
    }
}

static void gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_if, esp_ble_gatts_cb_param_t *param)
{
    switch (event) {
    case ESP_GATTS_REG_EVT:
        esp_ble_gap_set_device_name(TEST_DEVICE_NAME);
        esp_ble_gap_config_adv_data(&adv_data);
        break;
    case ESP_GATTS_CREAT_ATTR_TAB_EVT:
        if (param->add_attr_tab.status != ESP_GATT_OK){
            ESP_LOGE(GATTS_TAG, "create attribute table failed, error code=0x%x", param->add_attr_tab.status);
        }
        else if (param->add_attr_tab.num_handle != HRS_IDX_NB) {
            ESP_LOGE(GATTS_TAG, "create attribute table abnormally, num_handle (%d) \
                    doesn't equal to HRS_IDX_NB(%d)", param->add_attr_tab.num_handle, HRS_IDX_NB);
        }
        else {
            ESP_LOGI(GATTS_TAG, "create attribute table successfully, the number handle = %d\n",param->add_attr_tab.num_handle);
            memcpy(gatts_demo_handle_table, param->add_attr_tab.handles, sizeof(gatts_demo_handle_table));
            esp_ble_gatts_start_service(gatts_demo_handle_table[IDX_SVC]);
        }
        break;
    case ESP_GATTS_CONNECT_EVT:
        ESP_LOGI(GATTS_TAG, "ESP_GATTS_CONNECT_EVT");
        break;
    case ESP_GATTS_DISCONNECT_EVT:
        ESP_LOGI(GATTS_TAG, "ESP_GATTS_DISCONNECT_EVT");
        esp_ble_gap_start_advertising(&adv_params);
        break;
    case ESP_GATTS_WRITE_EVT:
        ESP_LOGI(GATTS_TAG, "ESP_GATTS_WRITE_EVT");
        break;
    case ESP_GATTS_MTU_EVT:
        ESP_LOGI(GATTS_TAG, "ESP_GATTS_MTU_EVT, MTU %d", param->mtu.mtu);
        break;
    case ESP_GATTS_CONF_EVT:
        ESP_LOGI(GATTS_TAG, "ESP_GATTS_CONF_EVT");
        break;
    case ESP_GATTS_EXEC_WRITE_EVT:
        ESP_LOGI(GATTS_TAG, "ESP_GATTS_EXEC_WRITE_EVT");
        break;
    case ESP_GATTS_START_EVT:
        ESP_LOGI(GATTS_TAG, "ESP_GATTS_START_EVT");
        break;
    case ESP_GATTS_STOP_EVT:
        ESP_LOGI(GATTS_TAG, "ESP_GATTS_STOP_EVT");
        break;
    case ESP_GATTS_OPEN_EVT:
        ESP_LOGI(GATTS_TAG, "ESP_GATTS_OPEN_EVT");
        break;
    case ESP_GATTS_CANCEL_OPEN_EVT:
        ESP_LOGI(GATTS_TAG, "ESP_GATTS_CANCEL_OPEN_EVT");
        break;
    case ESP_GATTS_CLOSE_EVT:
        ESP_LOGI(GATTS_TAG, "ESP_GATTS_CLOSE_EVT");
        break;
    case ESP_GATTS_LISTEN_EVT:
        ESP_LOGI(GATTS_TAG, "ESP_GATTS_LISTEN_EVT");
        break;
    case ESP_GATTS_CONGEST_EVT:
        ESP_LOGI(GATTS_TAG, "ESP_GATTS_CONGEST_EVT");
        break;
    case ESP_GATTS_UNREG_EVT:
    case ESP_GATTS_DELETE_EVT:
    default:
        break;
    }
}

void app_main()
{
    esp_err_t ret;

    ESP_LOGI(GATTS_TAG, "ESP_BLUETOOTH_BLE example started.");

    esp_bt_controller_config_t bt_cfg = BT_CONTROLLER_INIT_CONFIG_DEFAULT();
    ret = esp_bt_controller_init(&bt_cfg);
    if (ret) {
        ESP_LOGE(GATTS_TAG, "%s initialize controller failed\n", __func__);
        return;
    }

    ret = esp_bt_controller_enable(ESP_BT_MODE_BLE);
    if (ret) {
        ESP_LOGE(GATTS_TAG, "%s enable controller failed\n", __func__);
        return;
    }

    ret = esp_bluedroid_init();
    if (ret) {
        ESP_LOGE(GATTS_TAG, "%s init bluetooth failed\n", __func__);
        return;
    }

    ret = esp_bluedroid_enable();
    if (ret) {
        ESP_LOGE(GATTS_TAG, "%s enable bluetooth failed\n", __func__);
        return;
    }

    ret = esp_ble_gatts_register_callback(gatts_event_handler);
    if (ret){
        ESP_LOGE(GATTS_TAG, "gatts register error, error code = %x", ret);
        return;
    }

    ret = esp_ble_gap_register_callback(gap_event_handler);
    if (ret){
        ESP_LOGE(GATTS_TAG, "gap register error, error code = %x", ret);
        return;
    }

    ret = esp_ble_gatts_app_register(ESP_APP_ID);
    if (ret){
        ESP_LOGE(GATTS_TAG, "gatts app register error, error code = %x", ret);
        return;
    }

    esp_err_t local_mtu_ret = esp_ble_gatt_set_local_mtu(500);
    if (local_mtu_ret){
        ESP_LOGE(GATTS_TAG, "set local  MTU failed, error code = %x", local_mtu_ret);
    }

    ret = esp_ble_gatts_create_attr_tab(gatt_db, gatts_if, HRS_IDX_NB, ESP_APP_ID);
    if (ret){
        ESP_LOGE(GATTS_TAG, "create attr table failed, error code = %x", ret);
    }
}

在这个示例中，我们使用了ESP-IDF提供的蓝牙协议栈和GATT Server框架，实现了一个简单的GATT Server，并且开启了蓝牙广播和可见性，使得其他蓝牙设备可以扫描到并连接我们的设备。在连接建立后，我们可以向GATT Server中的特定Characteristic写入数据，也可以从特定Characteristic读取数据。