devbox
从前慢现在也慢
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

沁恒蓝牙芯片CH58X蓝牙主机的使用_ch582主从服务

作者：从前慢现在也慢 | 2024-08-05 16:32:51

赞

踩

ch582主从服务

        在做的项目本身只是需要用到蓝牙从机就行，从机项目开发已基本要收尾了。考虑到要配合产线系统做自动化测试，因此需要一个配合从机的主机dongle供自动化测试系统使用。

        蓝牙主机的使用只要按主机和从机的通信流程来走的话各家的蓝牙软件流程基本差不多，都是围绕主机扫描----主机连接-----（主从交换mtu等phy参数）-------主机遍历从机的service------主机遍历所需要service下的char记录下需要char的handle值以及同时找出支持notify的char handler-----对支持notify/indicate的char进行使能-----------对所需要的char进行read write

代码上的大体流程主要如下

1、主机角色初始化，扫描连接及启动遍历service

  1. GAPRole_CentralInit();  
  2. // Initialize GATT Client
  3. GATT_InitClient();
  4. //注册相关回调
  5. GAPRole_CentralStartDevice(centralTaskId, &centralBondCB, &centralRoleCB);
  6.  
  7.  
  8. 回调定义
  9. // GAP Role Callbacks
  10. static gapCentralRoleCB_t centralRoleCB = {
  11.     centralRssiCB,        // RSSI callback
  12.     centralEventCB,       // Event callback
  13.     centralHciMTUChangeCB // MTU change callback
  14. };
  15.  
  16.  
  17. 和蓝牙通信连接相关的主要回调，扫描 连接等状态的切换主要都在该回调里
  18. static void centralEventCB(gapRoleEvent_t *pEvent)
  19. {
  20.     switch(pEvent->gap.opcode)
  21.     {
  22.         case GAP_DEVICE_INIT_DONE_EVENT:
  23.         {
  24.             PRINT("Discovering...\n");
  25.             GAPRole_CentralStartDiscovery(DEFAULT_DISCOVERY_MODE,
  26.                                           DEFAULT_DISCOVERY_ACTIVE_SCAN,
  27.                                           DEFAULT_DISCOVERY_WHITE_LIST);
  28.         }
  29.         break;
  30.  
  31.         case GAP_DEVICE_INFO_EVENT:
  32.         {
  33.             // Add device to list
  34.             PRINT("Add device to list...\n");
  35.             centralAddDeviceInfo(pEvent->deviceInfo.addr, pEvent->deviceInfo.addrType);
  36.         }
  37.         break;
  38.  
  39.         case GAP_DEVICE_DISCOVERY_EVENT:
  40.         {
  41.             uint8_t i;
  42. 			PRINT("centralScanRes:%d...\r\n",centralScanRes);
  43.             // See if peer device has been discovered
  44.             for(i = 0; i < centralScanRes; i++)
  45.             {
  46.                 if(tmos_memcmp(PeerAddrDef, centralDevList[i].addr, B_ADDR_LEN))
  47.                     break;
  48.             }
  49.  
  50.             // Peer device not found
  51.             if(i == centralScanRes)
  52.             {
  53.                 PRINT("Device not found...\n");
  54.                 centralScanRes = 0;
  55.                 GAPRole_CentralStartDiscovery(DEFAULT_DISCOVERY_MODE,
  56.                                               DEFAULT_DISCOVERY_ACTIVE_SCAN,
  57.                                               DEFAULT_DISCOVERY_WHITE_LIST);
  58.                 PRINT("Discovering...\n");
  59.             }
  60.  
  61.             // Peer device found
  62.             else
  63.             {
  64.                 PRINT("Device found...\n");
  65.                 GAPRole_CentralEstablishLink(DEFAULT_LINK_HIGH_DUTY_CYCLE,
  66.                                              DEFAULT_LINK_WHITE_LIST,
  67.                                              centralDevList[i].addrType,
  68.                                              centralDevList[i].addr);
  69.  
  70.                 // Start establish link timeout event
  71.                 tmos_start_task(centralTaskId, ESTABLISH_LINK_TIMEOUT_EVT, ESTABLISH_LINK_TIMEOUT);
  72.                 PRINT("Connecting...\n");
  73.             }
  74.         }
  75.         break;
  76.  
  77.         case GAP_LINK_ESTABLISHED_EVENT:
  78.         {
  79. 			PRINT("GAP_LINK_ESTABLISHED_EVENT...\n");
  80.             tmos_stop_task(centralTaskId, ESTABLISH_LINK_TIMEOUT_EVT);
  81.             if(pEvent->gap.hdr.status == SUCCESS)
  82.             {
  83.                 centralState = BLE_STATE_CONNECTED;
  84.                 centralConnHandle = pEvent->linkCmpl.connectionHandle;
  85.                 centralProcedureInProgress = TRUE;
  86. 				
  87. 		central_gattdiscover_start();//连接上后开始遍历serveice和char
  88.  
  89.                 // Initiate service discovery
  90.                 tmos_start_task(centralTaskId, START_SVC_DISCOVERY_EVT, DEFAULT_SVC_DISCOVERY_DELAY);
  91.  
  92.                 // See if initiate connect parameter update
  93.                 if(centralParamUpdate)
  94.                 {
  95.                     tmos_start_task(centralTaskId, START_PARAM_UPDATE_EVT, DEFAULT_PARAM_UPDATE_DELAY);
  96.                 }
  97.                 // See if initiate connect parameter update
  98.                 if(centralPhyUpdate)
  99.                 {
  100.                     tmos_start_task(centralTaskId, START_PHY_UPDATE_EVT, DEFAULT_PHY_UPDATE_DELAY);
  101.                 }
  102.                 // See if start RSSI polling
  103.                 if(centralRssi)
  104.                 {
  105.                     tmos_start_task(centralTaskId, START_READ_RSSI_EVT, DEFAULT_RSSI_PERIOD);
  106.                 }
  107.  
  108.                 PRINT("Connected...\n");
  109.             }
  110.             else
  111.             {
  112.                 PRINT("Connect Failed...Reason:%X\n", pEvent->gap.hdr.status);
  113.                 PRINT("Discovering...\n");
  114.                 centralScanRes = 0;
  115.                 GAPRole_CentralStartDiscovery(DEFAULT_DISCOVERY_MODE,
  116.                                               DEFAULT_DISCOVERY_ACTIVE_SCAN,
  117.                                               DEFAULT_DISCOVERY_WHITE_LIST);
  118.             }
  119.         }
  120.         break;
  121.  
  122.         case GAP_LINK_TERMINATED_EVENT:
  123.         {
  124.             centralState = BLE_STATE_IDLE;
  125.             centralConnHandle = GAP_CONNHANDLE_INIT;
  126.             centralDiscState = BLE_DISC_STATE_IDLE;
  127.             centralCharHdl = 0;
  128.             centralScanRes = 0;
  129.             centralProcedureInProgress = FALSE;
  130.             tmos_stop_task(centralTaskId, START_READ_RSSI_EVT);
  131.             PRINT("Disconnected...Reason:%x\n", pEvent->linkTerminate.reason);
  132.             PRINT("Discovering...\n");
  133.             GAPRole_CentralStartDiscovery(DEFAULT_DISCOVERY_MODE,
  134.                                           DEFAULT_DISCOVERY_ACTIVE_SCAN,
  135.                                           DEFAULT_DISCOVERY_WHITE_LIST);
  136.         }
  137.         break;
  138.  
  139.         case GAP_LINK_PARAM_UPDATE_EVENT:
  140.         {
  141.             PRINT("Param Update...\n");
  142.         }
  143.         break;
  144.  
  145.         case GAP_PHY_UPDATE_EVENT:
  146.         {
  147.             PRINT("PHY Update...\n");
  148.         }
  149.         break;
  150.  
  151.         case GAP_EXT_ADV_DEVICE_INFO_EVENT:
  152.         {
  153.             // Display device addr
  154.             PRINT("AddrType:%d Recv ext adv - Addr %x %x %x %x %x %x \n", pEvent->deviceExtAdvInfo.addrType,pEvent->deviceExtAdvInfo.addr[0],
  155.                   pEvent->deviceExtAdvInfo.addr[1], pEvent->deviceExtAdvInfo.addr[2],
  156.                   pEvent->deviceExtAdvInfo.addr[3], pEvent->deviceExtAdvInfo.addr[4],
  157.                   pEvent->deviceExtAdvInfo.addr[5]);
  158.         }
  159.         break;
  160.  
  161.         case GAP_DIRECT_DEVICE_INFO_EVENT:
  162.         {
  163.             // Display device addr
  164.             PRINT("AddrType:%d Recv direct adv - Addr %x %x %x %x %x %x \n", pEvent->deviceExtAdvInfo.addrType, pEvent->deviceExtAdvInfo.addr[0],
  165.                   pEvent->deviceExtAdvInfo.addr[1], pEvent->deviceExtAdvInfo.addr[2],
  166.                   pEvent->deviceExtAdvInfo.addr[3], pEvent->deviceExtAdvInfo.addr[4],
  167.                   pEvent->deviceExtAdvInfo.addr[5]);
  168.         }
  169.         break;
  170.  
  171.         default:
  172.             break;
  173.     }
  174. }
  175.  
  176.  
  177.

2、遍历service和char

  1. //遍历所有service
  2. GATT_DiscAllPrimaryServices(centralConnHandle,centralTaskId );
  3.  
  4. 遍历完成会通过centralProcessGATTMsg传递系统消息SYS_EVENT_MSG给用户层进行解析
  5.  
  6. //如下从系统消息里解析出来遍历到需要的service hander值
  7. if( ( pMsg->method ==  ATT_READ_BY_GRP_TYPE_RSP) && 
  8.         			( pMsg->msg.readByGrpTypeRsp.numGrps > 0 ) )
  9.         {
  10.     		for(unsigned char i = 0 ; i < pMsg->msg.readByGrpTypeRsp.numGrps;i++)
  11.     		{
  12.                 uint8_t *p_uuid = &(pMsg->msg.readByGrpTypeRsp.pDataList[pMsg->msg.readByGrpTypeRsp.len * i + 4]);
  13.                 uint8_t uuid_length = pMsg->msg.readByGrpTypeRsp.len - 4;
  14.                 
  15.               
  16.                 if(uuid_length == sizeof(TheFind_ServiceUUID)){
  17.                     if(tmos_memcmp(TheFind_ServiceUUID,p_uuid,uuid_length)) {
  18.                         centralSvcStartHdl = BUILD_UINT16(	pMsg->msg.readByGrpTypeRsp.pDataList[pMsg->msg.readByGrpTypeRsp.len * i], \
  19.     						pMsg->msg.readByGrpTypeRsp.pDataList[pMsg->msg.readByGrpTypeRsp.len * i + 1]);
  20.                         centralSvcEndHdl = BUILD_UINT16(	pMsg->msg.readByGrpTypeRsp.pDataList[pMsg->msg.readByGrpTypeRsp.len * i+2], \
  21.     						pMsg->msg.readByGrpTypeRsp.pDataList[pMsg->msg.readByGrpTypeRsp.len * i + 3]);
  22.                     }
  23.                 }
  24.                 
  25.  
  26.     		}
  27.         }
  28.  
  29.  
  30.

找到service后开始遍历char

  1. //遍历所有char找到自己要用的char handler值
  2. GATT_DiscAllChars(centralConnHandle,centralSvcStartHdl,centralSvcEndHdl,centralTaskId);
  3.  
  4. //同样也是通过系统消息传递遍历后的结果
  5.  if ( pMsg->method == ATT_READ_BY_TYPE_RSP ){
  6.     if(pMsg->msg.readByTypeRsp.numPairs > 0 ){
  7.  
  8.         for(unsigned char i = 0; i < pMsg->msg.readByTypeRsp.numPairs ; i++){
  9.                 uint16_t char_value_handle = BUILD_UINT16(pMsg->msg.readByTypeRsp.pDataList[pMsg->msg.readByTypeRsp.len * i+3], \
  10.                                                 pMsg->msg.readByTypeRsp.pDataList[pMsg->msg.readByTypeRsp.len * i + 4]);
  11.                 //characteristic uuid length
  12.                 uint8_t char_uuid_length = pMsg->msg.readByGrpTypeRsp.len - 5;
  13.                 
  14.                 //uuid
  15.                 uint8_t *chat_uuid = &(pMsg->msg.readByGrpTypeRsp.pDataList[pMsg->msg.readByGrpTypeRsp.len * i + 5]);                          
  16.                 if(sizeof(TheFind_CharUUID) == char_uuid_length){
  17.                     if(tmos_memcmp(TheFind_CharUUID,chat_uuid,char_uuid_length)){
  18. 						TheFind_CharUUID = char_value_handle;
  19.                     }
  20.                 }
  21.         }
  22.     }
  23. }
  24.

3、遍历支持notify的char handler

  1.             req.startHandle = centralSvcStartHdl;
  2.             req.endHandle = centralSvcEndHdl;
  3.             req.type.len = ATT_BT_UUID_SIZE;
  4.             req.type.uuid[0] = LO_UINT16(GATT_CLIENT_CHAR_CFG_UUID);
  5.             req.type.uuid[1] = HI_UINT16(GATT_CLIENT_CHAR_CFG_UUID);
  6.             GATT_ReadUsingCharUUID( centralConnHandle, &req, centralTaskId );

4、读写char

  1.  void WriteCharHandler(uint8_t* data,uint8_t datalen，uint16_t Handler)
  2.  {
  3. 	 attWriteReq_t req;
  4. 	 req.cmd = FALSE;
  5. 	 req.sig = FALSE;
  6. 	 req.handle = Handler;
  7. 	 req.len = datalen;
  8. 	 req.pValue = GATT_bm_alloc(centralConnHandle, ATT_WRITE_REQ, req.len, NULL, 0);
  9. 	 if(req.pValue != NULL)
  10. 	 {
  11. 		 tmos_memcpy(req.pValue,data,datalen);
  12. 		 if(GATT_WriteCharValue(centralConnHandle, &req, centralTaskId) == SUCCESS)
  13. 		 {
  14. 			 centralDoWrite = FALSE;
  15. 		 }
  16. 		 else
  17. 		 {
  18. 			 GATT_bm_free((gattMsg_t *)&req, ATT_WRITE_REQ);
  19. 		 }
  20. 	 }
  21.  }
  22.  
  23.  
  24.  void ReadCharHandler(uint16_t handle)
  25.  {
  26. 	 attReadReq_t req;
  27. 	 req.handle = handle;
  28. 	 GATT_ReadCharValue(centralConnHandle, &req, centralTaskId);
  29.  }
  30.  
  31.

5、接收notify以及read响应

  1. //接收读写回应以及notify indicate都是通过系统消息进来给用户
  2.  
  3.  static void centralProcessGATTMsg(gattMsgEvent_t *pMsg)
  4.  {
  5. 	 if(centralState != BLE_STATE_CONNECTED)
  6. 	 {
  7. 		 // In case a GATT message came after a connection has dropped,
  8. 		 // ignore the message
  9. 		 GATT_bm_free(&pMsg->msg, pMsg->method);
  10. 		 return;
  11. 	 }
  12.  
  13. 	 if((pMsg->method == ATT_EXCHANGE_MTU_RSP) ||
  14. 		((pMsg->method == ATT_ERROR_RSP) &&
  15. 		 (pMsg->msg.errorRsp.reqOpcode == ATT_EXCHANGE_MTU_REQ)))
  16. 	 {
  17. 		 if(pMsg->method == ATT_ERROR_RSP)
  18. 		 {
  19. 			 uint8_t status = pMsg->msg.errorRsp.errCode;
  20.  
  21. 			 PRINT("Exchange MTU Error: %x\n", status);
  22. 		 }
  23. 		 centralProcedureInProgress = FALSE;
  24. 	 }
  25.  
  26. 	 if(pMsg->method == ATT_MTU_UPDATED_EVENT)
  27. 	 {
  28. 		 PRINT("MTU: %x\n", pMsg->msg.mtuEvt.MTU);
  29. 	 }
  30.  
  31. 	 if((pMsg->method == ATT_READ_RSP) ||
  32. 		((pMsg->method == ATT_ERROR_RSP) &&
  33. 		 (pMsg->msg.errorRsp.reqOpcode == ATT_READ_REQ)))
  34. 	 {
  35. 		 if(pMsg->method == ATT_ERROR_RSP)
  36. 		 {
  37. 			 uint8_t status = pMsg->msg.errorRsp.errCode;
  38.  
  39. 			 PRINT("Read Error: %x\n", status);
  40. 		 }
  41. 		 else
  42. 		 {
  43. 			 // After a successful read, display the read value
  44. 			 PRINT("Read rsp: %x\n", *pMsg->msg.readRsp.pValue);
  45. 			 
  46. 		 }
  47. 		 centralProcedureInProgress = FALSE;
  48. 	 }
  49. 	 else if((pMsg->method == ATT_WRITE_RSP) ||
  50. 			 ((pMsg->method == ATT_ERROR_RSP) &&
  51. 			  (pMsg->msg.errorRsp.reqOpcode == ATT_WRITE_REQ)))
  52. 	 {
  53. 		 if(pMsg->method == ATT_ERROR_RSP)
  54. 		 {
  55. 			 uint8_t status = pMsg->msg.errorRsp.errCode;
  56.  
  57. 			 PRINT("Write Error: %x\n", status);
  58. 		 }
  59. 		 else
  60. 		 {
  61. 			 // Write success
  62. 			 PRINT("Write success \n");
  63. 			 
  64. 		 }
  65.  
  66. 		 centralProcedureInProgress = FALSE;
  67. 	 }
  68. 	 else if(pMsg->method == ATT_HANDLE_VALUE_NOTI)
  69. 	 {
  70. 		 PRINT("Receive noti: %x\n", *pMsg->msg.handleValueNoti.pValue);
  71. 	 }
  72. 	 else if(centralDiscState != BLE_DISC_STATE_IDLE)
  73. 	 {
  74. 		 //centralGATTDiscoveryEvent(pMsg);
  75. 	 }
  76. 	 
  77. 	 GATT_bm_free(&pMsg->msg, pMsg->method);
  78.  }

对蓝牙主从连接以及服务特性发现流程稍微了解下后再来按着流程来理解软件上的流程基本都能很快用起来。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/933191
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号