/******************************************************************************
Function Name: main
*******************************************************************************
Summary:
Main routine of this firmware. Initializes the components once and hanles the
BLE events and UART data in a loop forever.
Parameters:
None.
Return:
None.
******************************************************************************/
int main()
{
/* This start-up delay is for the Android app to open when the locator
* device is plugged into the phone's USB port so that the first printf
* message will not be missed.
*/
CyDelay(3000);
CyGlobalIntEnable;
UART_DEB_Start(); /* Start communication component */
printf("PSoC: BLE Find Me Locator is Connected\r\n");
Disconnect_LED_Write(LED_OFF);
apiResult = CyBle_Start(AppCallBack);
if(apiResult != CYBLE_ERROR_OK)
{
printf("PSoC: CyBle_Start API Error: 0x%x \r\n", apiResult);
}
while(1)
{
/*******************************************************************
* Processes all pending BLE events in the stack
*******************************************************************/
CyBle_ProcessEvents();
/* Process the received UART data */
ProcessUartData();
}
}
/*******************************************************************************
* Function Name: HidsCallBack()
********************************************************************************
*
* Summary:
* This is an event callback function to receive service specific events from
* HID Service.
*
* Parameters:
* event - the event code
* *eventParam - the event parameters
*
* Return:
* None.
*
********************************************************************************/
void HidsCallBack(uint32 event, void *eventParam)
{
CYBLE_HIDS_CHAR_VALUE_T *locEventParam = (CYBLE_HIDS_CHAR_VALUE_T *)eventParam;
DBG_PRINTF("HIDS event: %lx, ", event);
switch(event)
{
case CYBLE_EVT_HIDSS_NOTIFICATION_ENABLED:
DBG_PRINTF("CYBLE_EVT_HIDSS_NOTIFICATION_ENABLED: serv=%x, char=%x\r\n",
locEventParam->serviceIndex,
locEventParam->charIndex);
if(CYBLE_HUMAN_INTERFACE_DEVICE_SERVICE_INDEX == locEventParam->serviceIndex)
{
keyboardSimulation = ENABLED;
}
break;
case CYBLE_EVT_HIDSS_NOTIFICATION_DISABLED:
DBG_PRINTF("CYBLE_EVT_HIDSS_NOTIFICATION_DISABLED: serv=%x, char=%x\r\n",
locEventParam->serviceIndex,
locEventParam->charIndex);
if(CYBLE_HUMAN_INTERFACE_DEVICE_SERVICE_INDEX == locEventParam->serviceIndex)
{
keyboardSimulation = DISABLED;
}
break;
case CYBLE_EVT_HIDSS_BOOT_MODE_ENTER:
DBG_PRINTF("CYBLE_EVT_HIDSS_BOOT_MODE_ENTER \r\n");
protocol = CYBLE_HIDS_PROTOCOL_MODE_BOOT;
break;
case CYBLE_EVT_HIDSS_REPORT_MODE_ENTER:
DBG_PRINTF("CYBLE_EVT_HIDSS_REPORT_MODE_ENTER \r\n");
protocol = CYBLE_HIDS_PROTOCOL_MODE_REPORT;
break;
case CYBLE_EVT_HIDSS_SUSPEND:
DBG_PRINTF("CYBLE_EVT_HIDSS_SUSPEND \r\n");
suspend = CYBLE_HIDS_CP_SUSPEND;
#if (DEBUG_UART_ENABLED == ENABLED)
/* Reduce power consumption, power down logic that is not required to wake up the system */
UART_DEB_Stop();
#endif /* (DEBUG_UART_ENABLED == ENABLED) */
break;
case CYBLE_EVT_HIDSS_EXIT_SUSPEND:
#if (DEBUG_UART_ENABLED == ENABLED)
/* Power up all circuitry previously shut down */
UART_DEB_Start();
#endif /* (DEBUG_UART_ENABLED == ENABLED) */
DBG_PRINTF("CYBLE_EVT_HIDSS_EXIT_SUSPEND \r\n");
suspend = CYBLE_HIDS_CP_EXIT_SUSPEND;
break;
case CYBLE_EVT_HIDSS_REPORT_CHAR_WRITE:
if(CYBLE_HUMAN_INTERFACE_DEVICE_SERVICE_INDEX == locEventParam->serviceIndex)
{
/* Write request to Keyboard Output Report characteristic.
* Handle Boot and Report protocol.
*/
if( ((CYBLE_HIDS_PROTOCOL_MODE_REPORT == protocol) &&
(CYBLE_HUMAN_INTERFACE_DEVICE_REPORT_OUT == locEventParam->charIndex)) ||
((CYBLE_HIDS_PROTOCOL_MODE_BOOT == protocol) &&
(CYBLE_HIDS_BOOT_KYBRD_OUT_REP == locEventParam->charIndex)) )
{
if( (CAPS_LOCK_LED & locEventParam->value->val[0u]) != 0u)
{
CapsLock_LED_Write(LED_ON);
}
else
{
CapsLock_LED_Write(LED_OFF);
}
}
}
DBG_PRINTF("CYBLE_EVT_HIDSS_REPORT_CHAR_WRITE: serv=%x, char=%x, value=",
locEventParam->serviceIndex,
locEventParam->charIndex);
ShowValue(locEventParam->value);
break;
case CYBLE_EVT_HIDSC_NOTIFICATION:
break;
case CYBLE_EVT_HIDSC_READ_CHAR_RESPONSE:
break;
case CYBLE_EVT_HIDSC_WRITE_CHAR_RESPONSE:
break;
case CYBLE_EVT_HIDSC_READ_DESCR_RESPONSE:
break;
case CYBLE_EVT_HIDSC_WRITE_DESCR_RESPONSE:
break;
default:
DBG_PRINTF("Not supported event\r\n");
break;
}
}
*******************************************************************************/int main()
{
CyGlobalIntEnable;
#if (DEBUG_UART_ENABLED == ENABLED)
UART_DEB_Start();
#endif /* (DEBUG_UART_ENABLED == ENABLED) */
DBG_PRINTF("BLE HID Keyboard Example Project \r\n");
LED_RED_Write(LED_OFF);
LED_BLU_Write(LED_OFF);
LED_GRN_Write(LED_OFF);
/* Start CYBLE component and register generic event handler */
CyBle_Start(AppCallBack);
#if (BAS_MEASURE_ENABLE != 0)
ADC_Start();
#endif /* BAS_MEASURE_ENABLE != 0 */
while(1)
{
/* CyBle_ProcessEvents() allows BLE stack to process pending events */
CyBle_ProcessEvents();
/* To achieve low power in the device */
LowPowerImplementation();
if((CyBle_GetState() == CYBLE_STATE_CONNECTED) && (suspend != CYBLE_HIDS_CP_SUSPEND))
{
if(mainTimer != 0u)
{
mainTimer = 0u;
#if (BAS_SIMULATE_ENABLE != 0)
SimulateBattery();
CyBle_ProcessEvents();
#endif /* BAS_SIMULATE_ENABLE != 0 */
#if (BAS_MEASURE_ENABLE != 0)
MeasureBattery();
CyBle_ProcessEvents();
#endif /* BAS_MEASURE_ENABLE != 0 */
if(keyboardSimulation == ENABLED)
{
SimulateKeyboard();
}
}
/* Store bonding data to flash only when all debug information has been sent */
#if(CYBLE_BONDING_REQUIREMENT == CYBLE_BONDING_YES)
#if (DEBUG_UART_ENABLED == ENABLED)
if((cyBle_pendingFlashWrite != 0u) &&
((UART_DEB_SpiUartGetTxBufferSize() + UART_DEB_GET_TX_FIFO_SR_VALID) == 0u))
#else
if(cyBle_pendingFlashWrite != 0u)
#endif /* (DEBUG_UART_ENABLED == ENABLED) */
{
CYBLE_API_RESULT_T apiResult;
apiResult = CyBle_StoreBondingData(0u);
(void)apiResult;
DBG_PRINTF("Store bonding data, status: %x \r\n", apiResult);
}
#endif /* CYBLE_BONDING_REQUIREMENT == CYBLE_BONDING_YES */
}
}
}
int main()
{
CYBLE_LP_MODE_T lpMode;
CYBLE_BLESS_STATE_T blessState;
CYBLE_STACK_LIB_VERSION_T stackVersion;
CyGlobalIntEnable;
UART_DEB_Start(); /* Start communication component */
printf("BLE Heart Rate Collector Example Project \r\n");
Disconnect_LED_Write(LED_OFF);
Scanning_LED_Write(LED_OFF);
Notification_LED_Write(LED_OFF);
apiResult = CyBle_Start(AppCallBack);
if(apiResult != CYBLE_ERROR_OK)
{
printf("CyBle_Start API Error: 0x%x \r\n", apiResult);
}
apiResult = CyBle_GetStackLibraryVersion(&stackVersion);
if(apiResult != CYBLE_ERROR_OK)
{
printf("CyBle_GetStackLibraryVersion API Error: 0x%x \r\n", apiResult);
}
else
{
printf("Stack Version: %d.%d.%d.%d \r\n", stackVersion.majorVersion,
stackVersion.minorVersion, stackVersion.patch, stackVersion.buildNumber);
}
CyBle_BasRegisterAttrCallback(BasCallBack);
HrsInit();
while(1)
{
if(CyBle_GetState() != CYBLE_STATE_INITIALIZING)
{
/* Enter DeepSleep mode between connection intervals */
lpMode = CyBle_EnterLPM(CYBLE_BLESS_DEEPSLEEP);
CyGlobalIntDisable;
blessState = CyBle_GetBleSsState();
if(lpMode == CYBLE_BLESS_DEEPSLEEP)
{
if(blessState == CYBLE_BLESS_STATE_ECO_ON || blessState == CYBLE_BLESS_STATE_DEEPSLEEP)
{
/* Put the device into the DeepSleep mode only when all debug information has been sent */
if((UART_DEB_SpiUartGetTxBufferSize() + UART_DEB_GET_TX_FIFO_SR_VALID) == 0u)
{
CySysPmDeepSleep();
}
else
{
CySysPmSleep();
}
}
}
else
{
if(blessState != CYBLE_BLESS_STATE_EVENT_CLOSE)
{
CySysPmSleep();
}
}
CyGlobalIntEnable;
/* Handle advertising led blinking */
HandleLeds();
}
/* Store bonding data to flash only when all debug information has been sent */
if((cyBle_pendingFlashWrite != 0u) &&
((UART_DEB_SpiUartGetTxBufferSize() + UART_DEB_GET_TX_FIFO_SR_VALID) == 0u))
{
apiResult = CyBle_StoreBondingData(0u);
printf("Store bonding data, status: %x \r\n", apiResult);
}
/*******************************************************************
* Processes all pending BLE events in the stack
*******************************************************************/
CyBle_ProcessEvents();
}
}
/*******************************************************************************
* Function Name: main()
********************************************************************************
* Summary:
* Main function for the project.
*
* Parameters:
* None
*
* Return:
* None
*
* Theory:
* The function starts BLE and UART components.
* This function process all BLE events and also implements the low power
* functionality.
*
*******************************************************************************/
int main()
{
CyGlobalIntEnable;
#if (DEBUG_UART_ENABLED == ENABLED)
UART_DEB_Start();
#endif /* (DEBUG_UART_ENABLED == ENABLED) */
DBG_PRINTF("BLE Cycling Sensor Example Project \r\n");
Disconnect_LED_Write(LED_OFF);
Advertising_LED_Write(LED_OFF);
CyBle_Start(AppCallback);
/* Start CYBLE component and register generic event handler */
CyBle_Start(AppCallback);
/* Register service specific callback functions */
CscsInit();
CpsInit();
WDT_Start();
/***************************************************************************
* Main polling loop
***************************************************************************/
while(1)
{
/* CyBle_ProcessEvents() allows BLE stack to process pending events */
CyBle_ProcessEvents();
/* To achieve low power in the device */
LowPowerImplementation();
/***********************************************************************
* Wait for connection established with Central device
***********************************************************************/
if(CyBle_GetState() == CYBLE_STATE_CONNECTED)
{
/*******************************************************************
* Periodically simulate Cycling characteristics and send
* results to the Client
*******************************************************************/
if(mainTimer != 0u)
{
mainTimer = 0u;
SimulateCyclingPower();
CyBle_ProcessEvents();
SimulateCyclingSpeed();
}
/* Store bounding data to flash only when all debug information has been sent */
#if (DEBUG_UART_ENABLED == ENABLED)
if((cyBle_pendingFlashWrite != 0u) &&
((UART_DEB_SpiUartGetTxBufferSize() + UART_DEB_GET_TX_FIFO_SR_VALID) == 0u))
#else
if(cyBle_pendingFlashWrite != 0u)
#endif /* (DEBUG_UART_ENABLED == ENABLED) */
{
CYBLE_API_RESULT_T apiResult;
apiResult = CyBle_StoreBondingData(0u);
(void)apiResult;
DBG_PRINTF("Store bonding data, status: %x \r\n", apiResult);
}
}
}
}
int main()
{
CyGlobalIntEnable;
SCB_Start();
UART_DEB_Start();
DBG_PRINTF("BLE HID Keyboard Example Project \r\n");
LED_RED_Write(LED_OFF);
LED_GRN_Write(LED_OFF);
LED_BLU_Write(LED_OFF);
/* Start CYBLE component and register generic event handler */
CyBle_Start(AppCallBack);
Sup_Pdu_t i2c_inbox;
while(1)
{
SCB_I2CMasterClearStatus();
/* CyBle_ProcessEvents() allows BLE stack to process pending events */
CyBle_ProcessEvents();
/*
uint8_t buf;
uint32_t result = SCB_I2CMasterReadBuf(8, &buf, 1, SCB_I2C_MODE_COMPLETE_XFER);
if (0 == (result & SCB_I2C_MSTR_NOT_READY)) {
uint32_t cnt = 100;
while (--cnt && 0 == (SCB_I2CMasterStatus() & SCB_I2C_MSTAT_RD_CMPLT)) {}
if (!cnt) {
uint32_t tmp = SCB_I2CMasterStatus();
DBG_PRINTF("stuck in I2C RX: %d\r\n", tmp);
} else {
if (0 == (SCB_I2CMasterStatus() & SCB_I2C_MSTAT_ERR_MASK) && buf != 0xff) {
i2c_inbox.command = buf;
result = SCB_I2C_MSTR_NOT_READY;
while (result & SCB_I2C_MSTR_NOT_READY) {
result = SCB_I2CMasterReadBuf(8, &buf, 1, SCB_I2C_MODE_COMPLETE_XFER);
}
while (0 == (SCB_I2CMasterStatus() & SCB_I2C_MSTAT_RD_CMPLT)) {}
if (0 == (SCB_I2CMasterStatus() & SCB_I2C_MSTAT_ERR_MASK)) {
i2c_inbox.data = buf;
process_inbox(&i2c_inbox);
}
}
}
}
*/
/* To achieve low power in the device */
LowPowerImplementation();
if((CyBle_GetState() == CYBLE_STATE_CONNECTED) && (suspend != CYBLE_HIDS_CP_SUSPEND))
{
if(mainTimer != 0u)
{
mainTimer = 0u;
}
/* Store bonding data to flash only when all debug information has been sent */
#if(CYBLE_BONDING_REQUIREMENT == CYBLE_BONDING_YES)
#if (DEBUG_UART_ENABLED == ENABLED)
if((cyBle_pendingFlashWrite != 0u) &&
((UART_DEB_SpiUartGetTxBufferSize() + UART_DEB_GET_TX_FIFO_SR_VALID) == 0u))
#else
if(cyBle_pendingFlashWrite != 0u)
#endif /* (DEBUG_UART_ENABLED == ENABLED) */
{
CYBLE_API_RESULT_T apiResult;
apiResult = CyBle_StoreBondingData(0u);
(void)apiResult;
DBG_PRINTF("Store bonding data, status: %x \r\n", apiResult);
}
#endif /* CYBLE_BONDING_REQUIREMENT == CYBLE_BONDING_YES */
}
}
}
int main()
{
CYBLE_STACK_LIB_VERSION_T stackVersion;
CyGlobalIntEnable;
UART_DEB_Start(); /* Start communication component */
printf("BLE Heart Rate Sensor Example Project \r\n");
Disconnect_LED_Write(LED_OFF);
Advertising_LED_Write(LED_OFF);
/* Start CYBLE component and register generic event handler */
apiResult = CyBle_Start(AppCallBack);
if(apiResult != CYBLE_ERROR_OK)
{
printf("CyBle_Start API Error: %x \r\n", apiResult);
}
apiResult = CyBle_GetStackLibraryVersion(&stackVersion);
if(apiResult != CYBLE_ERROR_OK)
{
printf("CyBle_GetStackLibraryVersion API Error: 0x%x \r\n", apiResult);
}
else
{
printf("Stack Version: %d.%d.%d.%d \r\n", stackVersion.majorVersion,
stackVersion.minorVersion, stackVersion.patch, stackVersion.buildNumber);
}
/* Services initialization */
HrsInit();
WDT_Start();
/***************************************************************************
* Main polling loop
***************************************************************************/
while(1)
{
/***********************************************************************
* Wait for connection established with Central device
***********************************************************************/
if(CyBle_GetState() == CYBLE_STATE_CONNECTED)
{
/*******************************************************************
* Periodically simulate heart rate and measure a battery level
* and send results to the Client
*******************************************************************/
if(mainTimer != 0u)
{
mainTimer = 0u;
if(heartRateSimulation == ENABLED)
{
SimulateHeartRate();
}
}
}
/*******************************************************************
* Process all pending BLE events in the stack
*******************************************************************/
CyBle_ProcessEvents();
}
}
int main()
{
CYBLE_LP_MODE_T lpMode;
CYBLE_BLESS_STATE_T blessState;
CyGlobalIntEnable;
UART_DEB_Start(); /* Start communication component */
printf("BLE Secure Connection Example Project \r\n");
Disconnect_LED_Write(LED_OFF);
Advertising_LED_Write(LED_OFF);
/* Start CYBLE component and register generic event handler */
apiResult = CyBle_Start(AppCallBack);
if(apiResult != CYBLE_ERROR_OK)
{
printf("CyBle_Start API Error: %x \r\n", apiResult);
}
/* Services initialization */
HrsInit();
/***************************************************************************
* Main polling loop
***************************************************************************/
while(1)
{
if(CyBle_GetState() != CYBLE_STATE_INITIALIZING)
{
/* Enter DeepSleep mode between connection intervals */
lpMode = CyBle_EnterLPM(CYBLE_BLESS_DEEPSLEEP);
CyGlobalIntDisable;
blessState = CyBle_GetBleSsState();
if(lpMode == CYBLE_BLESS_DEEPSLEEP)
{
if(blessState == CYBLE_BLESS_STATE_ECO_ON || blessState == CYBLE_BLESS_STATE_DEEPSLEEP)
{
/* Put the device into the Deep Sleep mode only when all debug information has been sent */
if((UART_DEB_SpiUartGetTxBufferSize() + UART_DEB_GET_TX_FIFO_SR_VALID) == 0u)
{
CySysPmDeepSleep();
}
else
{
CySysPmSleep();
}
}
}
else
{
if(blessState != CYBLE_BLESS_STATE_EVENT_CLOSE)
{
CySysPmSleep();
}
}
CyGlobalIntEnable;
}
/***********************************************************************
* Wait for connection established with Central device
***********************************************************************/
if(CyBle_GetState() == CYBLE_STATE_CONNECTED)
{
/*******************************************************************
* Periodically simulates heart beat and sends the results to the Client
*******************************************************************/
mainTimer++;
if(mainTimer == MAIN_LOOP_SIMULATION_THRESHOLD)
{
mainTimer = 0u;
if(heartRateSimulation == ENABLED)
{
SimulateHeartRate();
CyBle_ProcessEvents();
}
}
else if((cyBle_pendingFlashWrite != 0u) &&
((UART_DEB_SpiUartGetTxBufferSize() + UART_DEB_GET_TX_FIFO_SR_VALID) == 0u))
{
apiResult = CyBle_StoreBondingData(0u);
printf("Store bonding data, status: %x \r\n", apiResult);
}
else
{
/* nothing else */
}
}
/*******************************************************************
* Process all pending BLE events in the stack
*******************************************************************/
CyBle_ProcessEvents();
}
}
