• 络达开发---自定义BLE服务（二）：功能实现

    络达开发--自定义BLE服务（一）

    一、目录和工程的配置

    本文讲解如何在该SDK中添加用户自居定义的BLE服务。该服务的源码可以存放在自己希望的位置，但为符合工程目录的合理性，建议放在工程所在的目录下面，假设我们的工程名称为: headset_ghp

    那么，笔者的BLE自定义服务源码存放的路径是：

    bta_sdk\mcu\project\ab1565_ab1568_evk\apps\headset_ghp\ble_ghp\

    笔者自定义的服务目录如下图所示，创建时参考了：bta_sdk\mcu\middleware\MTK\bt_air\src\ble_air目录下的服务：

    • 源码目录创建好后，需要把该源码加入到工程中：把目录中的module.mk添加到工程的Makefile中（路径：
    bta_sdk\mcu\project\ab1565_ab1568_evk\apps\headset_ghp\GCC\Makefile)；
    • 添加内容如下：
    1. #######################################################
    2.  
    3. # Main APP files
    4.  
    5. APP_PATH        := $(patsubst $(SDK_PATH)/%,%,$(abspath $(dir $(PWD))))
    6.  
    7. APP_PATH_SRC    := $(APP_PATH)/src
    8.  
    9.  
    10. include $(SOURCE_DIR)/$(APP_PATH_SRC)/apps/module.mk
    11.  
    12. include $(SOURCE_DIR)/$(APP_PATH)/ble_ghp/module.mk

    注意：添加的行需要在APP_PATH 定义的后面，否则会module.mk中所使用的变量APP_PATH会为空值导至找不到源码文件；

    • module.mk文件内容： 
      1. BT_GHP_PATH = $(SOURCE_DIR)/$(APP_PATH)/ble_ghp/src
      2.  
      3. C_FILES  += $(BT_GHP_PATH)/ble_ghp_service.c
      4. #################################################################################
      5. #include path
      6. #################################################################################
      7. CFLAGS  += -I$(SOURCE_DIR)/$(APP_PATH)/ble_ghp/inc
      8. CFLAGS  += -I$(SOURCE_DIR)/kernel/rtos/FreeRTOS/Source/include 
      9. CFLAGS  += -I$(SOURCE_DIR)/kernel/rtos/FreeRTOS/Source/portable/GCC/ARM_CM4F
      10. CFLAGS  += -I$(SOURCE_DIR)/driver/chip/inc
      11. CFLAGS  += -I$(SOURCE_DIR)/kernel/service/inc 
      12. CFLAGS  += -I$(SOURCE_DIR)/middleware/MTK/bt_callback_manager/inc
      13. CFLAGS  += -I$(SOURCE_DIR)/middleware/MTK/nvdm/inc
      14.  
      15. ifeq ($(MTK_AWS_MCE_ENABLE),y)
      16. ifeq ($(SUPPORT_ROLE_HANDOVER_SERVICE),y)
      17. CFLAGS  += -I$(SOURCE_DIR)/middleware/MTK/bluetooth_service/bt_role_handover_service/inc
      18. endif
      19. endif
      20.  
      21. ifeq ($(MTK_CUS_FEATURE_BLE_GHP_ENABLE),y)
      22. CFLAGS += -DMTK_CUS_FEATURE_BLE_GHP_ENABLE
      23. endif

      从上面可以看出，笔者使用了一个宏定义来开或关该服务：MTK_CUS_FEATURE_BLE_GHP_ENABLE

     二、服务的实现

    自定义的BLE服务需要使用128位的uuid，UUID的值用户可以自行定义；同时，服务中的属性可以支持不同的操作权限，如可读/可写/可订阅等，或者是需要鉴权后才可以操作属性，这些权限的定义在头文件:bt_gatt.h中均有定义，如

    BT_GATT_CHARC_PROP_READ/BT_GATT_CHARC_PROP_NOTIFY/BT_GATT_CHARC_PROP_WRITE

    最常使用的属性的操作有三个：读/写/订阅；这三个权限再实例化属性描述符时就需要进行声明，并且对读和写的操作，还需要有相应的回调函数或者是对值的描述符的定义。此处笔者采用了通过回调函数来支持读和写及订阅的操作。

    笔者的UUID的及各描述符的定义如下所示：

    //此处定义一个日志类型，这样在调试看日志的时候，就可以以此为过滤条件来仅显示该类型的日志；

    log_create_module(GHP, PRINT_LEVEL_INFO);
    #define ble_ghp_hex_dump(_message,...)   LOG_HEXDUMP_I(GHP, (_message), ##__VA_ARGS__)

    //下面是主服务的UUID及该服务下两个属性的UUID的定义，注意观察这些值，其中大部分的值都是一样的，仅有2个字节用来区分不同的属性，如粗体数值所示。

    1. #define GHP_SERVICE_UUID                \
    2.     {{0x45, 0x4C, 0x42, 0x61, 0x68, 0x6F, 0x72, 0x69, \
    3.       0x41, 0x03, 0xAB, 0x2D, 0x4D, 0x49, 0x19, 0x73}}
    4.  
    5. #define GHP_RX_CHAR_UUID                \
    6.     {{0x45, 0x4C, 0x42, 0x61, 0x68, 0x6F, 0x72, 0x69, \
    7.       0x41, 0x32, 0xAB, 0x2D, 0x52, 0x41, 0x19, 0x73}}
    8.  
    9. #define GHP_TX_CHAR_UUID                \
    10.     {{0x45, 0x4C, 0x42, 0x61, 0x68, 0x6F, 0x72, 0x69, \
    11.       0x41, 0x31, 0xAB, 0x2D, 0x52, 0x41, 0x19, 0x73}}
    12.  
    13.  
    14. 如下代码，还需要定义两个属性的句柄，在描述符实例化的时候需要使用。
    15.  
    16. const bt_uuid_t GHP_RX_CHAR_UUID128 = GHP_RX_CHAR_UUID;
    17. const bt_uuid_t GHP_TX_CHAR_UUID128 = GHP_TX_CHAR_UUID;
    1. //主服务对象的定义
    2. BT_GATTS_NEW_PRIMARY_SERVICE_128(ble_ghp_primary_service, GHP_SERVICE_UUID);
    3.  
    4. //第一个属性的定义，可以发现，该属性支持开放式的读+写+订阅，
    5. BT_GATTS_NEW_CHARC_128(ble_ghp_rx_char, BT_GATT_CHARC_PROP_WRITE_WITHOUT_RSP | 
    6.                                         BT_GATT_CHARC_PROP_WRITE | 
    7.                                         BT_GATT_CHARC_PROP_READ |
    8.                                         BT_GATT_CHARC_PROP_NOTIFY, GHP_RX_CHAR_VALUE_HANDLE, GHP_RX_CHAR_UUID);
    9.  
    10. //下面这个是对该属性的值对象的定义，定义了该值是可读和可写，这个需要和属性对象的定义对应起来，因为属性定义中支持读和写。并且还需需要添加一个回调函数，当客户端对该值进行读或写时，就会触发该回调函数，在该函数中来实现对应值的读和写操作。
    11. BT_GATTS_NEW_CHARC_VALUE_CALLBACK(ble_ghp_rx_char_value, GHP_RX_CHAR_UUID128, 
    12.                                     BT_GATTS_REC_PERM_WRITABLE |
    13.                                     BT_GATTS_REC_PERM_READABLE, ble_ghp_rx_char_callback);
    1. //下面这行是对该属性起了一个易读的名字，通常是个字符串，该实例中采用了定长字符串来显示，当然，也可以使用动态的方式，这个就需要使用宏：BT_GATTS_NEW_CHARC_USER_DESCRIPTION来实现，因为它支持回调函数，可以在回调函数中来动态更改该易读的名字。
    2. BT_GATTS_NEW_CHARC_USER_DESCRIPTION_STR16(ble_ghp_rx_desc, BT_GATTS_REC_PERM_READABLE, 3,"Rx");

    //因为该属性同时还支持订阅，因此还需要添加一个cccd描述符对象，用来给客户端提供订阅的接口。客户端点击订阅或取消都会触发该宏定义中的回调函数，其值决定了是否打开订阅功能（1=打开，0=取消订阅）。所以，该描述符需要支持读和写的权限。

    BT_GATTS_NEW_CLIENT_CHARC_CONFIG(ble_ghp_rx_client_config, BT_GATTS_REC_PERM_READABLE|BT_GATTS_REC_PERM_WRITABLE, ble_ghp_rx_char_cccd_callback);

    //下面是定义了第二个属性，其原更同第一个类似，这里不再重复解释。其中一个区别是该属性的值不支持写操作，且默认值为123；

    1. BT_GATTS_NEW_CHARC_128(ble_ghp_tx_char, BT_GATT_CHARC_PROP_NOTIFY, GHP_TX_CHAR_VALUE_HANDLE, GHP_TX_CHAR_UUID);
    2. BT_GATTS_NEW_CHARC_VALUE_UINT8(ble_ghp_tx_char_value, GHP_TX_CHAR_UUID128, BT_GATTS_REC_PERM_READABLE, 123);
    3. BT_GATTS_NEW_CHARC_USER_DESCRIPTION_STR16(ble_ghp_tx_desc, BT_GATTS_REC_PERM_READABLE, 3,"Tx");
    4. BT_GATTS_NEW_CLIENT_CHARC_CONFIG(ble_ghp_tx_client_config, BT_GATTS_REC_PERM_READABLE|BT_GATTS_REC_PERM_WRITABLE, ble_ghp_tx_char_cccd_callback);

    上面对各服务的属性的对象定义之后，还需要把这些对象有序的组织起来，如下代码所示，注意，这里顺序是有要求的：

    1. static const bt_gatts_service_rec_t *ble_ghp_service_rec[] = {
    2.     (const bt_gatts_service_rec_t*) &ble_ghp_primary_service, //starting_handle=0xA401
    3.  
    4.     (const bt_gatts_service_rec_t*) &ble_ghp_rx_char,         //0xA402
    5.     (const bt_gatts_service_rec_t*) &ble_ghp_rx_char_value,   //0xA403
    6.     (const bt_gatts_service_rec_t*) &ble_ghp_rx_desc,         //0xA404
    7.     (const bt_gatts_service_rec_t*) &ble_ghp_rx_client_config,//0xA405
    8.     
    9.     (const bt_gatts_service_rec_t*) &ble_ghp_tx_char,         //0xA406
    10.     (const bt_gatts_service_rec_t*) &ble_ghp_tx_char_value,   //0xA407
    11.     (const bt_gatts_service_rec_t*) &ble_ghp_tx_desc,         //0xA408
    12.     (const bt_gatts_service_rec_t*) &ble_ghp_tx_client_config,//ending_handle=0xA409
    13. };

    下面这个定义，用来声明该服务下面所有描述符对象的句柄的范围，值为uint16_t类型，如下代码中的值0xA401和0xA409；

    那么，这两个值的定义有什么要求呢？我们看上面的代码ble_ghp_service_rec[]的定义中的注释，可以发现其数据的长度刚好是starting_handle和ending_handle的差值的长度，且句柄的起始值从starting_handle开始。

    1. const bt_gatts_service_t ble_ghp_service = {
    2.     .starting_handle = 0xA401,
    3.     .ending_handle   = 0xA409,
    4.     .required_encryption_key_size = 0,
    5.     .records = ble_ghp_service_rec
    6. };

    那么另一个问题，为什么是0xA401开始？这个就和SDK中其它服务句柄的定义有关系了。我们可以查看如下路径中的文件：

    bta_sdk\mcu\project\ab1565_ab1568_evk\apps\headset_ref_design\src\bt_app_utility\gatt_service.c

    找到如下代码：

    1. /**< gatt server collects all service. */
    2. const bt_gatts_service_t *bt_if_clm_gatt_server[] = {
    3.     &bt_if_gap_service, /**< handle range: 0x0001 to 0x0009. */
    4.     &bt_if_gatt_service,/**< handle range: 0x0011 to 0x0015. */
    5. #ifdef MTK_BLE_SMTCN_ENABLE
    6.     &bt_if_dtp_service, //0x0014-0x0017
    7. #endif
    8.     /*&bt_if_dogp_service,*/ /**< handle range: 0x0020 to 0x0025. */
    9. #ifdef __BLE_BAS__
    10.     &ble_bas_service,/**< handle range: 0x0031 to 0x0034. */
    11. #endif
    12. #ifdef MTK_BLE_IAS
    13.     &ble_ias_service,/**< handle range: 0x0040 to 0x0042. */
    14. #endif
    15. #ifdef MTK_PORT_SERVICE_BT_ENABLE
    16.     &ble_air_service,/**< handle range: 0x0051 to 0x0056. */
    17. #endif
    18.     &ble_dis_service,/**< handle range: 0x0060 to 0x0072. */
    19. #ifdef MTK_AMA_ENABLE
    20.     &ble_ama_service,/**handle range: 0x00D0 to 0x00D5. */
    21. #endif
    22. #ifdef MTK_VA_XIAOWEI_ENABLE
    23.     &xiaowei_ble_service,
    24. #endif
    25. #ifdef MTK_VA_XIAOAI_ENABLE
    26.     &xiaoai_ble_service,            /**< handle range: 0x00F0 to 0x00F5. */
    27. #endif
    28. #ifdef __BT_FAST_PAIR_ENABLE__
    29.     &bt_fast_pair_service,/**< handle range: 0x0100 to 0x013F. */
    30. #endif
    31. #ifdef AIR_LE_AUDIO_ENABLE
    32.     &ble_ascs_service,   /**< handle range: 0x1103 to 0x110F. */
    33.     &ble_pacs_service,   /**< handle range: 0x1200 to 0x1212. */
    34.     &ble_vcs_service,    /**< handle range: 0x1301 to 0x1309. */
    35.     &ble_vocs_service_channel_1, /**< handle range: 0x2001 to 0x200C. */
    36. #ifdef AIR_LE_AUDIO_HEADSET_ENABLE
    37.     &ble_vocs_service_channel_2, /**< handle range: 0x3001 to 0x300C. */
    38. #endif
    39.     &ble_aics_service,   /**< handle range: 0x4001 to 0x4010. */
    40.     &ble_mics_service,   /**< handle range: 0x5001 to 0x5004. */
    41.     &ble_csis_service,   /**< handle range: 0x6001 to 0x600A. */
    42.     &ble_cas_service,    /**< handle range: 0x7001 to 0x7002. */
    43.     &ble_bass_service,   /**< handle range: 0xA201 to 0xA209. */
    44.     &ble_tmas_service,   /**< handle range: 0xA301 to 0xA303. */
    45. #endif
    46. #ifdef MTK_CUS_FEATURE_BLE_GHP_ENABLE 
    47.     &ble_ghp_service,    /**< handle range: 0xA401 to 0xA409. */
    48. #endif
    49.     NULL
    50. };

    从这段代码的注释中我们可以发现，每个Primary services都会占用若干个句柄的值，且大至是按顺序去使用0x0000~0xFFFF这段的值，因为SDK中已经使用到了0xA303，因此笔者继续从0xA401值开始定义。当然，你也可以从0xA304开始，只要不和系统中已经被占用的句柄的值有冲突就基本是没问题的，但还是建议按照顺序的规则来使用，这样不容易乱。

    再看属性值的读和写操作，回调函数如下所示：

    1. static uint32_t ble_ghp_rx_char_cccd_callback(const uint8_t rw, uint16_t handle, void *data, uint16_t size, uint16_t offset)
    2. {
    3.     uint16_t val=255;
    4.  
    5.     if(size == 2)  val = *(uint16_t*)data;
    6.     LOG_MSGID_I(GHP, "[BLE_GHP]ble_ghp_rx_char_cccd_callback,hd:%d, rw%d,size%d, offset%d,val%d\r\n", 5, handle, rw, size, offset, val);
    7.     if ((handle != BT_HANDLE_INVALID) && (handle == g_ghp_cntx.conn_handle)) {
    8.         /** record for each connection. */
    9.         if (rw == BT_GATTS_CALLBACK_WRITE) {
    10.             if (size != sizeof(uint16_t)) { //Size check
    11.                 return 0;
    12.             }
    13.             g_ghp_cntx.notify_enabled = (val&1)<<1;
    14.             LOG_MSGID_I(GHP, "[BLE_GHP]rx_data:%d \r\n", 1,  g_ghp_cntx.notify_enabled);
    15.         } else if (rw == BT_GATTS_CALLBACK_READ) {
    16.             if (size != 0) {
    17.                 uint16_t *buf = (uint16_t*) data;
    18.                 *buf = (uint16_t) g_ghp_cntx.notify_enabled;
    19.                 LOG_MSGID_I(GHP, "[BLE_GHP]read rx cccd value = %d\r\n", 1, *buf);
    20.                 return size;
    21.             }
    22.         }
    23.         return sizeof(uint16_t);
    24.     }
    25.     return 0;
    26. }

    其中参数rw即是用来区分对属性是读（BT_GATTS_CALLBACK_READ）还是写（BT_GATTS_CALLBACK_WRITE）。注意这里的size的值，在读的时候，若size的值为0,表示系统需要通过该函数的返回值来确认待读数据的长度，因此这时不能往data参数中写数据,仅当size值不为0时才可以向data中写数据。在对属性值读的时候，系统都会首先通过该回调函数来获取待读数据的长度，然后再来读有效的数据。

    其中参数offset用来表示向目标数据中写或读的偏移量，因为目标数据可以是一个很大的数据，无法采用普通的如byte,uint16,uint32这样的数据来表示，所以这时候就需要使用offset这个参数来实现对复合数据的读写。

    再来看CCCD的回调函数：

    1. static uint32_t ble_ghp_tx_char_cccd_callback(const uint8_t rw, uint16_t handle, void *data, uint16_t size, uint16_t offset)
    2. {
    3.     uint16_t val=255;
    4.  
    5.     if(size == 2)  val = *(uint16_t*)data;
    6.     LOG_MSGID_I(GHP, "[BLE_GHP]ble_ghp_tx_char_cccd_callback, hd:%d, rw%d,size%d,offset%d,val%d\r\n", 5, handle, rw, size,offset, val);
    7.     if ((handle != BT_HANDLE_INVALID) && (handle == g_ghp_cntx.conn_handle)) {
    8.         /** record for each connection. */
    9.         if (rw == BT_GATTS_CALLBACK_WRITE) {
    10.             if (size != sizeof(uint16_t)) { //Size check
    11.                 return 0;
    12.             }
    13.             g_ghp_cntx.notify_enabled = (val&1)<<0;
    14.             LOG_MSGID_I(GHP, "[BLE_GHP]rx_data:%d \r\n", 1,  g_ghp_cntx.notify_enabled);
    15.         } else if (rw == BT_GATTS_CALLBACK_READ) {
    16.             if (size != 0) {
    17.                 uint16_t *buf = (uint16_t*) data;
    18.                 *buf = (uint16_t) g_ghp_cntx.notify_enabled;
    19.                 LOG_MSGID_I(GHP, "[BLE_GHP]read tx cccd value = %d\r\n", 1, *buf);
    20.                 return size;
    21.             }
    22.         }
    23.         return sizeof(uint16_t);
    24.     }
    25.     return 0;
    26. }

    同属性值的读写的回调函数类似，这里操作的不是属性值，而是一个用户自己用来记录订阅是否开启的变量：g_ghp_cntx.notify_enabled;

    那么，对于订阅的功能，笔者采用了一个Timer来周期的通知客户端，Timer的回调函数如下所示，当然，也可以在工程中别的地方通过调用函数：

    ble_ghp_write_data来实现对客户端的数据通知。

    1. uint16_t lgTxVal=0;
    2. static void notify_timer_callback(TimerHandle_t expiredTimer)
    3. {
    4.     lgTxVal++;
    5.     LOG_MSGID_I(GHP,"[BLE_GHP]in timer callback function, tx:%d\r\n", 1, lgTxVal);
    6.     
    7.     ble_ghp_write_data(g_ghp_cntx.conn_handle, &lgTxVal, 2);
    8. }
    9.  
    10.  
    11. /**
    12.  * @brief Function for sending the Ghp service tx characteristic value.
    13.  *
    14.  * @param[in]   conn_handle                           connection handle.
    15.  *
    16.  * @return      ble_status_t                              0 means success.
    17.  */
    18. static bt_status_t ble_ghp_service_tx_send(bt_handle_t conn_handle, uint8_t *data, uint32_t length)
    19. {
    20.     bt_status_t status = BT_STATUS_FAIL;
    21.  
    22.     LOG_MSGID_I(GHP, "[BLE_GHP]ble_ghp_service_tx_send! hd:%d,len:%d \r\n", 2, conn_handle, length);
    23.     uint8_t *buf = NULL;
    24.     bt_gattc_charc_value_notification_indication_t *ghp_noti_rsp;
    25.     ble_ghp_cntx_t *buffer_t = ble_ghp_get_cntx_by_handle(conn_handle);
    26.  
    27.     buf = (uint8_t *)pvPortMalloc(5 + length);
    28.     if (buf == NULL) {
    29.         LOG_MSGID_I(GHP, "[BLE_GHP]ble_ghp_service_tx_send fail, OOM!\r\n", 0);  
    30.         return status;
    31.     }
    32.     ghp_noti_rsp = (bt_gattc_charc_value_notification_indication_t*) buf;
    33.     LOG_MSGID_I(GHP, "[BLE_GHP]ble_ghp_service_tx_send, new RX Char Value is %d\r\n", 1, data[0]);  
    34.  
    35.     if ((conn_handle != BT_HANDLE_INVALID) && (buffer_t) &&
    36.         (BLE_GHP_CCCD_NOTIFICATION ==  buffer_t->notify_enabled)) {
    37.         ghp_noti_rsp->att_req.opcode = BT_ATT_OPCODE_HANDLE_VALUE_NOTIFICATION;
    38.         ghp_noti_rsp->att_req.handle = GHP_TX_CHAR_VALUE_HANDLE;
    39.         memcpy((void*)(ghp_noti_rsp->att_req.attribute_value), data, length);
    40.         ghp_noti_rsp->attribute_value_length = 3 + length;
    41.         
    42.         LOG_MSGID_I(GHP, "[BLE_GHP]ble_ghp_service_notify conn_handle is %x, send data is %d\r\n", 2, conn_handle, data[0]);
    43.         
    44.         status = bt_gatts_send_charc_value_notification_indication(conn_handle, ghp_noti_rsp); 
    45.     }
    46.     if (buf != NULL) {
    47.         vPortFree(buf);
    48.     }
    49.     return status;
    50. }
    51.  
    52.  
    53.  
    54. /**
    55.  * @brief Function for application to write data to the send buffer.
    56.  */
    57. uint32_t ble_ghp_write_data(uint16_t conn_handle, uint8_t *buffer, uint32_t size)
    58. {
    59.     BLEGHP_MUTEX_LOCK();  
    60.     LOG_MSGID_I(GHP, "[BLE_GHP]ble_ghp_write_data incoming, hd:%d,size:%d\r\n", 2, conn_handle, size);
    61.     
    62.     uint32_t send_size = 0;
    63.     uint32_t mtu_size;
    64.     ble_ghp_cntx_t *buffer_t = ble_ghp_get_cntx_by_handle(conn_handle);
    65.  
    66.     if ((conn_handle != BT_HANDLE_INVALID) && (buffer_t) ) 
    67.     {
    68.         mtu_size = bt_gattc_get_mtu((bt_handle_t)conn_handle);
    69.  
    70.         LOG_MSGID_I(GHP, "[BLE_GHP]mtu = %d\r\n", 1, mtu_size);
    71.         if ((mtu_size - 3) < size) {
    72.             send_size = mtu_size - 3;
    73.         } else {
    74.             send_size = size;
    75.         }
    76.         if (0 == send_size) {
    77.             LOG_MSGID_I(GHP, "[BLE_GHP] ble_ghp_send_data send_size is 0!\r\n", 0);
    78.             BLEGHP_MUTEX_UNLOCK();
    79.             return 0;
    80.         }
    81.  
    82. #ifdef BLE_GHP_LOW_POWER_CONTROL
    83.         ble_ghp_set_remote_device_type(conn_handle, BLE_GHP_REMOTE_DEVICE_IOS);
    84.         ble_ghp_update_connection_interval(conn_handle);
    85. #endif   
    86.  
    87.         if (BT_STATUS_SUCCESS == ble_ghp_service_tx_send(conn_handle, buffer, send_size)) {
    88.             LOG_MSGID_I(GHP, "[BLE_GHP] ble_ghp_send_data: send_size[%d]\r\n", 1, send_size); 
    89.             BLEGHP_MUTEX_UNLOCK();  
    90.             return send_size;
    91.         }
    92.     }
    93.     BLEGHP_MUTEX_UNLOCK();
    94.     return 0;
    95. }

    其订阅测试如下图所示：

  • 相关阅读:
    八股——const 关键字
    Linux 命令行小技巧 – ！叹号的用处
    华为od德科面试数据算法解析 2022-8-29 24按身高和体重排队
    activiti-api
    java---IO流：字节流
    C/C++数据结构之深入了解线性表：顺序表、单链表、循环链表和双向链表
    WebGL前言——WebGL相关介绍
    从GPT-4到GPT-4o：人工智能的进化与革命
    【力扣-每日一题】714. 买卖股票的最佳时机含手续费
    Redis常见错误
  • 原文地址：https://blog.csdn.net/cczy_/article/details/126034301