TI BLE:SCAN

主机会运行SCAN来搜寻广播中的设备

运行函数：

GAPCentralRole_StartDiscovery( DEFAULT_DISCOVERY_MODE,
DEFAULT_DISCOVERY_ACTIVE_SCAN,
DEFAULT_DISCOVERY_WHITE_LIST );

 /**
  * @brief   Start a device discovery scan.
  *
  * Public function defined in central.h.
  */
 bStatus_t GAPCentralRole_StartDiscovery( uint8 mode, uint8 activeScan, uint8 whiteList )
 {
   gapDevDiscReq_t params;

   params.taskID = gapCentralRoleTaskId;
   params.mode = mode;
   params.activeScan = activeScan;
   params.whiteList = whiteList;

   return GAP_DeviceDiscoveryRequest( &params );
 }

GAPCentralRole_StartDiscovery

最终使用的是API：GAP_DeviceDiscoveryRequest

来看几个参数：DEFAULT_DISCOVERY_MODE

// Discovey mode (limited, general, all)
#define DEFAULT_DISCOVERY_MODE     DEVDISC_MODE_ALL

#define DEVDISC_MODE_NONDISCOVERABLE 0x00 //!< No discoverable setting
#define DEVDISC_MODE_GENERAL 0x01 //!< General Discoverable devices
#define DEVDISC_MODE_LIMITED 0x02 //!< Limited Discoverable devices
#define DEVDISC_MODE_ALL 0x03 //!< Not filtered

// TRUE to use active scan
#define DEFAULT_DISCOVERY_ACTIVE_SCAN TRUE

// TRUE to use white list during discovery
#define DEFAULT_DISCOVERY_WHITE_LIST FALSE

//TRUE to only allow advertisements from devices in the white list.

初始化函数中有些设置：

// Setup Central Profile
{
uint8 scanRes = DEFAULT_MAX_SCAN_RES;
GAPCentralRole_SetParameter ( GAPCENTRALROLE_MAX_SCAN_RES, sizeof( uint8 ), &scanRes );
}

// Maximum number of scan responses
#define DEFAULT_MAX_SCAN_RES 8

最大的支持扫描到的器件数，为8

GAP_SetParamValue( TGAP_GEN_DISC_SCAN, DEFAULT_SCAN_DURATION );
GAP_SetParamValue( TGAP_LIM_DISC_SCAN, DEFAULT_SCAN_DURATION );

// Scan duration in ms
#define DEFAULT_SCAN_DURATION 4000

#define TGAP_GEN_DISC_SCAN 2 //!< Minimum time to perform scanning, when performing General Discovery proc (mSec)
#define TGAP_LIM_DISC_SCAN 3 //!< Minimum time to perform scanning, when performing Limited Discovery proc (mSec)

主机的发现过程，有两个事件：GAP_DEVICE_INFO_EVENT，GAP_DEVICE_DISCOVERY_EVENT

#define GAP_DEVICE_INFO_EVENT                 0x0D //!< Sent during the Device Discovery Process when a device is discovered. This event is sent as an OSAL message defined as gapDeviceInfoEvent_t.

发现当中每发现一个device就触发一次

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

发现结束时候调用

 case GAP_DEVICE_INFO_EVENT:
       {
         // if filtering device discovery results based on service UUID
         if ( DEFAULT_DEV_DISC_BY_SVC_UUID == TRUE )
         {
           if ( simpleBLEFindSvcUuid( SIMPLEPROFILE_SERV_UUID,
                                      pEvent->deviceInfo.pEvtData,
                                      pEvent->deviceInfo.dataLen ) )
           {
             simpleBLEAddDeviceInfo( pEvent->deviceInfo.addr, pEvent->deviceInfo.addrType );
           }
         }
       }
       break;

GAP_DEVICE_INFO_EVENT

每次发现会调用两个函数：simpleBLEFindSvcUuid，确定发现的设备SvcUUid是否匹配，匹配的话调用simpleBLEAddDeviceInfo将其地址加入列表

 /*********************************************************************
  * @fn      simpleBLEFindSvcUuid
  *
  * @brief   Find a given UUID in an advertiser's service UUID list.
  *
  * @return  TRUE if service UUID found
  */
 static bool simpleBLEFindSvcUuid( uint16 uuid, uint8 *pData, uint8 dataLen )
 {
   uint8 adLen;
   uint8 adType;
   uint8 *pEnd;

   pEnd = pData + dataLen - ;

   // While end of data not reached
   while ( pData < pEnd )
   {
     // Get length of next AD item
     adLen = *pData++;
     if ( adLen >  )
     {
       adType = *pData;

       // If AD type is for 16-bit service UUID
       if ( adType == GAP_ADTYPE_16BIT_MORE || adType == GAP_ADTYPE_16BIT_COMPLETE )
       {
         pData++;
         adLen--;

         // For each UUID in list
         while ( adLen >=  && pData < pEnd )
         {
           // Check for match
           if ( pData[] == LO_UINT16(uuid) && pData[] == HI_UINT16(uuid) )
           {
             // Match found
             return TRUE;
           }

           // Go to next
           pData += ;
           adLen -= ;
         }

         // Handle possible erroneous extra byte in UUID list
         if ( adLen ==  )
         {
           pData++;
         }
       }
       else
       {
         // Go to next item
         pData += adLen;
       }
     }
   }

   // Match not found
   return FALSE;
 }

simpleBLEFindSvcUuid

这个函数利用广播数据格式来判断，先找到类型字节，判断类型是否是uuid，是的话判断内容，不是的话调到下一段内容，把广播格式再粘一次

 / GAP - Advertisement data (max size =  bytes, though this is
 // best kept short to conserve power while advertisting)
 static uint8 advertData[] =
 {
   // Flags; this sets the device to use limited discoverable
   // mode (advertises for 30 seconds at a time) instead of general
   // discoverable mode (advertises indefinitely)
   0x02,   // length of this data
   GAP_ADTYPE_FLAGS,
   DEFAULT_DISCOVERABLE_MODE | GAP_ADTYPE_FLAGS_BREDR_NOT_SUPPORTED,

   // service UUID, to notify central devices what services are included
   // in this peripheral
   0x03,   // length of this data
   GAP_ADTYPE_16BIT_MORE,      // some of the UUID's, but not all
   LO_UINT16( SIMPLEPROFILE_SERV_UUID ),
   HI_UINT16( SIMPLEPROFILE_SERV_UUID ),

 };

advertData

如果是的话加入数组当中，也将扫描到的设备数+1

 /*********************************************************************
  * @fn      simpleBLEAddDeviceInfo
  *
  * @brief   Add a device to the device discovery result list
  *
  * @return  none
  */
 static void simpleBLEAddDeviceInfo( uint8 *pAddr, uint8 addrType )
 {
   uint8 i;

   // If result count not at max
   if ( simpleBLEScanRes < DEFAULT_MAX_SCAN_RES )
   {
     // Check if device is already in scan results
     for ( i = ; i < simpleBLEScanRes; i++ )
     {
       if ( osal_memcmp( pAddr, simpleBLEDevList[i].addr , B_ADDR_LEN ) )
       {
         return;
       }
     }

     // Add addr to scan result list
     osal_memcpy( simpleBLEDevList[simpleBLEScanRes].addr, pAddr, B_ADDR_LEN );
     simpleBLEDevList[simpleBLEScanRes].addrType = addrType;

     // Increment scan result count
     simpleBLEScanRes++;
   }
 }

simpleBLEAddDeviceInfo

发现结束后会将数组转移做些存储然后指示用户下一步

 case GAP_DEVICE_DISCOVERY_EVENT:
       {
         // discovery complete
         simpleBLEScanning = FALSE;

         // if not filtering device discovery results based on service UUID
         if ( DEFAULT_DEV_DISC_BY_SVC_UUID == FALSE )
         {
           // Copy results
           simpleBLEScanRes = pEvent->discCmpl.numDevs;
           osal_memcpy( simpleBLEDevList, pEvent->discCmpl.pDevList,
                        (sizeof( gapDevRec_t ) * pEvent->discCmpl.numDevs) );
         }

         LCD_WRITE_STRING_VALUE( "Devices Found", simpleBLEScanRes,
                                 , HAL_LCD_LINE_1 );
         if ( simpleBLEScanRes >  )
         {
           LCD_WRITE_STRING( "<- To Select", HAL_LCD_LINE_2 );
         }

         // initialize scan index to last device
         simpleBLEScanIdx = simpleBLEScanRes;

       }
       break;

GAP_DEVICE_DISCOVERY_EVENT

key里面有个更新显示，对于收到的device比较多的时候：

  if ( keys & HAL_KEY_LEFT )
   {
     // Display discovery results
     if ( !simpleBLEScanning && simpleBLEScanRes >  )
     {
         // Increment index of current result (with wraparound)
         simpleBLEScanIdx++;
         if ( simpleBLEScanIdx >= simpleBLEScanRes )
         {
           simpleBLEScanIdx = ;
         }

         LCD_WRITE_STRING_VALUE( "Device", simpleBLEScanIdx + ,
                                 , HAL_LCD_LINE_1 );
         LCD_WRITE_STRING( bdAddr2Str( simpleBLEDevList[simpleBLEScanIdx].addr ),
                           HAL_LCD_LINE_2 );
     }
   }

HAL_KEY_LEFT