一、背景
基于 simplelink_cc2640r2_sdk_1_40_00_45 [提取码：jp7g]的 multi_role 工程上做修改。实现CC2640R2F开发板充当主机设备，多连接4个从机设备，连接完成后对特征值进行改写。
二、流程
① 按键开启连接
② 循环对4个从机设备创建连接
③ 发现服务和特征
④ 写入特征值
⑤ 循环断开连接
三、开启连接
首先固定4个从机MAC地址，注意MAC地址要逆序排放。
uint8_t PeripheralMac1[6] = {0x22, 0x11, 0x00, 0x5D, 0x19, 0x00}; // 要连接从机1的MAC地址
uint8_t PeripheralMac2[6] = {0x44, 0x33, 0x00, 0x5D, 0x19, 0x00}; // 要连接从机2的MAC地址
uint8_t PeripheralMac3[6] = {0x66, 0x55, 0x00, 0x5D, 0x19, 0x00}; // 要连接从机3的MAC地址
uint8_t PeripheralMac4[6] = {0x88, 0x77, 0x00, 0x5D, 0x19, 0x00}; // 要连接从机4的MAC地址
然后修改按键处理函数，按下左键开启扫描4秒后，按下右键开启连接。
static void multi_role_handleKeys(uint8_t keys)
{
if (keys & KEY_LEFT)
{
// Check if the key is still pressed
if (PIN_getInputValue(Board_KEY_LEFT) == 0)
{
mr_doScan(0); // 此处传入0没有任何作用
}
}
else if (keys & KEY_RIGHT)
{
// Check if the key is still pressed
if (PIN_getInputValue(Board_KEY_RIGHT) == 0)
{
mr_doConnect(0); // 此处传入0没有任何作用
}
}
}
四、创建多连接
创建两个全局变量
uint8 connected_num = 0; // 已连接设备数量
uint8 goonConnFlag = FALSE; // 继续连接下一个设备标志
/**
@brief 执行创建连接函数
@param index 此处无用
@return TRUE 此处无用
*/
bool mr_doConnect(uint8_t index)
{
(void) index;
/* 如果正在连接中，则取消 */
if (connecting == TRUE)
{
GAPRole_TerminateConnection(GAP_CONNHANDLE_INIT); // 取消连接请求
// Clear connecting flag
connecting = FALSE; // 清除正在连接标志
}
/* 创建连接 */
else
{
GAPRole_CancelDiscovery(); // 取消扫描
scanningStarted = TRUE; // 开启正在扫描标志，避免执行扫描函数
/*----------------------- 连接第1个设备 -----------------------*/
if ((scanRes > 0) && (connected_num == 0))
{
uint8_t addrType;
uint8_t *peerAddr;
/* 判断是否有我们想连接的设备 */
for (uint8_t i = 0; i < scanRes; i++)
{
if (memcmp(PeripheralMac1, devList[i].addr, 6) == 0)
{
peerAddr = devList[i].addr;
addrType = devList[i].addrType;
/* 从扫描列表中向当前选择设备发出创建连接请求 */
GAPRole_EstablishLink(DEFAULT_LINK_HIGH_DUTY_CYCLE,
DEFAULT_LINK_WHITE_LIST,
addrType, peerAddr);
connected_num++;
connecting = TRUE; // 开启正在连接标志
goonConnFlag = TRUE; // 继续连接下一个设备
}
}
}
/*----------------------- 连接第2个设备 -----------------------*/
else if ((scanRes > 1) && (connected_num == 1))
{
uint8_t addrType;
uint8_t *peerAddr;
/* 判断是否有我们想连接的设备 */
for (uint8_t i = 0; i < scanRes; i++)
{
if (memcmp(PeripheralMac2, devList[i].addr, 6) == 0)
{
peerAddr = devList[i].addr;
addrType = devList[i].addrType;
/* 从扫描列表中向当前选择设备发出创建连接请求 */
GAPRole_EstablishLink(DEFAULT_LINK_HIGH_DUTY_CYCLE,
DEFAULT_LINK_WHITE_LIST,
addrType, peerAddr);
connected_num++;
connecting = TRUE; // 开启正在连接标志
goonConnFlag = TRUE; // 继续连接下一个设备
}
}
}
/*----------------------- 连接第3个设备 -----------------------*/
else if ((scanRes > 2) && (connected_num == 2))
{
uint8_t addrType;
uint8_t *peerAddr;
/* 判断是否有我们想连接的设备 */
for (uint8_t i = 0; i < scanRes; i++)
{
if (memcmp(PeripheralMac3, devList[i].addr, 6) == 0)
{
peerAddr = devList[i].addr;
addrType = devList[i].addrType;
/* 从扫描列表中向当前选择设备发出创建连接请求 */
GAPRole_EstablishLink(DEFAULT_LINK_HIGH_DUTY_CYCLE,
DEFAULT_LINK_WHITE_LIST,
addrType, peerAddr);
connected_num++;
connecting = TRUE; // 开启正在连接标志
goonConnFlag = TRUE; // 继续连接下一个设备
}
}
}
/*----------------------- 连接第4个设备 -----------------------*/
else if ((scanRes > 3) && (connected_num == 3))
{
uint8_t addrType;
uint8_t *peerAddr;
/* 判断是否有我们想连接的设备 */
for (uint8_t i = 0; i < scanRes; i++)
{
if (memcmp(PeripheralMac4, devList[i].addr, 6) == 0)
{
peerAddr = devList[i].addr;
addrType = devList[i].addrType;
/* 从扫描列表中向当前选择设备发出创建连接请求 */
GAPRole_EstablishLink(DEFAULT_LINK_HIGH_DUTY_CYCLE,
DEFAULT_LINK_WHITE_LIST,
addrType, peerAddr);
connected_num++;
connecting = TRUE; // 开启正在连接标志
goonConnFlag = FALSE; // 停止继续连接
}
}
}
}
return TRUE;
}
在第1个从机设备调用 GAPRole_EstablishLink() 创建连接函数之后，如果建立连接完成，则进入建立连接完成事件 GAP_LINK_ESTABLISHED_EVENT，对下一个设备创建连接。
在 multi_role_processRoleEvent() 函数中
/*----------------------- 建立链接完成事件 -----------------------*/
case GAP_LINK_ESTABLISHED_EVENT:
{
// If succesfully established
if (pEvent->gap.hdr.status == SUCCESS)
{
connecting = FALSE; // 清除正在连接标志
// Add index-to-connHandle mapping entry and update menus
uint8_t index = multi_role_addMappingEntry(pEvent->linkCmpl.connectionHandle, pEvent->linkCmpl.devAddr);
// turn off advertising if no available links
if (linkDB_NumActive() >= maxNumBleConns)
{
uint8_t advertEnabled = FALSE;
GAPRole_SetParameter(GAPROLE_ADVERT_ENABLED, sizeof(uint8_t), &advertEnabled, NULL);
}
/* 开始发现服务 */
multi_role_startDiscovery(pEvent->linkCmpl.connectionHandle);
if (goonConnFlag == TRUE)
{
mr_doConnect(0); // 连接完成后，进行对下一个设备连接
}
}
// If the connection was not successfully established
else
{
}
}
break;
五、发现服务和特征
在上述事件中调用 multi_role_startDiscovery()发现服务函数后，
static void multi_role_startDiscovery(uint16_t connHandle)
{
// 交换MTU请求
attExchangeMTUReq_t req;
// Map connection handle to index
connIndex = multi_role_mapConnHandleToIndex(connHandle);
// Check to prevent buffer overrun
if (connIndex < maxNumBleConns)
{
// Update discovery state of this connection
discInfo[connIndex].discState = BLE_DISC_STATE_MTU;
// Initialize cached handles
discInfo[connIndex].svcStartHdl = discInfo[connIndex].svcEndHdl = 0;
}
else
{
// 连接句柄数量超过最大可连接设备数
}
// Discover GATT Server's Rx MTU size
req.clientRxMTU = maxPduSize - L2CAP_HDR_SIZE;
// ATT MTU size should be set to the minimum of the Client Rx MTU
// and Server Rx MTU values
VOID GATT_ExchangeMTU(connHandle, &req, selfEntity);
}
调用GATT交换MTU消息函数 GATT_ExchangeMTU，当蓝牙协议栈收到GATT交换MTU消息后，
在 multi_role_processStackMsg() 处理栈消息函数中，如果当前连接活跃设备数大于0，则进入 multi_role_processGATTDiscEvent() 处理GATT发现事件函数；否则如果当前连接活跃设备数等于0，则断开所有连接。断开连接定时器函数，后面给出
/*------------------处理GATT消息--------------------*/
case GATT_MSG_EVENT:
// Process GATT message
safeToDealloc = multi_role_processGATTMsg((gattMsgEvent_t *)pMsg);
break;
收到GATT消息后，进入 GATT_MSG_EVENT 事件。
在 multi_role_processGATTMsg() 处理GATT消息函数中
static uint8_t multi_role_processGATTMsg(gattMsgEvent_t *pMsg)
{
// 查看GATT服务器是否无法传输ATT响应
if (pMsg->hdr.status == blePending)
{
// No HCI buffer was available. Let's try to retransmit the response
// on the next connection event.
if (HCI_EXT_ConnEventNoticeCmd(pMsg->connHandle, selfEntity,
MR_CONN_EVT_END_EVT) == SUCCESS)
{
// First free any pending response
multi_role_freeAttRsp(FAILURE);
// Hold on to the response message for retransmission
pAttRsp = pMsg;
// Don't free the response message yet
return (FALSE);
}
}
else if (pMsg->method == ATT_FLOW_CTRL_VIOLATED_EVENT)
{
// ATT request-response or indication-confirmation flow control is
// violated. All subsequent ATT requests or indications will be dropped.
// The app is informed in case it wants to drop the connection.
}
else if (pMsg->method == ATT_MTU_UPDATED_EVENT)
{
// MTU size updated
}
// 来自GATT服务端的消息
// 如果连接活跃设备数大于0
if (linkDB_NumActive() > 0)
{
// Find index from connection handle
connIndex = multi_role_mapConnHandleToIndex(pMsg->connHandle);
if (connIndex < maxNumBleConns)
{
if ((pMsg->method == ATT_READ_RSP) ||
((pMsg->method == ATT_ERROR_RSP) &&
(pMsg->msg.errorRsp.reqOpcode == ATT_READ_REQ)))
{
if (pMsg->method == ATT_ERROR_RSP)
{
}
else
{
// After a successful read, display the read value
}
}
else if ((pMsg->method == ATT_WRITE_RSP) ||
((pMsg->method == ATT_ERROR_RSP) &&
(pMsg->msg.errorRsp.reqOpcode == ATT_WRITE_REQ)))
{
if (pMsg->method == ATT_ERROR_RSP == ATT_ERROR_RSP)
{
}
else
{
// After a succesful write, display the value that was written and
// increment value
}
}
else if (discInfo[connIndex].discState != BLE_DISC_STATE_IDLE)
{
multi_role_processGATTDiscEvent(pMsg); // 处理GATT发现事件
}
}
} // Else - in case a GATT message came after a connection has dropped, ignore it.
else
{
// 当前连接活跃设备数为0就断连
Util_startClock(&delayDisconnClock); // 延时后断连
}
// Free message payload. Needed only for ATT Protocol messages
GATT_bm_free(&pMsg->msg, pMsg->method);
// It's safe to free the incoming message
return (TRUE);
}
如果收到GATT交换MTU消息后，如果从机设备不自己断开连接，会陆续收到GATT发现服务消息、GATT发现特征消息。在multi_role_processGATTDiscEvent() 中，可以根据用户需求，更改需要发现的服务的UUID SIMPLEPROFILE_SERV_UUID 和 特征UUID SIMPLEPROFILE_CHAR1_UUID，在这里是0xFFF0和0xFFF1
static void multi_role_processGATTDiscEvent(gattMsgEvent_t *pMsg)
{
// Map connection handle to index
connIndex = multi_role_mapConnHandleToIndex(pMsg->connHandle);
// Check to prevent buffer overrun
if (connIndex < maxNumBleConns)
{
// MTU update
if (pMsg->method == ATT_MTU_UPDATED_EVENT)
{
// MTU size updated
}
// If we've updated the MTU size
/*----------------------- 交换ATT属性MTU大小 -----------------------*/
else if (discInfo[connIndex].discState == BLE_DISC_STATE_MTU)
{
// MTU size response received, discover simple service
if (pMsg->method == ATT_EXCHANGE_MTU_RSP)
{
uint8_t uuid[ATT_BT_UUID_SIZE] = { LO_UINT16(SIMPLEPROFILE_SERV_UUID),
HI_UINT16(SIMPLEPROFILE_SERV_UUID) };
// Advance state
discInfo[connIndex].discState= BLE_DISC_STATE_SVC;
// Discovery of simple service
VOID GATT_DiscPrimaryServiceByUUID(pMsg->connHandle, uuid, ATT_BT_UUID_SIZE, selfEntity);
}
}
// If we're performing service discovery
/*----------------------- 发现服务 -----------------------*/
else if (discInfo[connIndex].discState == BLE_DISC_STATE_SVC)
{
// Service found, store handles
if (pMsg->method == ATT_FIND_BY_TYPE_VALUE_RSP &&
pMsg->msg.findByTypeValueRsp.numInfo > 0)
{
discInfo[connIndex].svcStartHdl = ATT_ATTR_HANDLE(pMsg->msg.findByTypeValueRsp.pHandlesInfo, 0);
discInfo[connIndex].svcEndHdl = ATT_GRP_END_HANDLE(pMsg->msg.findByTypeValueRsp.pHandlesInfo, 0);
}
// If procedure is complete
if (((pMsg->method == ATT_FIND_BY_TYPE_VALUE_RSP) &&
(pMsg->hdr.status == bleProcedureComplete)) ||
(pMsg->method == ATT_ERROR_RSP))
{
// If we've discovered the service
if (discInfo[connIndex].svcStartHdl != 0)
{
attReadByTypeReq_t req;
// Discover characteristic
discInfo[connIndex].discState = BLE_DISC_STATE_CHAR;
req.startHandle = discInfo[connIndex].svcStartHdl;
req.endHandle = discInfo[connIndex].svcEndHdl;
req.type.len = ATT_BT_UUID_SIZE;
req.type.uuid[0] = LO_UINT16(SIMPLEPROFILE_CHAR1_UUID);
req.type.uuid[1] = HI_UINT16(SIMPLEPROFILE_CHAR1_UUID);
// Send characteristic discovery request
VOID GATT_ReadUsingCharUUID(pMsg->connHandle, &req, selfEntity);
}
}
}
// If we're discovering characteristics
/*----------------------- 发现特征 -----------------------*/
else if (discInfo[connIndex].discState == BLE_DISC_STATE_CHAR)
{
// Characteristic found
if ((pMsg->method == ATT_READ_BY_TYPE_RSP) &&
(pMsg->msg.readByTypeRsp.numPairs > 0))
{
// Store handle
discInfo[connIndex].charHdl = BUILD_UINT16(pMsg->msg.readByTypeRsp.pDataList[0],
pMsg->msg.readByTypeRsp.pDataList[1]);
}
mr_doGattRw(connIndex);
}
}
}
在成功发现特征后，调用读写特征函数 mr_doGattRw()。
六、写入特征值
如果执行写入特征值的设备数等于已连接的设备数，则开启延时断连定时器
/**
@brief 执行读写特征值函数
@param index 要读写特征值的索引
@return 无
*/
bool mr_doGattRw(uint8_t index)
{
bStatus_t status = FAILURE;
static uint8_t doing_deive_num = 0;
uint8_t readOrWrite = 0;
/* 如果已经发现特征 */
if (discInfo[index].charHdl != 0)
{
/*----------------------- 执行写操作 -----------------------*/
if (readOrWrite == 0)
{
attWriteReq_t req;
/* 分配GATT写入请求包的内存 */
req.pValue = GATT_bm_alloc(connHandleMap[index].connHandle, ATT_WRITE_REQ, 1, NULL);
if (req.pValue != NULL)
{
/* 填充请求包 */
req.handle = discInfo[index].charHdl; // 特征句柄
req.len = 1; // 特征值长度
req.pValue[0] = 1; // 特征值
req.sig = 0;
req.cmd = 0;
/* 向控制器发送GATT写入特征值请求 */
status = GATT_WriteCharValue(connHandleMap[index].connHandle, &req, selfEntity);
doing_deive_num++; // 执行设备数+1
/* 发送请求失败 */
if (status != SUCCESS)
{
/* 释放内存 */
GATT_bm_free((gattMsg_t *)&req, ATT_WRITE_REQ);
}
}
}
/*----------------------- 执行读操作 -----------------------*/
else
{
// Create read request...place in CSTACK
attReadReq_t req;
/* 填充请求包 */
req.handle = discInfo[index].charHdl; // 特征句柄
// Send read request. no need to free if unsuccessful since the request
// is only placed in CSTACK; not allocated
status = GATT_ReadCharValue(connHandleMap[index].connHandle, &req, selfEntity);
}
/* 如果执行设备数等于已连接设备数 */
if (doing_deive_num == connected_num)
{
Util_startClock(&delayDisconnClock); // 延时后断连
doing_deive_num = 0; // 执行设备数清零
}
}
return TRUE;
}
七、断开连接
7.1 注册延时断连定时器
定义延时断开定时器的宏
#define MR_DELAY_DISCONN_EVT Event_Id_08 // 定时器：延迟断开连接事件
将这个宏加入事件集合里面
// 所有事件的集合
#define MR_ALL_EVENTS (MR_ICALL_EVT | \
MR_QUEUE_EVT | \
MR_STATE_CHANGE_EVT | \
MR_CHAR_CHANGE_EVT | \
MR_CONN_EVT_END_EVT | \
MR_KEY_CHANGE_EVT | \
MR_PAIRING_STATE_EVT | \
MR_PERIODIC_EVT | \
MR_PASSCODE_NEEDED_EVT | \
MR_UART_EVT | \
MR_DELAY_DISCONN_EVT)
添加延时断开定时器事件的处理，在 multi_role_taskFxn() 中，尾部加入
/*----------------- 延迟断连事件 ------------------*/
if (events & MR_DELAY_DISCONN_EVT)
{
// 延迟断连处理函数
delay_disconnect_performTask();
}
声明和定义延时断开定时器事件处理函数
static void delay_disconnect_performTask(void);
static void delay_disconnect_performTask(void)
{
uint8 disconn_num;
/* 要断连的数量小于已连接数量，则继续 */
for (disconn_num = 0; disconn_num < connected_num; disconn_num++)
{
mr_doDisconnect(disconn_num); // 执行断连函数
}
// 初始化连接句柄表的索引
for (uint8_t i = 0; i < maxNumBleConns; i++)
{
connHandleMap[i].connHandle = INVALID_CONNHANDLE; // 无效连接句柄
}
/* 重新开始扫描 */
scanningStarted = FALSE; // 断连后，清除正在扫描标志
connected_num = 0; // 已连接设备数清零
mr_doScan(0); // 执行扫描函数
}
初始化定时器
static Clock_Struct delayDisconnClock; // 定义延时断连处理定时器
设置延时时间，这里设置为 4000ms。
#define DELAY_DISCONN_EVT_PERIOD 4000
初始化定时事件，在 multi_role_init() 中，尾部加入
// 延时断连处理定时器初始化
Util_constructClock(&delayDisconnClock, multi_role_clockHandler,
DELAY_DISCONN_EVT_PERIOD, 0, false, MR_DELAY_DISCONN_EVT);
7.2 故障处理
发起4个设备多连接的时候，不一定每个设备都会成功连上，当一个设备断开后，会产生 GAP_LINK_TERMINATED_EVENT 终止连接事件
在 multi_role_processRoleEvent() 函数中
/*----------------------- 终止链接事件 -----------------------*/
case GAP_LINK_TERMINATED_EVENT:
{
// read current num active so that this doesn't change before this event is processed
uint8_t currentNumActive = linkDB_NumActive();
// Find index from connection handle
connIndex = multi_role_mapConnHandleToIndex(pEvent->linkTerminate.connectionHandle);
// 检查连接索引是否小于最大连接数，避免过载
if (connIndex < maxNumBleConns)
{
// Clear screen, reset discovery info, and return to main menu
connHandleMap[connIndex].connHandle = INVALID_CONNHANDLE;
// Reset discovery info
discInfo[connIndex].discState = BLE_DISC_STATE_IDLE;
discInfo[connIndex].charHdl = 0;
// If there aren't any active connections
if (currentNumActive == 0)
{
// Stop periodic clock
Util_stopClock(&periodicClock);
}
if(connected_num > 0)
{
Util_startClock(&delayDisconnClock); // 延时后断连
}
}
}
break;
当一个设备进入这个事件时，要执行延时断连定时器，避免程序卡死。
八、注意事项
-
修改最大可连接设备的宏
- 修改默认连接间隔时间
#define DEFAULT_CONN_INT 33
计算公式：12.5 + 5*N（N为可连接设备数）
• 由 Leung 写于 2019 年 2 月 23 日
• 参考：BLE开发（TI CC254x）之一主多从方案（蓝牙项目纪实）