21ic电子技术开发论坛 › 单片机与嵌入式系统 › 沁恒USB蓝牙MCU › 分享CH582的MultiCentral一主二从实现接收两蓝牙从机not ...
返回列表 发新帖我要提问本帖赏金: 20.00元(功能说明)

[蓝牙芯片] 分享CH582的MultiCentral一主二从实现接收两蓝牙从机noti

[复制链接]
 楼主| lilijin1995 发表于 2023-3-14 11:26 | 显示全部楼层 |阅读模式
<
ICE, Multi, TI, ce, central
本帖最后由 lilijin1995 于 2023-3-14 14:34 编辑

背景：
之前有使用过Multicentral还是之前的CH58x_BLE_LIB_V1.41版本，连接两个其他品牌蓝牙芯片FR8012HAQ从机，是可以直接接收到两个从机的notify的。现在两个从机都改成CH582了。然后连接之后，只收到了先连接的那个从机的noti，然后一看Multicentral，只实现了连接0的：如下图
8121364100a44a5e6b.png

一开始我也是想直接添加连接1的，但第一次添加的时候我应该是忘记调用了，然后才没有成功，我还特意找了WCH的FAE问了，是直接根据连接0的重写一遍就行。

软件说明：
添加连接1的处理之前，我们先来看看BLE Central是怎么启动的：
复制
  1. void Central_Init()
    

  2. {
    

  3.     centralTaskId = TMOS_ProcessEventRegister(Central_ProcessEvent);
    


  4. 

  5.     // Setup GAP
    

  6.     GAP_SetParamValue(TGAP_DISC_SCAN, DEFAULT_SCAN_DURATION);
    

  7.     GAP_SetParamValue(TGAP_CONN_EST_INT_MIN, DEFAULT_MIN_CONNECTION_INTERVAL);
    

  8.     GAP_SetParamValue(TGAP_CONN_EST_INT_MAX, DEFAULT_MAX_CONNECTION_INTERVAL);
    

  9.     GAP_SetParamValue(TGAP_CONN_EST_SUPERV_TIMEOUT, DEFAULT_CONNECTION_TIMEOUT);
    


  10. 

  11.     // Setup the GAP Bond Manager
    

  12.     {
    

  13.         uint32_t passkey = DEFAULT_PASSCODE;
    

  14.         uint8_t  pairMode = DEFAULT_PAIRING_MODE;
    

  15.         uint8_t  mitm = DEFAULT_MITM_MODE;
    

  16.         uint8_t  ioCap = DEFAULT_IO_CAPABILITIES;
    

  17.         uint8_t  bonding = DEFAULT_BONDING_MODE;
    


  18. 

  19.         GAPBondMgr_SetParameter(GAPBOND_CENT_DEFAULT_PASSCODE, sizeof(uint32_t), &passkey);
    

  20.         GAPBondMgr_SetParameter(GAPBOND_CENT_PAIRING_MODE, sizeof(uint8_t), &pairMode);
    

  21.         GAPBondMgr_SetParameter(GAPBOND_CENT_MITM_PROTECTION, sizeof(uint8_t), &mitm);
    

  22.         GAPBondMgr_SetParameter(GAPBOND_CENT_IO_CAPABILITIES, sizeof(uint8_t), &ioCap);
    

  23.         GAPBondMgr_SetParameter(GAPBOND_CENT_BONDING_ENABLED, sizeof(uint8_t), &bonding);
    

  24.     }
    


  25. 

  26.     // Init Connection Item
    

  27.     centralInitConnItem(centralTaskId, centralConnList);
    

  28.     // Initialize GATT Client
    

  29.     GATT_InitClient();
    

  30.     // Register to receive incoming ATT Indications/Notifications
    

  31.     GATT_RegisterForInd(centralTaskId);
    

  32.     // Setup a delayed profile startup
    

  33.     tmos_set_event(centralTaskId, START_DEVICE_EVT);
    

  34. }
wch的BLE协议实现好像都是基于TMOS的，在Central_Init这个我们看到最后一行代码这里tmos_set_event(centralTaskId, START_DEVICE_EVT)直接启动设备启动事件，我们直接看事件回调函数Central_ProcessEvent里面的START_DEVICE_EVT
复制
  1. uint16_t Central_ProcessEvent(uint8_t task_id, uint16_t events)
    

  2. {
    

  3.     if(events & SYS_EVENT_MSG)
    

  4.     {
    

  5.         uint8_t *pMsg;
    


  6. 

  7.         if((pMsg = tmos_msg_receive(centralTaskId)) != NULL)
    

  8.         {
    

  9.             central_ProcessTMOSMsg((tmos_event_hdr_t *)pMsg);
    

  10.             // Release the TMOS message
    

  11.             tmos_msg_deallocate(pMsg);
    

  12.         }
    

  13.         // return unprocessed events
    

  14.         return (events ^ SYS_EVENT_MSG);
    

  15.     }
    


  16. 

  17.     if(events & START_DEVICE_EVT)
    

  18.     {
    

  19.         // Start the Device
    

  20.         GAPRole_CentralStartDevice(centralTaskId, ¢ralBondCB, ¢ralRoleCB);
    

  21.         return (events ^ START_DEVICE_EVT);
    

  22.     }
    

  23. }
在GAPRole_CentralStartDevice(centralTaskId, ¢ralBondCB, ¢ralRoleCB)里面又实现了
绑定管理回调函数：
复制
  1. // Bond Manager Callbacks
    

  2. static gapBondCBs_t centralBondCB = {
    

  3.     centralPasscodeCB,
    

  4.     centralPairStateCB
    

  5. };
以及GAP角色回调函数
复制
  1. // GAP Role Callbacks
    

  2. static gapCentralRoleCB_t centralRoleCB = {
    

  3.     centralRssiCB,        // RSSI callback
    

  4.     centralEventCB,       // Event callback
    

  5.     centralHciMTUChangeCB // MTU change callback
    

  6. };
centralEventCB这个事件回调函数里面全是GAP连接相关的事件的处理，GAP连接相关的事件可以CH58xBLE_LIB.h里面找到
复制
  1. #define GAP_DEVICE_INIT_DONE_EVENT              0x00 //!< Sent when the Device Initialization is complete.  This event is sent as an tmos message defined as gapDeviceInitDoneEvent_t.
    

  2. #define GAP_DEVICE_DISCOVERY_EVENT              0x01 //!< Sent when the Device Discovery Process is complete. This event is sent as an tmos message defined as gapDevDiscEvent_t.
    

  3. #define GAP_ADV_DATA_UPDATE_DONE_EVENT          0x02 //!< Sent when the Advertising Data or SCAN_RSP Data has been updated. This event is sent as an tmos message defined as gapAdvDataUpdateEvent_t.
    

  4. #define GAP_MAKE_DISCOVERABLE_DONE_EVENT        0x03 //!< Sent when the Make Discoverable Request is complete. This event is sent as an tmos message defined as gapMakeDiscoverableRspEvent_t.
    

  5. #define GAP_END_DISCOVERABLE_DONE_EVENT         0x04 //!< Sent when the Advertising has ended. This event is sent as an tmos message defined as gapEndDiscoverableRspEvent_t.
    

  6. #define GAP_LINK_ESTABLISHED_EVENT              0x05 //!< Sent when the Establish Link Request is complete. This event is sent as an tmos message defined as gapEstLinkReqEvent_t.
    

  7. #define GAP_LINK_TERMINATED_EVENT               0x06 //!< Sent when a connection was terminated. This event is sent as an tmos message defined as gapTerminateLinkEvent_t.
    

  8. #define GAP_LINK_PARAM_UPDATE_EVENT             0x07 //!< Sent when an Update Parameters Event is received. This event is sent as an tmos message defined as gapLinkUpdateEvent_t.
我们在GAP_DEVICE_INFO_EVENT里面过滤一下"Simple Peripheral"广播的peripheral如下代码：
复制
  1.         case GAP_DEVICE_INFO_EVENT:
    

  2.         {
    

  3.             // Add device to list
    

  4.             if(strstr(pEvent->deviceInfo.pEvtData,"Simple Peripheral")!=NULL)
    

  5.             {
    

  6.                 PRINT("%s\r\n",pEvent->deviceInfo.pEvtData);
    

  7.                 centralAddDeviceInfo(pEvent->deviceInfo.addr, pEvent->deviceInfo.addrType);
    


  8. 

  9.             }
    

  10. //            // Add device to list
    

  11. //            centralAddDeviceInfo(pEvent->deviceInfo.addr, pEvent->deviceInfo.addrType);
    

  12.         }
这样MultiCentral就只添加Simple Peripheral了。
接着修改对端设备地址，根据MAC连接的，并且我们只需要2个外设设备，所以这里修改一下对端设备地址和连接数：
复制
  1. #ifndef CENTRAL_MAX_CONNECTION
    

  2. #define CENTRAL_MAX_CONNECTION              2
    

  3. #endif
    

  4. // Peer device address
    

  5. static peerAddrDefItem_t PeerAddrDef[CENTRAL_MAX_CONNECTION] = {
    

  6.     {0x3d, 0x61, 0x85, 0x26, 0x3b, 0x38 },
    

  7.     {0x34, 0x53, 0x24, 0x7b, 0x54, 0x50 }
    

  8. };

GAP_LINK_ESTABLISHED_EVENT是建立连接的事件，在这里wch已经实现了连接0的了，如下：
复制
  1.                     //  连接0
    

  2.                     if(connItem == CONNECT0_ITEM)
    

  3.                     {
    

  4.                         centralConnList[connItem].procedureInProgress = TRUE;
    


  5. 

  6.                         // Initiate service discovery
    

  7.                         tmos_start_task(centralConnList[connItem].taskID, START_SVC_DISCOVERY_EVT, DEFAULT_SVC_DISCOVERY_DELAY);
    


  8. 

  9.                         // Initiate connect parameter update
    

  10.                         tmos_start_task(centralConnList[connItem].taskID, START_PARAM_UPDATE_EVT, DEFAULT_PARAM_UPDATE_DELAY);
    


  11. 

  12.                         // Start RSSI polling
    

  13.                         tmos_start_task(centralConnList[connItem].taskID, START_READ_RSSI_EVT, DEFAULT_RSSI_PERIOD);
    

  14.                     }
这里直接复制连接0的即可：
复制
  1.                     //  连接1
    

  2.                     else if(connItem == CONNECT1_ITEM)
    

  3.                     {
    

  4.                         centralConnList[connItem].procedureInProgress = TRUE;
    


  5. 

  6.                         // Initiate service discovery
    

  7.                         tmos_start_task(centralConnList[connItem].taskID, START_SVC_DISCOVERY_EVT, DEFAULT_SVC_DISCOVERY_DELAY);
    


  8. 

  9.                         // Initiate connect parameter update
    

  10.                         tmos_start_task(centralConnList[connItem].taskID, START_PARAM_UPDATE_EVT, DEFAULT_PARAM_UPDATE_DELAY);
    


  11. 

  12.                         // Start RSSI polling
    

  13.                         tmos_start_task(centralConnList[connItem].taskID, START_READ_RSSI_EVT, DEFAULT_RSSI_PERIOD);
    

  14.                     }
我们可以看到，这里启动了发现服务，参数更新，RSSI任务，那我们对应的也需要修改一下。连接0的是connect0_ProcessEvent处理的，那么我们直接复制修改如下：
复制
  1. static uint16_t connect1_ProcessEvent(uint8_t task_id, uint16_t events)
    

  2. {
    

  3.     if(events & START_SVC_DISCOVERY_EVT)
    

  4.     {
    

  5.         // start service discovery
    

  6.         centralConnIistStartDiscovery_1();
    

  7.         return (events ^ START_SVC_DISCOVERY_EVT);
    

  8.     }
    


  9. 

  10.     if(events & START_READ_OR_WRITE_EVT)
    

  11.     {
    

  12.         if(centralConnList[CONNECT1_ITEM].procedureInProgress == FALSE)
    

  13.         {
    

  14.             if(centralDoWrite)
    

  15.             {
    

  16.                 // Do a write
    

  17.                 attWriteReq_t req;
    


  18. 

  19.                 req.cmd = FALSE;
    

  20.                 req.sig = FALSE;
    

  21.                 req.handle = centralConnList[CONNECT1_ITEM].charHdl;
    

  22.                 req.len = 1;
    

  23.                 req.pValue = GATT_bm_alloc(centralConnList[CONNECT1_ITEM].connHandle, ATT_WRITE_REQ, req.len, NULL, 0);
    

  24.                 if(req.pValue != NULL)
    

  25.                 {
    

  26.                     *req.pValue = centralCharVal;
    


  27. 

  28.                     if(GATT_WriteCharValue(centralConnList[CONNECT1_ITEM].connHandle, &req, centralTaskId) == SUCCESS)
    

  29.                     {
    

  30.                         centralConnList[CONNECT1_ITEM].procedureInProgress = TRUE;
    

  31.                         centralDoWrite = !centralDoWrite;
    

  32.                         tmos_start_task(centralConnList[CONNECT1_ITEM].taskID, START_READ_OR_WRITE_EVT, DEFAULT_READ_OR_WRITE_DELAY);
    

  33.                     }
    

  34.                     else
    

  35.                     {
    

  36.                         GATT_bm_free((gattMsg_t *)&req, ATT_WRITE_REQ);
    

  37.                     }
    

  38.                 }
    

  39.             }
    

  40.             else
    

  41.             {
    

  42.                 // Do a read
    

  43.                 attReadReq_t req;
    


  44. 

  45.                 req.handle = centralConnList[CONNECT1_ITEM].charHdl;
    

  46.                 if(GATT_ReadCharValue(centralConnList[CONNECT1_ITEM].connHandle, &req, centralTaskId) == SUCCESS)
    

  47.                 {
    

  48.                     centralConnList[CONNECT1_ITEM].procedureInProgress = TRUE;
    

  49.                     centralDoWrite = !centralDoWrite;
    

  50.                 }
    

  51.             }
    

  52.         }
    

  53.         return (events ^ START_READ_OR_WRITE_EVT);
    

  54.     }
    


  55. 

  56.     if(events & START_PARAM_UPDATE_EVT)
    

  57.     {
    

  58.         // start connect parameter update
    

  59.         GAPRole_UpdateLink(centralConnList[CONNECT1_ITEM].connHandle,
    

  60.                            DEFAULT_UPDATE_MIN_CONN_INTERVAL,
    

  61.                            DEFAULT_UPDATE_MAX_CONN_INTERVAL,
    

  62.                            DEFAULT_UPDATE_SLAVE_LATENCY,
    

  63.                            DEFAULT_UPDATE_CONN_TIMEOUT);
    


  64. 

  65.         return (events ^ START_PARAM_UPDATE_EVT);
    

  66.     }
    


  67. 

  68.     if(events & START_WRITE_CCCD_EVT)
    

  69.     {
    

  70.         if(centralConnList[CONNECT1_ITEM].procedureInProgress == FALSE)
    

  71.         {
    

  72.             // Do a write
    

  73.             attWriteReq_t req;
    


  74. 

  75.             req.cmd = FALSE;
    

  76.             req.sig = FALSE;
    

  77.             req.handle = centralConnList[CONNECT1_ITEM].cccHdl;
    

  78.             req.len = 2;
    

  79.             req.pValue = GATT_bm_alloc(centralConnList[CONNECT1_ITEM].connHandle, ATT_WRITE_REQ, req.len, NULL, 0);
    

  80.             if(req.pValue != NULL)
    

  81.             {
    

  82.                 req.pValue[0] = 1;
    

  83.                 req.pValue[1] = 0;
    


  84. 

  85.                 if(GATT_WriteCharValue(centralConnList[CONNECT1_ITEM].connHandle, &req, centralTaskId) == SUCCESS)
    

  86.                 {
    

  87.                     centralConnList[CONNECT1_ITEM].procedureInProgress = TRUE;
    

  88.                 }
    

  89.                 else
    

  90.                 {
    

  91.                     GATT_bm_free((gattMsg_t *)&req, ATT_WRITE_REQ);
    

  92.                 }
    

  93.             }
    

  94.         }
    

  95.         return (events ^ START_WRITE_CCCD_EVT);
    

  96.     }
    


  97. 

  98.     if(events & START_READ_RSSI_EVT)
    

  99.     {
    

  100.         GAPRole_ReadRssiCmd(centralConnList[CONNECT1_ITEM].connHandle);
    

  101.         tmos_start_task(centralConnList[CONNECT1_ITEM].taskID, START_READ_RSSI_EVT, DEFAULT_RSSI_PERIOD);
    

  102.         return (events ^ START_READ_RSSI_EVT);
    

  103.     }
    

  104.     // Discard unknown events
    

  105.     return 0;
    

  106. }
把CONNECT0_ITEM改成CONNECT1_ITEM，编译一下会发现centralConnIistStartDiscovery_1还没实现，这里也是复制粘贴修改
复制
  1. static void centralConnIistStartDiscovery_1(void)
    

  2. {
    

  3.     uint8_t uuid[ATT_BT_UUID_SIZE] = {LO_UINT16(SIMPLEPROFILE_SERV_UUID),
    

  4.                                       HI_UINT16(SIMPLEPROFILE_SERV_UUID)};
    


  5. 

  6.     // Initialize cached handles
    

  7.     centralConnList[CONNECT1_ITEM].svcStartHdl = centralConnList[CONNECT1_ITEM].svcEndHdl = centralConnList[CONNECT1_ITEM].charHdl = 0;
    


  8. 

  9.     centralConnList[CONNECT1_ITEM].discState = BLE_DISC_STATE_SVC;
    


  10. 

  11.     // Discovery simple BLE service
    

  12.     GATT_DiscPrimaryServiceByUUID(centralConnList[CONNECT1_ITEM].connHandle,
    

  13.                                   uuid,
    

  14.                                   ATT_BT_UUID_SIZE,
    

  15.                                   centralTaskId);
    

  16. }
然后回到，Central_ProcessEvent添加调用
复制
  1.     // 连接1的任务处理
    

  2.     else if(task_id == centralConnList[CONNECT1_ITEM].taskID)
    

  3.     {
    

  4.         return connect1_ProcessEvent(task_id, events);
    

  5.     }

如果直接编译下载的话，估计跟我第一次修改实现的一样，还是只能接收先连接的，只有一个外设的noti，
因为我还差了一步：
复制
  1. /*********************************************************************
    

  2.  * @fn      centralGATTDiscoveryEvent
    

  3.  *
    

  4.  * [url=home.php?mod=space&uid=247401]@brief[/url]   Process GATT discovery event
    

  5.  *
    

  6.  * [url=home.php?mod=space&uid=266161]@return[/url]  none
    

  7.  */
    

  8. static void centralGATTDiscoveryEvent(uint8_t connItem, gattMsgEvent_t *pMsg)
    

  9. {
    

  10.     attReadByTypeReq_t req;
    

  11.     //  连接0的枚举
    

  12.     if(connItem == CONNECT0_ITEM)
    

  13.     {
    

  14.         if(centralConnList[connItem].discState == BLE_DISC_STATE_SVC)
    

  15.         {
    

  16.             // Service found, store handles
    

  17.             if(pMsg->method == ATT_FIND_BY_TYPE_VALUE_RSP &&
    

  18.                pMsg->msg.findByTypeValueRsp.numInfo > 0)
    

  19.             {
    

  20.                 centralConnList[connItem].svcStartHdl = ATT_ATTR_HANDLE(pMsg->msg.findByTypeValueRsp.pHandlesInfo, 0);
    

  21.                 centralConnList[connItem].svcEndHdl = ATT_GRP_END_HANDLE(pMsg->msg.findByTypeValueRsp.pHandlesInfo, 0);
    


  22. 

  23.                 // Display Profile Service handle range
    

  24.                 PRINT("Found Profile Service handle : %x ~ %x \n", centralConnList[connItem].svcStartHdl, centralConnList[connItem].svcEndHdl);
    

  25.             }
    

  26.             // If procedure complete
    

  27.             if((pMsg->method == ATT_FIND_BY_TYPE_VALUE_RSP &&
    

  28.                 pMsg->hdr.status == bleProcedureComplete) ||
    

  29.                (pMsg->method == ATT_ERROR_RSP))
    

  30.             {
    

  31.                 if(centralConnList[connItem].svcStartHdl != 0)
    

  32.                 {
    

  33.                     // Discover characteristic
    

  34.                     centralConnList[connItem].discState = BLE_DISC_STATE_CHAR;
    

  35.                     req.startHandle = centralConnList[connItem].svcStartHdl;
    

  36.                     req.endHandle = centralConnList[connItem].svcEndHdl;
    

  37.                     req.type.len = ATT_BT_UUID_SIZE;
    

  38.                     req.type.uuid[0] = LO_UINT16(SIMPLEPROFILE_CHAR1_UUID);
    

  39.                     req.type.uuid[1] = HI_UINT16(SIMPLEPROFILE_CHAR1_UUID);
    


  40. 

  41.                     GATT_ReadUsingCharUUID(centralConnList[connItem].connHandle, &req, centralTaskId);
    

  42.                 }
    

  43.             }
    

  44.         }
    

  45.         else if(centralConnList[connItem].discState == BLE_DISC_STATE_CHAR)
    

  46.         {
    

  47.             // Characteristic found, store handle
    

  48.             if(pMsg->method == ATT_READ_BY_TYPE_RSP &&
    

  49.                pMsg->msg.readByTypeRsp.numPairs > 0)
    

  50.             {
    

  51.                 centralConnList[connItem].charHdl = BUILD_UINT16(pMsg->msg.readByTypeRsp.pDataList[0],
    

  52.                                                                  pMsg->msg.readByTypeRsp.pDataList[1]);
    

  53.                 centralConnList[connItem].procedureInProgress = FALSE;
    


  54. 

  55.                 // Start do read or write
    

  56.                 tmos_start_task(centralConnList[connItem].taskID, START_READ_OR_WRITE_EVT, DEFAULT_READ_OR_WRITE_DELAY);
    


  57. 

  58.                 // Display Characteristic 1 handle
    

  59.                 PRINT("Found Characteristic 1 handle : %x \n", centralConnList[0].charHdl);
    

  60.             }
    


  61. 

  62.             if((pMsg->method == ATT_READ_BY_TYPE_RSP &&
    

  63.                 pMsg->hdr.status == bleProcedureComplete) ||
    

  64.                 (pMsg->method == ATT_ERROR_RSP))
    

  65.             {
    

  66.                 // Discover characteristic
    

  67.                 centralConnList[connItem].discState = BLE_DISC_STATE_CCCD;
    

  68.                 req.startHandle = centralConnList[connItem].svcStartHdl;
    

  69.                 req.endHandle = centralConnList[connItem].svcEndHdl;
    

  70.                 req.type.len = ATT_BT_UUID_SIZE;
    

  71.                 req.type.uuid[0] = LO_UINT16(GATT_CLIENT_CHAR_CFG_UUID);
    

  72.                 req.type.uuid[1] = HI_UINT16(GATT_CLIENT_CHAR_CFG_UUID);
    


  73. 

  74.                 GATT_ReadUsingCharUUID(centralConnList[connItem].connHandle, &req, centralTaskId);
    

  75.             }
    


  76. 

  77.         }
    

  78.         else if(centralConnList[connItem].discState == BLE_DISC_STATE_CCCD)
    

  79.         {
    

  80.             // Characteristic found, store handle
    

  81.             if(pMsg->method == ATT_READ_BY_TYPE_RSP &&
    

  82.             pMsg->msg.readByTypeRsp.numPairs > 0)
    

  83.             {
    

  84.                 centralConnList[connItem].cccHdl = BUILD_UINT16(pMsg->msg.readByTypeRsp.pDataList[0],
    

  85.                                             pMsg->msg.readByTypeRsp.pDataList[1]);
    


  86. 

  87.                 centralConnList[connItem].procedureInProgress = FALSE;
    


  88. 

  89.                 // Start do write CCCD
    

  90.                 tmos_start_task(centralConnList[connItem].taskID, START_WRITE_CCCD_EVT, DEFAULT_WRITE_CCCD_DELAY);
    


  91. 

  92.                 // Display Characteristic 1 handle
    

  93.                 PRINT("Found client characteristic configuration handle : %x \n", centralConnList[connItem].cccHdl);
    

  94.             }
    

  95.             centralConnList[connItem].discState = BLE_DISC_STATE_IDLE;
    

  96.         }
    

  97.     }
    

  98.     //  连接1的枚举
    

  99.     else if(connItem == CONNECT1_ITEM)
    

  100.     {
    

  101.         if(centralConnList[connItem].discState == BLE_DISC_STATE_SVC)
    

  102.         {
    

  103.             // Service found, store handles
    

  104.             if(pMsg->method == ATT_FIND_BY_TYPE_VALUE_RSP &&
    

  105.                pMsg->msg.findByTypeValueRsp.numInfo > 0)
    

  106.             {
    

  107.                 centralConnList[connItem].svcStartHdl = ATT_ATTR_HANDLE(pMsg->msg.findByTypeValueRsp.pHandlesInfo, 0);
    

  108.                 centralConnList[connItem].svcEndHdl = ATT_GRP_END_HANDLE(pMsg->msg.findByTypeValueRsp.pHandlesInfo, 0);
    


  109. 

  110.                 // Display Profile Service handle range
    

  111.                 PRINT("Found Profile Service handle : %x ~ %x \n", centralConnList[connItem].svcStartHdl, centralConnList[connItem].svcEndHdl);
    

  112.             }
    

  113.             // If procedure complete
    

  114.             if((pMsg->method == ATT_FIND_BY_TYPE_VALUE_RSP &&
    

  115.                 pMsg->hdr.status == bleProcedureComplete) ||
    

  116.                (pMsg->method == ATT_ERROR_RSP))
    

  117.             {
    

  118.                 if(centralConnList[connItem].svcStartHdl != 0)
    

  119.                 {
    

  120.                     // Discover characteristic
    

  121.                     centralConnList[connItem].discState = BLE_DISC_STATE_CHAR;
    

  122.                     req.startHandle = centralConnList[connItem].svcStartHdl;
    

  123.                     req.endHandle = centralConnList[connItem].svcEndHdl;
    

  124.                     req.type.len = ATT_BT_UUID_SIZE;
    

  125.                     req.type.uuid[0] = LO_UINT16(SIMPLEPROFILE_CHAR1_UUID);
    

  126.                     req.type.uuid[1] = HI_UINT16(SIMPLEPROFILE_CHAR1_UUID);
    


  127. 

  128.                     GATT_ReadUsingCharUUID(centralConnList[connItem].connHandle, &req, centralTaskId);
    

  129.                 }
    

  130.             }
    

  131.         }
    

  132.         else if(centralConnList[connItem].discState == BLE_DISC_STATE_CHAR)
    

  133.         {
    

  134.             // Characteristic found, store handle
    

  135.             if(pMsg->method == ATT_READ_BY_TYPE_RSP &&
    

  136.                pMsg->msg.readByTypeRsp.numPairs > 0)
    

  137.             {
    

  138.                 centralConnList[connItem].charHdl = BUILD_UINT16(pMsg->msg.readByTypeRsp.pDataList[0],
    

  139.                                                                  pMsg->msg.readByTypeRsp.pDataList[1]);
    

  140.                 centralConnList[connItem].procedureInProgress = FALSE;
    


  141. 

  142.                 // Start do read or write
    

  143.                 tmos_start_task(centralConnList[connItem].taskID, START_READ_OR_WRITE_EVT, DEFAULT_READ_OR_WRITE_DELAY);
    


  144. 

  145.                 // Display Characteristic 1 handle
    

  146.                 PRINT("Found Characteristic 1 handle : %x \n", centralConnList[0].charHdl);
    

  147.             }
    


  148. 

  149.             if((pMsg->method == ATT_READ_BY_TYPE_RSP &&
    

  150.                 pMsg->hdr.status == bleProcedureComplete) ||
    

  151.                 (pMsg->method == ATT_ERROR_RSP))
    

  152.             {
    

  153.                 // Discover characteristic
    

  154.                 centralConnList[connItem].discState = BLE_DISC_STATE_CCCD;
    

  155.                 req.startHandle = centralConnList[connItem].svcStartHdl;
    

  156.                 req.endHandle = centralConnList[connItem].svcEndHdl;
    

  157.                 req.type.len = ATT_BT_UUID_SIZE;
    

  158.                 req.type.uuid[0] = LO_UINT16(GATT_CLIENT_CHAR_CFG_UUID);
    

  159.                 req.type.uuid[1] = HI_UINT16(GATT_CLIENT_CHAR_CFG_UUID);
    


  160. 

  161.                 GATT_ReadUsingCharUUID(centralConnList[connItem].connHandle, &req, centralTaskId);
    

  162.             }
    


  163. 

  164.         }
    

  165.         else if(centralConnList[connItem].discState == BLE_DISC_STATE_CCCD)
    

  166.         {
    

  167.             // Characteristic found, store handle
    

  168.             if(pMsg->method == ATT_READ_BY_TYPE_RSP &&
    

  169.             pMsg->msg.readByTypeRsp.numPairs > 0)
    

  170.             {
    

  171.                 centralConnList[connItem].cccHdl = BUILD_UINT16(pMsg->msg.readByTypeRsp.pDataList[0],
    

  172.                                             pMsg->msg.readByTypeRsp.pDataList[1]);
    


  173. 

  174.                 centralConnList[connItem].procedureInProgress = FALSE;
    


  175. 

  176.                 // Start do write CCCD
    

  177.                 tmos_start_task(centralConnList[connItem].taskID, START_WRITE_CCCD_EVT, DEFAULT_WRITE_CCCD_DELAY);
    


  178. 

  179.                 // Display Characteristic 1 handle
    

  180.                 PRINT("Found client characteristic configuration handle : %x \n", centralConnList[connItem].cccHdl);
    

  181.             }
    

  182.             centralConnList[connItem].discState = BLE_DISC_STATE_IDLE;
    

  183.         }
    

  184.     }
    

  185.     //  连接2的枚举
    

  186.     else if(connItem == CONNECT2_ITEM)
    

  187.     {
    

  188.     }
    

  189. }
要在这个函数里面实现连接1的枚举。

最后可以看到multicentrl是有接收两个设备的noti 563476410155b33597.png


回复 赏

举报

打赏榜单

21ic小管家 打赏了 20.00 元 2023-04-14

相关帖子
zhuotuzi 发表于 2023-3-19 17:37 | 显示全部楼层
学习了，受教了。
回复 赏

举报

tpgf 发表于 2023-4-10 10:22 | 显示全部楼层
TMOS是沁恒微电子针对蓝牙协议栈开发的“操作系统”,是简化版的OSAL
回复 赏

举报

qcliu 发表于 2023-4-10 11:14 | 显示全部楼层
要实现一个BLE应用，首先需要一个支持BLE射频的芯片，然后还需要提供一个与此芯片配套的BLE协议栈，最后在协议栈上开发自己的应用
回复 赏

举报

drer 发表于 2023-4-10 11:24 | 显示全部楼层
TMOS是通过时间片轮询的方式实现多任务调度运行，实际上每次只有一个任务运行
回复 赏

举报

coshi 发表于 2023-4-10 12:00 | 显示全部楼层
TMOS循环查询任务链表，根据任务ID确定优先级，越小越高
回复 赏

举报

kxsi 发表于 2023-4-10 12:18 | 显示全部楼层
如果使用了ble,建议不要在单个任务中执行超过连接间隔一半时长的任务，否则将影响蓝牙通讯
回复 赏

举报

wiba 发表于 2023-4-10 13:25 | 显示全部楼层
请注意 ，  TMOS禁止在中断中调用任务调度函数
回复 赏

举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

lilijin1995

56

主题

165

帖子

8

粉丝
快速回复 在线客服 返回列表 返回顶部