/*******************************************************************************
* Function Name: StartAdvertisement
********************************************************************************
*
* Summary:
* Initiates the advertisement procedure.
* Prints the Device Address.
*
* Parameters:
* None.
*
* Return:
* None.
*
*******************************************************************************/
void StartAdvertisement(uint8 advType)
{
CYBLE_API_RESULT_T apiResult = CYBLE_ERROR_OK;
CYBLE_GAP_BD_ADDR_T localAddr;
uint16 i;
if(advType == ADV_STATE_GENERAL)
{
cyBle_discoveryParam.advFilterPolicy = SCAN_ANY_CONNECT_ANY;
}
else
{
cyBle_discoveryParam.advFilterPolicy = SCAN_WHITELIST_CONNECT_WHITELIST;
}
apiResult = CyBle_GappStartAdvertisement(CYBLE_ADVERTISING_FAST);
if(apiResult != CYBLE_ERROR_OK)
{
printf("StartAdvertisement API Error: %x \r\n", (int) apiResult);
}
else
{
printf("Start Advertisement with addr: ");
CyBle_GetDeviceAddress(&localAddr);
for(i = CYBLE_GAP_BD_ADDR_SIZE; i > 0u; i--)
{
printf("%2.2x", localAddr.bdAddr[i-1]);
}
printf("\r\n");
}
}
/*******************************************************************************
* Function Name: AppCallBack()
********************************************************************************
*
* Summary:
* This is an event callback function to receive events from the BLE Component.
*
*******************************************************************************/
void AppCallBack(uint32 event, void* eventParam)
{
CYBLE_API_RESULT_T apiResult;
CYBLE_GAP_BD_ADDR_T localAddr;
CYBLE_GAP_AUTH_INFO_T *authInfo;
uint8 i;
switch (event)
{
/**********************************************************
* General Events
***********************************************************/
case CYBLE_EVT_STACK_ON: /* This event is received when the component is Started */
/* Enter into discoverable mode so that remote can search it. */
apiResult = CyBle_GappStartAdvertisement(CYBLE_ADVERTISING_FAST);
if(apiResult != CYBLE_ERROR_OK)
{
DBG_PRINTF("StartAdvertisement API Error: %d \r\n", apiResult);
}
DBG_PRINTF("Bluetooth On, StartAdvertisement with addr: ");
localAddr.type = 0u;
CyBle_GetDeviceAddress(&localAddr);
for(i = CYBLE_GAP_BD_ADDR_SIZE; i > 0u; i--)
{
DBG_PRINTF("%2.2x", localAddr.bdAddr[i-1]);
}
DBG_PRINTF("\r\n");
break;
case CYBLE_EVT_TIMEOUT:
break;
case CYBLE_EVT_HARDWARE_ERROR: /* This event indicates that some internal HW error has occurred. */
DBG_PRINTF("CYBLE_EVT_HARDWARE_ERROR \r\n");
break;
/* This event will be triggered by host stack if BLE stack is busy or not busy.
* Parameter corresponding to this event will be the state of BLE stack.
* BLE stack busy = CYBLE_STACK_STATE_BUSY,
* BLE stack not busy = CYBLE_STACK_STATE_FREE
*/
case CYBLE_EVT_STACK_BUSY_STATUS:
DBG_PRINTF("CYBLE_EVT_STACK_BUSY_STATUS: %x\r\n", *(uint8 *)eventParam);
break;
case CYBLE_EVT_HCI_STATUS:
DBG_PRINTF("CYBLE_EVT_HCI_STATUS: %x \r\n", *(uint8 *)eventParam);
break;
/**********************************************************
* GAP Events
***********************************************************/
case CYBLE_EVT_GAP_AUTH_REQ:
DBG_PRINTF("CYBLE_EVT_AUTH_REQ: security=%x, bonding=%x, ekeySize=%x, err=%x \r\n",
(*(CYBLE_GAP_AUTH_INFO_T *)eventParam).security,
(*(CYBLE_GAP_AUTH_INFO_T *)eventParam).bonding,
(*(CYBLE_GAP_AUTH_INFO_T *)eventParam).ekeySize,
(*(CYBLE_GAP_AUTH_INFO_T *)eventParam).authErr);
break;
case CYBLE_EVT_GAP_PASSKEY_ENTRY_REQUEST:
DBG_PRINTF("CYBLE_EVT_PASSKEY_ENTRY_REQUEST press 'p' to enter passkey \r\n");
break;
case CYBLE_EVT_GAP_PASSKEY_DISPLAY_REQUEST:
DBG_PRINTF("CYBLE_EVT_PASSKEY_DISPLAY_REQUEST %6.6ld \r\n", *(uint32 *)eventParam);
break;
case CYBLE_EVT_GAP_KEYINFO_EXCHNGE_CMPLT:
DBG_PRINTF("CYBLE_EVT_GAP_KEYINFO_EXCHNGE_CMPLT \r\n");
break;
case CYBLE_EVT_GAP_AUTH_COMPLETE:
authInfo = (CYBLE_GAP_AUTH_INFO_T *)eventParam;
(void)authInfo;
DBG_PRINTF("AUTH_COMPLETE: security:%x, bonding:%x, ekeySize:%x, authErr %x \r\n",
authInfo->security, authInfo->bonding, authInfo->ekeySize, authInfo->authErr);
break;
case CYBLE_EVT_GAP_AUTH_FAILED:
DBG_PRINTF("CYBLE_EVT_AUTH_FAILED: %x \r\n", *(uint8 *)eventParam);
break;
case CYBLE_EVT_GAPP_ADVERTISEMENT_START_STOP:
DBG_PRINTF("CYBLE_EVT_ADVERTISING, state: %x \r\n", CyBle_GetState());
if(CYBLE_STATE_DISCONNECTED == CyBle_GetState())
{
/* Fast and slow advertising period complete, go to low power
* mode (Hibernate mode) and wait for an external
* user event to wake up the device again */
DBG_PRINTF("Hibernate \r\n");
LED_BLU_Write(LED_OFF);
LED_RED_Write(LED_ON);
LED_GRN_Write(LED_OFF);
SW2_ClearInterrupt();
Wakeup_Interrupt_ClearPending();
Wakeup_Interrupt_Start();
#if (DEBUG_UART_ENABLED == ENABLED)
/* Wait until debug info is sent */
while((UART_DEB_SpiUartGetTxBufferSize() + UART_DEB_GET_TX_FIFO_SR_VALID) != 0);
#endif /* (DEBUG_UART_ENABLED == ENABLED) */
CySysPmHibernate();
}
break;
case CYBLE_EVT_GAP_DEVICE_CONNECTED:
DBG_PRINTF("CYBLE_EVT_GAP_DEVICE_CONNECTED \r\n");
LED_BLU_Write(LED_OFF);
break;
case CYBLE_EVT_GAP_DEVICE_DISCONNECTED:
DBG_PRINTF("CYBLE_EVT_GAP_DEVICE_DISCONNECTED\r\n");
apiResult = CyBle_GappStartAdvertisement(CYBLE_ADVERTISING_FAST);
if(apiResult != CYBLE_ERROR_OK)
{
DBG_PRINTF("StartAdvertisement API Error: %d \r\n", apiResult);
}
break;
case CYBLE_EVT_GATTS_XCNHG_MTU_REQ:
{
uint16 mtu;
CyBle_GattGetMtuSize(&mtu);
DBG_PRINTF("CYBLE_EVT_GATTS_XCNHG_MTU_REQ, final mtu= %d \r\n", mtu);
}
break;
case CYBLE_EVT_GATTS_WRITE_REQ:
DBG_PRINTF("CYBLE_EVT_GATT_WRITE_REQ: %x = ",((CYBLE_GATTS_WRITE_REQ_PARAM_T *)eventParam)->handleValPair.attrHandle);
ShowValue(&((CYBLE_GATTS_WRITE_REQ_PARAM_T *)eventParam)->handleValPair.value);
(void)CyBle_GattsWriteRsp(((CYBLE_GATTS_WRITE_REQ_PARAM_T *)eventParam)->connHandle);
break;
case CYBLE_EVT_GAP_ENCRYPT_CHANGE:
DBG_PRINTF("CYBLE_EVT_GAP_ENCRYPT_CHANGE: %x \r\n", *(uint8 *)eventParam);
break;
case CYBLE_EVT_GAPC_CONNECTION_UPDATE_COMPLETE:
DBG_PRINTF("CYBLE_EVT_CONNECTION_UPDATE_COMPLETE: %x \r\n", *(uint8 *)eventParam);
break;
/**********************************************************
* GATT Events
***********************************************************/
case CYBLE_EVT_GATT_CONNECT_IND:
DBG_PRINTF("CYBLE_EVT_GATT_CONNECT_IND: %x, %x \r\n", cyBle_connHandle.attId, cyBle_connHandle.bdHandle);
/* Register service specific callback functions */
HidsInit();
BasInit();
ScpsInit();
break;
case CYBLE_EVT_GATT_DISCONNECT_IND:
DBG_PRINTF("CYBLE_EVT_GATT_DISCONNECT_IND \r\n");
break;
case CYBLE_EVT_GATTS_READ_CHAR_VAL_ACCESS_REQ:
/* Triggered on server side when client sends read request and when
* characteristic has CYBLE_GATT_DB_ATTR_CHAR_VAL_RD_EVENT property set.
* This event could be ignored by application unless it need to response
* by error response which needs to be set in gattErrorCode field of
* event parameter. */
DBG_PRINTF("CYBLE_EVT_GATTS_READ_CHAR_VAL_ACCESS_REQ: handle: %x \r\n",
((CYBLE_GATTS_CHAR_VAL_READ_REQ_T *)eventParam)->attrHandle);
break;
/**********************************************************
* Other Events
***********************************************************/
case CYBLE_EVT_PENDING_FLASH_WRITE:
/* Inform application that flash write is pending. Stack internal data
* structures are modified and require to be stored in Flash using
* CyBle_StoreBondingData() */
DBG_PRINTF("CYBLE_EVT_PENDING_FLASH_WRITE\r\n");
break;
default:
DBG_PRINTF("OTHER event: %lx \r\n", event);
break;
}
}
void StackEventHandler(uint32 event,void * eventParam)
{
/*Local avriables*/
uint8 i;
CYBLE_GAP_BD_ADDR_T localAddr;
switch(event)
{
case CYBLE_EVT_STACK_ON:
printf("BLE Stack ON: \r\n");
/*Get local device address*/
CyBle_GetDeviceAddress(&localAddr);
for(i = CYBLE_GAP_BD_ADDR_SIZE; i > 0u; i--)
{
printf("%2.2x", localAddr.bdAddr[i-1]);
}
printf("\r\n");
/*Start to advertise*/
CyBle_GappStartAdvertisement(CYBLE_ADVERTISING_FAST);
break;
case CYBLE_EVT_GAPP_ADVERTISEMENT_START_STOP:
if(CyBle_GetState()==CYBLE_STATE_DISCONNECTED)
{
printf("Advertising stopped\r\n");
}
else if(CyBle_GetState()==CYBLE_STATE_ADVERTISING)
{
printf("Started to Advertise\r\n");
}
break;
case CYBLE_EVT_GAP_DEVICE_CONNECTED:
printf("Device Connected\r\n)");
break;
case CYBLE_EVT_GAP_DEVICE_DISCONNECTED:
disSupport=0;
CyBle_GappStartAdvertisement(CYBLE_ADVERTISING_FAST);
break;
case CYBLE_EVT_GATTC_DISCOVERY_COMPLETE:
printf("\r\n");
printf("Discovery complete.\r\n");
printf("Discovered services: \r\n");
for(i = 0u; i < CYBLE_SRVI_COUNT; i++)
{ /*Check for DIS service*/
if(cyBle_serverInfo[i].uuid == CYBLE_UUID_DEVICE_INFO_SERVICE)
{
if(cyBle_serverInfo[i].range.startHandle < cyBle_serverInfo[i].range.endHandle)
{
printf("Peer device supports Device Information Service \r\n");
disSupport=1;
}
else
{
printf("Peer device doesn't supports Device Information Service \r\n");
}
}
}
printf("\r\n");
break;
default:
break;
}
}
