/***************************************************************************** * File Name: main.c * * Version: 1.0 * * Description: * This is the top level file for the PSoC 4 BLE Lab 3. * * Hardware Dependency: * CY8CKIT-042 BLE Pioneer Kit * ****************************************************************************** * Copyright (2014), Cypress Semiconductor Corporation. ****************************************************************************** * This software is owned by Cypress Semiconductor Corporation (Cypress) and is * protected by and subject to worldwide patent protection (United States and * foreign), United States copyright laws and international treaty provisions. * Cypress hereby grants to licensee a personal, non-exclusive, non-transferable * license to copy, use, modify, create derivative works of, and compile the * Cypress Source Code and derivative works for the sole purpose of creating * custom software in support of licensee product to be used only in conjunction * with a Cypress integrated circuit as specified in the applicable agreement. * Any reproduction, modification, translation, compilation, or representation of * this software except as specified above is prohibited without the express * written permission of Cypress. * * Disclaimer: CYPRESS MAKES NO WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, WITH * REGARD TO THIS MATERIAL, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. * Cypress reserves the right to make changes without further notice to the * materials described herein. Cypress does not assume any liability arising out * of the application or use of any product or circuit described herein. Cypress * does not authorize its products for use as critical components in life-support * systems where a malfunction or failure may reasonably be expected to result in * significant injury to the user. The inclusion of Cypress' product in a life- * support systems application implies that the manufacturer assumes all risk of * such use and in doing so indemnifies Cypress against all charges. Use may be * limited by and subject to the applicable Cypress software license agreement. *****************************************************************************/ /***************************************************************************** * Included headers *****************************************************************************/ #include #include #include "main.h" #include "HeartRateProcessing.h" #include "BleProcessing.h" #include "WatchdogTimer.h" /***************************************************************************** * Macros *****************************************************************************/ #if CONNECTION_PARAM_UPDATE #define TIME_SINCE_CONNECTED_MS (5000) #endif /***************************************************************************** * Global variables *****************************************************************************/ #if CONNECTION_PARAM_UPDATE static CYBLE_GAP_CONN_UPDATE_PARAM_T hrmConnectionParam = { 16, /* Minimum connection interval of 20 ms */ 16, /* Maximum connection interval of 20 ms */ 49, /* Slave latency of 49 */ 500 /* Supervision timeout of 5 seconds */ }; #endif #if SENSOR_LOCATION BODY_SENSOR_LOCATION hrmSensorLocation = EAR_LOBE; #endif /***************************************************************************** * Static function definitions *****************************************************************************/ /***************************************************************************** * Function Name: InitializeSystem ****************************************************************************** * Summary: * Initializes all the blocks of the system. * * Parameters: * None * * Return: * None * * Theory: * The function enables the Opamp and ADC for the heart rate measurement, and * setups the BLE component. It also starts the watchdog timer and ensures that * all the status LEDs are off at system startup. * * Side Effects: * None * *****************************************************************************/ static void InitializeSystem(void) { #if (RGB_LED_IN_PROJECT) /* Turn off all LEDs */ Led_Advertising_Green_Write(1); Led_Connected_Blue_Write(1); #endif /* #if (RGB_LED_IN_PROJECT) */ /* Enabling Global interrupts */ CyGlobalIntEnable; /* Start Opamp and ADC components */ Opamp_Start(); ADC_Start(); /* Start BLE component */ CyBle_Start(GeneralEventHandler); /* Register the Heart Rate Service event handler callback. The function * to be registered is HrsEventHandler(). */ CyBle_HrsRegisterAttrCallback(HrsEventHandler); #if SENSOR_LOCATION /* Update Body Sensor Location Characteristic with new sensor location */ CyBle_HrssSetCharacteristicValue(CYBLE_HRS_BSL, sizeof(hrmSensorLocation), (uint8*)(&hrmSensorLocation)); #endif /* Start the Watchdog Timer */ WatchdogTimer_Start(); } /***************************************************************************** * Public function definitions *****************************************************************************/ /***************************************************************************** * Function Name: main ****************************************************************************** * Summary: * The main function for the project. * * Parameters: * None * * Return: * None * * Theory: * The main function first calls the initialization function to start the * system, and then enters a loop to run forever. In the main loop, it scans * the heart rate first, then sends a notification packet every second to a * BLE connected device. It then enters low power (deep sleep) state, waiting * for the periodic wakeup interrupt from watchdog timer. * When the device is disconnected or when advertisement timeout happens, * the device enters Hibernate mode, waiting for the SW2 switch press to wakeup. * * Side Effects: * None * *****************************************************************************/ int main() { static uint32 previousTimestamp = 0; static uint32 currentTimestamp = 0; CYBLE_LP_MODE_T bleMode; uint8 interruptStatus; /* Initialize all blocks of the system */ InitializeSystem(); /* Run forever */ for(;;) { /* Wake up Opamp from low power mode */ /* This API has not effect when Opamp is operating in deep sleep mode */ Opamp_Wakeup(); /* Wake up ADC from low power mode */ ADC_Wakeup(); /* Analog Front End. * Detects the input signal and measures Heart Rate */ ProcessHeartRateSignal(); /* Put ADC in low power mode */ ADC_Sleep(); /* Put Opamp in low power mode */ /* This API has not effect when Opamp is operating in deep sleep mode */ Opamp_Sleep(); /* Measure the current system timestamp from watchdog timer */ currentTimestamp = WatchdogTimer_GetTimestamp(); #if CONNECTION_PARAM_UPDATE /* Update BLE connection parameters a few seconds after connection */ if((CyBle_GetState() == CYBLE_STATE_CONNECTED) && (connParamRequestState == CONN_PARAM_REQUEST_NOT_SENT)) { if((currentTimestamp - timestampWhenConnected) > TIME_SINCE_CONNECTED_MS) { CyBle_L2capLeConnectionParamUpdateRequest(cyBle_connHandle.bdHandle, &hrmConnectionParam); connParamRequestState = CONN_PARAM_REQUEST_SENT; } } #endif /* Send Heart Rate notification over BLE every second. * Check if the current timestamp minus previous exceeds 1000 ms. */ if((currentTimestamp - previousTimestamp) >= 1000) { /* Call API defined in BleProcessing.c to send * notification over BLE. */ SendHeartRateOverBLE(); /* Update the previous timestamp with the current timestamp. */ previousTimestamp = currentTimestamp; } /* Try to stay in low power mode until the next watchdog interrupt */ while(WatchdogTimer_GetTimestamp() == currentTimestamp) { /* Process any pending BLE events */ CyBle_ProcessEvents(); /* The idea of low power operation is to first request the BLE * block go to Deep Sleep, and then check whether it actually * entered Deep Sleep. This is important because the BLE block * runs asynchronous to the rest of the application and thus * could be busy/idle independent of the application state. * * Once the BLE block is in Deep Sleep, only then the system * can enter Deep Sleep. This is important to maintain the BLE * connection alive while being in Deep Sleep. */ /* Request the BLE block to enter Deep Sleep */ bleMode = CyBle_EnterLPM(CYBLE_BLESS_DEEPSLEEP); /* Check if the BLE block entered Deep Sleep and if so, then the * system can enter Deep Sleep. This is done inside a Critical * Section (where global interrupts are disabled) to avoid a * race condition between application main (that wants to go to * Deep Sleep) and other interrupts (which keep the device from * going to Deep Sleep). */ interruptStatus = CyEnterCriticalSection(); /* Check if the BLE block entered Deep Sleep */ if(CYBLE_BLESS_DEEPSLEEP == bleMode) { /* Check the current state of BLE - System can enter Deep Sleep * only when the BLE block is starting the ECO (during * pre-processing for a new connection event) or when it is * idle. */ if((CyBle_GetBleSsState() == CYBLE_BLESS_STATE_ECO_ON) || (CyBle_GetBleSsState() == CYBLE_BLESS_STATE_DEEPSLEEP)) { CySysPmDeepSleep(); } } /* The else condition signifies that the BLE block cannot enter * Deep Sleep and is in Active mode. */ else { /* At this point, the CPU can enter Sleep, but Deep Sleep is not * allowed. * There is one exception - at a connection event, when the BLE * Rx/Tx has just finished, and the post processing for the * connection event is ongoing, the CPU cannot go to sleep. * The CPU should wait in Active mode until the post processing * is complete while continuously polling the BLE low power * entry. As soon as post processing is complete, the BLE block * would enter Deep Sleep (because of the polling) and the * system Deep Sleep would then be entered. Deep Sleep is the * preferred low power mode since it takes much lesser current. */ if(CyBle_GetBleSsState() != CYBLE_BLESS_STATE_EVENT_CLOSE) { CySysPmSleep(); } } /* Exit Critical section - Global interrupts are enabled again */ CyExitCriticalSection(interruptStatus); } /* Hibernate entry point - Hibernate is entered upon a BLE disconnect * event or advertisement timeout. Wakeup happens via SW2 switch press, * upon which the execution starts from the first line of code. * The I/O state, RAM and UDBs are retained during Hibernate. */ if(enterHibernateFlag) { /* Stop the BLE component */ CyBle_Stop(); /* Enable the Hibernate wakeup functionality */ SW2_Switch_ClearInterrupt(); Wakeup_ISR_Start(); #if (RGB_LED_IN_PROJECT) /* Turn off Green and Blue LEDs to indicate Hibernate */ Led_Advertising_Green_Write(1); Led_Connected_Blue_Write(1); /* Change the GPIO state to High-Z */ Led_Advertising_Green_SetDriveMode(Led_Advertising_Green_DM_ALG_HIZ); Led_Connected_Blue_SetDriveMode(Led_Connected_Blue_DM_ALG_HIZ); #endif /* #if (RGB_LED_IN_PROJECT) */ /* Enter hibernate mode */ CySysPmHibernate(); } } } /* [] END OF FILE */