diff options
Diffstat (limited to 'Projects/P-NUCLEO-WB55.USBDongle/Applications/BLE/BLE_MeshLightingPRFNode/STM32_WPAN/app/appli_sensor.c')
| -rw-r--r-- | Projects/P-NUCLEO-WB55.USBDongle/Applications/BLE/BLE_MeshLightingPRFNode/STM32_WPAN/app/appli_sensor.c | 1495 |
1 files changed, 812 insertions, 683 deletions
diff --git a/Projects/P-NUCLEO-WB55.USBDongle/Applications/BLE/BLE_MeshLightingPRFNode/STM32_WPAN/app/appli_sensor.c b/Projects/P-NUCLEO-WB55.USBDongle/Applications/BLE/BLE_MeshLightingPRFNode/STM32_WPAN/app/appli_sensor.c index 7c164b49e..c6bed93c0 100644 --- a/Projects/P-NUCLEO-WB55.USBDongle/Applications/BLE/BLE_MeshLightingPRFNode/STM32_WPAN/app/appli_sensor.c +++ b/Projects/P-NUCLEO-WB55.USBDongle/Applications/BLE/BLE_MeshLightingPRFNode/STM32_WPAN/app/appli_sensor.c @@ -6,7 +6,7 @@ ****************************************************************************** * @attention * - * <h2><center>© Copyright (c) 2019 STMicroelectronics. + * <h2><center>© Copyright (c) 2020 STMicroelectronics. * All rights reserved.</center></h2> * * This software component is licensed by ST under Ultimate Liberty license @@ -21,9 +21,10 @@ #include "hal_common.h" #include "types.h" +#include "sensor_cfg_usr.h" #include "sensors.h" -#include "light_lc.h" #include "appli_sensor.h" +#include "appli_light_lc.h" #include "mesh_cfg.h" //#include "LPS25HB.h" #include "string.h" @@ -38,13 +39,49 @@ * @{ */ -/* Private typedef -----------------------------------------------------------*/ -/* Private define ------------------------------------------------------------*/ +MOBLE_RESULT Appli_Sensor_ValueSet(MOBLEUINT8 sensorOffset, + MOBLEUINT32 value); + +/* Private variables ---------------------------------------------------------*/ + +/* ALIGN(4) */ +__attribute__((aligned(4)))const sensor_server_init_params_t SensorServerInitParams = SENSOR_SERVER_INIT_PARAMS; + +/* ALIGN(4) */ +__attribute__((aligned(4)))const sensor_server_cb_t AppliSensor_cb = +{ + /* Sensor Model callbacks */ + Appli_Sensor_CadenceGet, + Appli_Sensor_CadenceSet, + Appli_Sensor_CadenceSetUnack, + Appli_Sensor_SettingsGet, + Appli_Sensor_SettingGet, + Appli_Sensor_SettingSet, + Appli_Sensor_SettingSetUnack, + Appli_Sensor_DescriptorGet, + Appli_Sensor_Get, + Appli_Sensor_ColumnGet, + Appli_Sensor_SeriesGet, + Appli_Sensor_ReadDescriptor, + Appli_Sensor_ReadValue, + Appli_Sensor_ReadColumn, + Appli_Sensor_ReadSeries, + Appli_Sensor_IsFastCadence, + Appli_Sensor_IsStatusTrigger, + Appli_Sensor_Descriptor_Status, + Appli_Sensor_Cadence_Status, + Appli_Sensor_Settings_Status, + Appli_Sensor_Setting_Status, + Appli_Sensor_Status, + Appli_Sensor_Column_Status, + Appli_Sensor_Series_Status +}; + #if 0 /** -* @brief PRESSURE init structure definition -*/ -PRESSURE_InitTypeDef InitStructure = + * @brief Pressure sensor init + */ +__attribute__((aligned(4)))const PRESSURE_InitTypeDef Lps25InitParams = { LPS25HB_ODR_1Hz, LPS25HB_BDU_READ, @@ -55,44 +92,19 @@ PRESSURE_InitTypeDef InitStructure = }; #endif -/* Application variables of sensor model definition */ -#ifdef ENABLE_SENSOR_MODEL_SERVER - -Appli_Sensor_DescriptorStatus_t Appli_Sensor_DescriptorStatus; -Appli_Sensor_SettingSet_t Appli_Sensor_SettingSet[3]; - -/* By Default value used for cadence set for testing. */ -Sensor_CadenceSet_t Sensor_CadenceSet[NUMBER_OF_SENSOR]; - -/* -{ - {0x0071 , 0x2 , 2 , 2 ,2 ,1 ,0X05 , 0x64}, - {0x2A6D , 0x2 , 1 , 1 , 1, 1, 0X258 , 0x3ED}, - {0X2A7F ,0x2,1,1,1,0,0x10, 0x20} -};*/ - - -#endif - -MODEL_Property_IDTableParam_t Property_ID_Table[NUMBER_OF_SENSOR] = -{ - {TEMPERATURE_PID}, - {PRESSURE_PID}, - {TIME_OF_FLIGHT_PID} -}; +/** + * @brief Variables for people + */ +MOBLEUINT8 AppliSensorReadFromSensor = 0; /* Used for PTS testing */ +MOBLEUINT8 PresentTemperatureValue = 0; +MOBLEUINT8 PreviousTemperatureValue = 0; MOBLEUINT8 Occupancy_Flag = MOBLE_FALSE; extern MOBLEUINT8 NumberOfElements; extern MOBLEUINT8 ProvisionFlag; MOBLEUINT8 Sensor_Setting_Access = 0x01 ; +MOBLEUINT32 PresentPeopleCount = 0; +MOBLEUINT32 PreviousPeopleCount = 0; - - -/* Temperature and Pressure init structure*/ -#if 0 - PRESSURE_DrvTypeDef* xLPS25HBDrv = &LPS25HBDrv; -#endif - -/* Private function prototypes -----------------------------------------------*/ /* Private functions ---------------------------------------------------------*/ /******************************************************************************/ @@ -101,792 +113,909 @@ MOBLEUINT8 Sensor_Setting_Access = 0x01 ; /** -* @brief Appli_Sensor_Cadence_Set: This function is callback for Application -* when sensor cadence Set message is received -* @param pCadence_param: Pointer to the parameters received for message -* @param property_ID: Property is of sensor coming in data packet -* @param length: Received data length. -* @retval MOBLE_RESULT + * @brief Callback corresponding to Sensor_CadenceGet_cb + * @param Cadence parameters +* @retval None */ -MOBLE_RESULT Appli_Sensor_Cadence_Set(Sensor_CadenceParam_t* pCadence_param, - MOBLEUINT16 property_ID, - MOBLEUINT32 length) -{ - if(property_ID == (MOBLEUINT16)TEMPERATURE_PID) - { - Sensor_CadenceSet[0].Property_ID = pCadence_param->Property_ID; - Sensor_CadenceSet[0].FastCadenceDevisor = pCadence_param->FastCadenceDevisor ; - Sensor_CadenceSet[0].StatusTriggerType = pCadence_param->StatusTriggerType ; - Sensor_CadenceSet[0].triggerDeltaDown = pCadence_param->triggerDeltaDown; - Sensor_CadenceSet[0].triggerDeltaUp = pCadence_param->triggerDeltaUp; - Sensor_CadenceSet[0].StatusMinInterval = pCadence_param->StatusMinInterval; - Sensor_CadenceSet[0].FastCadenceLow = pCadence_param->FastCadenceLow; - Sensor_CadenceSet[0].FastCadenceHigh = pCadence_param->FastCadenceHigh; - } - else if(property_ID == (MOBLEUINT16)PRESSURE_PID) - { - Sensor_CadenceSet[1].Property_ID = pCadence_param->Property_ID; - Sensor_CadenceSet[1].FastCadenceDevisor = pCadence_param->FastCadenceDevisor ; - Sensor_CadenceSet[1].StatusTriggerType = pCadence_param->StatusTriggerType ; - Sensor_CadenceSet[1].triggerDeltaDown = pCadence_param->triggerDeltaDown; - Sensor_CadenceSet[1].triggerDeltaUp = pCadence_param->triggerDeltaUp; - Sensor_CadenceSet[1].StatusMinInterval = pCadence_param->StatusMinInterval; - Sensor_CadenceSet[1].FastCadenceLow = pCadence_param->FastCadenceLow; - Sensor_CadenceSet[1].FastCadenceHigh = pCadence_param->FastCadenceHigh; - } - - else if( property_ID == (MOBLEUINT16) TIME_OF_FLIGHT_PID) - { - Sensor_CadenceSet[2].Property_ID = pCadence_param->Property_ID; - Sensor_CadenceSet[2].FastCadenceDevisor = pCadence_param->FastCadenceDevisor ; - Sensor_CadenceSet[2].StatusTriggerType = pCadence_param->StatusTriggerType ; - Sensor_CadenceSet[2].triggerDeltaDown = pCadence_param->triggerDeltaDown; - Sensor_CadenceSet[2].triggerDeltaUp = pCadence_param->triggerDeltaUp; - Sensor_CadenceSet[2].StatusMinInterval = pCadence_param->StatusMinInterval; - Sensor_CadenceSet[2].FastCadenceLow = pCadence_param->FastCadenceLow; - Sensor_CadenceSet[2].FastCadenceHigh = pCadence_param->FastCadenceHigh; - } - - return MOBLE_RESULT_SUCCESS; +void Appli_Sensor_CadenceGet(sensor_CadenceCbParam_t* pCadenceParam, + MOBLEUINT32 length, + MOBLE_ADDRESS peerAddr, + MOBLE_ADDRESS dstPeer, + MOBLEUINT8 elementIndex) +{ + TRACE_M(TF_SENSOR, "Property ID %X element index %X peer addr %X dst peer %X\r\n", + pCadenceParam->property_ID, elementIndex, peerAddr, dstPeer); } + /** -* @brief Appli_Sensor_Cadence_Get: This function is callback for Application -* when sensor cadence Set message is received -* @param pCadence_get: Pointer to the parameters received for message -* @param property_ID: Property is of sensor coming in data packet -* @param length: Received data length. -* @retval MOBLE_RESULT + * @brief Callback corresponding to Sensor_CadenceSet_cb + * @param Cadence parameters +* @retval None */ - -MOBLE_RESULT Appli_Sensor_Cadence_Get(MOBLEUINT8* sensor_DataCadence, - MOBLEUINT16 property_ID, MOBLEUINT32 length) +void Appli_Sensor_CadenceSet(sensor_CadenceCbParam_t* pCadenceParam, + MOBLEUINT32 length, + MOBLE_ADDRESS peerAddr, + MOBLE_ADDRESS dstPeer, + MOBLEUINT8 elementIndex) { - return MOBLE_RESULT_SUCCESS; + TRACE_M(TF_SENSOR, "Property ID %X element index %X peer addr %X dst peer %X\r\n", + pCadenceParam->property_ID, elementIndex, peerAddr, dstPeer); } -/** -* @brief Appli_Sensor_Setting_Set: This function is callback for Application -* when sensor setting Set message is received -* @param pSensor_SettingParam: Pointer to the parameters received for message -* @param OptionalValid: Flag to inform about the validity of optional parameters -* @retval MOBLE_RESULT -*/ -MOBLE_RESULT Appli_Sensor_Setting_Set(Sensor_SettingParam_t* pSensor_SettingParam, - MOBLEUINT8 OptionalValid,MOBLEUINT16 prop_ID) -{ - - for(int i=0;i< NUMBER_OF_SENSOR;i++) - { - if(prop_ID == Property_ID_Table[i].Property_ID) - { - Appli_Sensor_SettingSet[i].Property_ID = pSensor_SettingParam->Property_ID; - - Appli_Sensor_SettingSet[i].Sensor_Setting_ID = pSensor_SettingParam->Sensor_Setting_ID; - Appli_Sensor_SettingSet[i].Sensor_Setting_Access = Sensor_Setting_Access; - Appli_Sensor_SettingSet[i].Sensor_Setting_Value = pSensor_SettingParam->Sensor_Setting_Value; - } - } - return MOBLE_RESULT_SUCCESS; +/** + * @brief Callback corresponding to Sensor_CadenceSetUnack_cb + * @param Cadence parameters +* @retval None +*/ +void Appli_Sensor_CadenceSetUnack(sensor_CadenceCbParam_t* pCadenceParam, + MOBLEUINT32 length, + MOBLE_ADDRESS peerAddr, + MOBLE_ADDRESS dstPeer, + MOBLEUINT8 elementIndex) +{ + TRACE_M(TF_SENSOR, "Property ID %X element index %X peer addr %X dst peer %X\r\n", + pCadenceParam->property_ID, elementIndex, peerAddr, dstPeer); } - /** -* @brief Appli_Sensor_Data_Status: This function is callback for Application -* when Sensor Get message is received -* @param sensor_Data: Pointer to buffer to be updated with parameters -* @param pLength: Length of the parameters to be sent in response -* @param prop_ID: Property Id of requested sensor (optional) -* @param length: Received data length -* @retval MOBLE_RESULT + * @brief Callback corresponding to Sensor_SettingsGet_cb + * @param Setting parameters +* @retval None */ -MOBLE_RESULT Appli_Sensor_Data_Status(MOBLEUINT8* sensor_Data , - MOBLEUINT32* pLength, - MOBLEUINT16 prop_ID , - MOBLEUINT32 length) +void Appli_Sensor_SettingsGet(sensor_SettingsCbParams_t* pSettingParam, + MOBLEUINT32 length, + MOBLE_ADDRESS peerAddr, + MOBLE_ADDRESS dstPeer, + MOBLEUINT8 elementIndex) { - MOBLE_RESULT result = MOBLE_RESULT_FALSE; - MOBLEUINT32 temperatureData = 0; - MOBLEUINT32 pressureData = 0; - MOBLEUINT8 data_Length = 0x03; - MOBLEUINT32 distance = 0x000000C8; // 200 cm - MOBLEUINT8 data_Length_UnknownID; + TRACE_M(TF_SENSOR, "Property ID %X element index %X peer addr %X dst peer %X\r\n", + pSettingParam->propertyId, elementIndex, peerAddr, dstPeer); +} -#if 0 - LPS25HB_GetTemperature((float*)&temperatureData); - - LPS25HB_GetPressure((float*)&pressureData); -#endif - - result = Check_Property_ID(Property_ID_Table , prop_ID); - - if(result == MOBLE_RESULT_SUCCESS && length > 0) - { - if((prop_ID == TEMPERATURE_PID )) /* format A */ - { - /*(prop_Id_Temp & 0x07) << 5) | (Len <<1) Format A - Property calculation is done like above line - */ - *(sensor_Data) = ((TEMPERATURE_PID & 0x07) << 5) | (data_Length <<1) ; - *(sensor_Data+1) = (TEMPERATURE_PID >> 3) & 0xFF; - - memcpy(&sensor_Data[2],(void*)&temperatureData,4); - - *pLength =6; - } - else if((prop_ID == PRESSURE_PID)) - { - /* Format B for Pressure sensor */ - *(sensor_Data+0) = ((data_Length <<1) | 0x01); - *(sensor_Data+1) = (MOBLEUINT8)PRESSURE_PID ; - *(sensor_Data+2) = (MOBLEUINT8)(PRESSURE_PID >> 8); - - memcpy(&sensor_Data[3],(void*)&pressureData,4); - - *pLength =7; - } - else if((prop_ID == TIME_OF_FLIGHT_PID)) - { - /* Format B for Pressure sensor */ - *(sensor_Data+0) = ((data_Length <<1) | 0x01); - *(sensor_Data+1) = (MOBLEUINT8)TIME_OF_FLIGHT_PID ; - *(sensor_Data+2) = (MOBLEUINT8)(TIME_OF_FLIGHT_PID >> 8); - - memcpy(&sensor_Data[3],(void*)&distance,4); - - *pLength =7; - } - } - else - { - if(length == 0) - { - /*(prop_Id_Temp & 0x07) << 5) | (Len <<1) Format A - Property calculation is done like above line +/** + * @brief Callback corresponding to Sensor_SettingGet_cb + * @param Setting parameters +* @retval None */ - *(sensor_Data) = ((TEMPERATURE_PID & 0x07) << 5) | (data_Length <<1) ; - *(sensor_Data+1) = (TEMPERATURE_PID >> 3) & 0xFF; - - memcpy(&sensor_Data[2],(void*)&temperatureData,4); - - /* Format B for Pressure sensor */ - *(sensor_Data+6) = ((data_Length <<1) | 0x01); - *(sensor_Data+7) = (MOBLEUINT8)PRESSURE_PID ; - *(sensor_Data+8) = (MOBLEUINT8)(PRESSURE_PID >> 8); - - memcpy(&sensor_Data[9],(void*)&pressureData,4); - - /* Format B for Pressure sensor */ - *(sensor_Data+13) = ((data_Length <<1) | 0x01); - *(sensor_Data+14) = (MOBLEUINT8)TIME_OF_FLIGHT_PID ; - *(sensor_Data+15) = (MOBLEUINT8)(TIME_OF_FLIGHT_PID >> 8); - - memcpy(&sensor_Data[16],(void*)&distance,4); +void Appli_Sensor_SettingGet(sensor_SettingCbParams_t* pSettingParam, + MOBLEUINT32 length, + MOBLE_ADDRESS peerAddr, + MOBLE_ADDRESS dstPeer, + MOBLEUINT8 elementIndex) +{ + TRACE_M(TF_SENSOR, "Property ID %X element index %X peer addr %X dst peer %X\r\n", + pSettingParam->property_ID, elementIndex, peerAddr, dstPeer); +} - *pLength =20; - } - else - { -// *(sensor_Data+0) = (MOBLEUINT8)prop_ID ; -// *(sensor_Data+1) = (MOBLEUINT8)(prop_ID >> 8); -// -// *pLength =2; - - data_Length_UnknownID = 0x0F; - if(prop_ID < 0x0800) - { - *(sensor_Data) = ((prop_ID & 0x07) << 5) | (data_Length_UnknownID << 1) ; - *(sensor_Data+1) = (prop_ID >> 3) & 0xFF; - - *pLength=2; - } - else - { - *(sensor_Data+0) = 0xFF; //((data_Length <<1) | 0x01) & 0x00; - *(sensor_Data+1) = (MOBLEUINT8)prop_ID ; - *(sensor_Data+2) = (MOBLEUINT8)(prop_ID >> 8); +/** + * @brief Callback corresponding to Sensor_SettingSet_cb + * @param Setting parameters +* @retval None +*/ +void Appli_Sensor_SettingSet(sensor_SettingCbParams_t* pSettingParam, + MOBLEUINT32 length, + MOBLE_ADDRESS peerAddr, + MOBLE_ADDRESS dstPeer, + MOBLEUINT8 elementIndex) +{ + TRACE_M(TF_SENSOR, "Property ID %X element index %X peer addr %X dst peer %X\r\n", + pSettingParam->property_ID, elementIndex, peerAddr, dstPeer); +} - *pLength = 3; - } - } - //*plength=0; - } - - TRACE_M(TF_SENSOR,"the temperature reading from sender in hex 0x%08lx \n\r ", temperatureData); - TRACE_M(TF_SENSOR,"the pressure reading from sender in hex 0x%08lx \n\r", pressureData ); - return MOBLE_RESULT_SUCCESS; +/** + * @brief Callback corresponding to Sensor_SettingSetUnack_cb + * @param Setting parameters +* @retval None +*/ +void Appli_Sensor_SettingSetUnack(sensor_SettingCbParams_t* pSettingParam, + MOBLEUINT32 length, + MOBLE_ADDRESS peerAddr, + MOBLE_ADDRESS dstPeer, + MOBLEUINT8 elementIndex) +{ + TRACE_M(TF_SENSOR, "Property ID %X element index %X peer addr %X dst peer %X\r\n", + pSettingParam->property_ID, elementIndex, peerAddr, dstPeer); } /** -* @brief Appli_Sensor_Descriptor_Status: This function is callback for Application -* when sensor get message is received -* @param sensor_Descriptor: Pointer to the parameters to be send in message -* @param pLength: Length of the parameters to be sent in response -* @retval MOBLE_RESULT + * @brief Callback corresponding to Sensor_DescriptorGet_cb + * @param Descriptor parameters +* @retval None */ -MOBLE_RESULT Appli_Sensor_Descriptor_Status(MOBLEUINT8* sensor_Descriptor , - MOBLEUINT32* pLength,MOBLEUINT16 prop_ID , - MOBLEUINT32 length) +void Appli_Sensor_DescriptorGet(MOBLEUINT8 prop_ID, + MOBLEUINT32 length, + MOBLE_ADDRESS peerAddr, + MOBLE_ADDRESS dstPeer, + MOBLEUINT8 elementIndex) { - Appli_Sensor_DescriptorStatus_t Appli_Sensor_DescriptorStatus1[] = + if(length == 0) { - {PRESSURE_PID,0xABC,0xDEF,0x03,0x04,0x05}, - {TEMPERATURE_PID,0xc56,0xd78,0x06,0x07,0x08}, - {TIME_OF_FLIGHT_PID,0xD23,0xE45,0x06,0x07,0x08} - }; - MOBLEUINT32 tolerance; - MOBLE_RESULT result = MOBLE_RESULT_FALSE; - result = Check_Property_ID(Property_ID_Table , prop_ID); - - if (result != MOBLE_RESULT_FALSE ) + TRACE_M(TF_SENSOR, "Sensor Descriptor data for all sensors on element index %X peer addr %X, dst peer %X\r\n", + elementIndex, peerAddr, dstPeer); + } + else { - if(prop_ID == TEMPERATURE_PID) - { - tolerance = Appli_Sensor_DescriptorStatus1[0].NegativeTolerance; - tolerance = (tolerance << 12 ) | - Appli_Sensor_DescriptorStatus1[0].PositiveTolerance; - - *(sensor_Descriptor) = Appli_Sensor_DescriptorStatus1[0].Prop_ID; - *(sensor_Descriptor+1) = Appli_Sensor_DescriptorStatus1[0].Prop_ID >> 8; - *(sensor_Descriptor+2) = tolerance; - *(sensor_Descriptor+3) = tolerance >> 8; - *(sensor_Descriptor+4) = tolerance >> 16; - *(sensor_Descriptor+5) = Appli_Sensor_DescriptorStatus1[0].SamplingFunction; - *(sensor_Descriptor+6) = Appli_Sensor_DescriptorStatus1[0].MeasurementPeriod; - *(sensor_Descriptor+7) = Appli_Sensor_DescriptorStatus1[0].UpdateInterval; - *pLength = 8; - } - else if(prop_ID == PRESSURE_PID) - { - tolerance = Appli_Sensor_DescriptorStatus1[1].NegativeTolerance; - tolerance = (tolerance << 12 ) | Appli_Sensor_DescriptorStatus1[1].PositiveTolerance ; - - *(sensor_Descriptor) = Appli_Sensor_DescriptorStatus1[1].Prop_ID; - *(sensor_Descriptor+1) = Appli_Sensor_DescriptorStatus1[1].Prop_ID >> 8; - *(sensor_Descriptor+2) = tolerance; - *(sensor_Descriptor+3) = tolerance >> 8; - *(sensor_Descriptor+4) = tolerance >> 16; - *(sensor_Descriptor+5) = Appli_Sensor_DescriptorStatus1[1].SamplingFunction; - *(sensor_Descriptor+6) = Appli_Sensor_DescriptorStatus1[1].MeasurementPeriod; - *(sensor_Descriptor+7) = Appli_Sensor_DescriptorStatus1[1].UpdateInterval; - *pLength =8; - } - else if(prop_ID == TIME_OF_FLIGHT_PID) - { - tolerance = Appli_Sensor_DescriptorStatus1[2].NegativeTolerance; - tolerance = (tolerance << 12 ) | Appli_Sensor_DescriptorStatus1[2].PositiveTolerance ; + TRACE_M(TF_SENSOR, "Property ID %X element index %X peer addr %X, dst peer %X\r\n", + prop_ID, elementIndex, peerAddr, dstPeer); + } +} - *(sensor_Descriptor) = Appli_Sensor_DescriptorStatus1[2].Prop_ID; - *(sensor_Descriptor+1) = Appli_Sensor_DescriptorStatus1[2].Prop_ID >> 8; - *(sensor_Descriptor+2) = tolerance; - *(sensor_Descriptor+3) = tolerance >> 8; - *(sensor_Descriptor+4) = tolerance >> 16; - *(sensor_Descriptor+5) = Appli_Sensor_DescriptorStatus1[2].SamplingFunction; - *(sensor_Descriptor+6) = Appli_Sensor_DescriptorStatus1[2].MeasurementPeriod; - *(sensor_Descriptor+7) = Appli_Sensor_DescriptorStatus1[2].UpdateInterval; - *pLength =8; - } +/** + * @brief Callback corresponding to Sensor_Get_cb + * @param Get parameters +* @retval None +*/ +void Appli_Sensor_Get(MOBLEUINT16 prop_ID, + MOBLEUINT32 length, + MOBLE_ADDRESS peerAddr, + MOBLE_ADDRESS dstPeer, + MOBLEUINT8 elementIndex) +{ + if(length == 0) + { + TRACE_M(TF_SENSOR, "Sensor Data for all sensors on element index %X peer addr %X dst peer %X\r\n", + elementIndex, peerAddr, dstPeer); } - else + else { - if(length ==0 ) - { - tolerance = Appli_Sensor_DescriptorStatus1[0].NegativeTolerance; - tolerance = (tolerance << 12 ) | Appli_Sensor_DescriptorStatus1[0].PositiveTolerance; - - *(sensor_Descriptor) = Appli_Sensor_DescriptorStatus1[0].Prop_ID; - *(sensor_Descriptor+1) = Appli_Sensor_DescriptorStatus1[0].Prop_ID >> 8; - *(sensor_Descriptor+2) = tolerance; - *(sensor_Descriptor+3) = tolerance >> 8; - *(sensor_Descriptor+4) = tolerance >> 16; - *(sensor_Descriptor+5) = Appli_Sensor_DescriptorStatus1[0].SamplingFunction; - *(sensor_Descriptor+6) = Appli_Sensor_DescriptorStatus1[0].MeasurementPeriod; - *(sensor_Descriptor+7) = Appli_Sensor_DescriptorStatus1[0].UpdateInterval; - - tolerance = Appli_Sensor_DescriptorStatus1[1].NegativeTolerance; - tolerance = (tolerance << 12 ) | Appli_Sensor_DescriptorStatus1[1].PositiveTolerance ; - - *(sensor_Descriptor+8) = Appli_Sensor_DescriptorStatus1[1].Prop_ID; - *(sensor_Descriptor+9) = Appli_Sensor_DescriptorStatus1[1].Prop_ID >> 8; - *(sensor_Descriptor+10) = tolerance; - *(sensor_Descriptor+11) = tolerance >> 8; - *(sensor_Descriptor+12) = tolerance >> 16; - *(sensor_Descriptor+13) = Appli_Sensor_DescriptorStatus1[1].SamplingFunction; - *(sensor_Descriptor+14) = Appli_Sensor_DescriptorStatus1[1].MeasurementPeriod; - *(sensor_Descriptor+15) = Appli_Sensor_DescriptorStatus1[1].UpdateInterval; - - tolerance = Appli_Sensor_DescriptorStatus1[2].NegativeTolerance; - tolerance = (tolerance << 12 ) | Appli_Sensor_DescriptorStatus1[2].PositiveTolerance ; - - *(sensor_Descriptor+16) = Appli_Sensor_DescriptorStatus1[2].Prop_ID; - *(sensor_Descriptor+17) = Appli_Sensor_DescriptorStatus1[2].Prop_ID >> 8; - *(sensor_Descriptor+18) = tolerance; - *(sensor_Descriptor+19) = tolerance >> 8; - *(sensor_Descriptor+20) = tolerance >> 16; - *(sensor_Descriptor+21) = Appli_Sensor_DescriptorStatus1[2].SamplingFunction; - *(sensor_Descriptor+22) = Appli_Sensor_DescriptorStatus1[2].MeasurementPeriod; - *(sensor_Descriptor+23) = Appli_Sensor_DescriptorStatus1[2].UpdateInterval; - - *pLength = 24; - } - else if(prop_ID != 0x0000) - { - *(sensor_Descriptor) = prop_ID >> 8; - *(sensor_Descriptor+1) = prop_ID; - *pLength = 2; - } - else - { - - } + TRACE_M(TF_SENSOR, "Property ID %X element index %X peer addr %X dst peer %X \r\n", + prop_ID, elementIndex, peerAddr, dstPeer); } +} + - // } - //else if(result == MOBLE_RESULT_FALSE && length >0) - //{ - // *(sensor_Descriptor) = prop_ID >> 8; - // *(sensor_Descriptor+1) = prop_ID; - // *pLength = 2; - //} - //else - //{ - // - //} - return MOBLE_RESULT_SUCCESS; +/** + * @brief Callback corresponding to Sensor_ColumnGet_cb + * @param Column parameters +* @retval None +*/ +void Appli_Sensor_ColumnGet(sensor_ColumnCbParams_t* pColumnParam, + MOBLEUINT32 length, + MOBLE_ADDRESS peerAddr, + MOBLE_ADDRESS dstPeer, + MOBLEUINT8 elementIndex) +{ + TRACE_M(TF_SENSOR, "Property ID %X element index %X peer addr %X dst peer %X\r\n", + pColumnParam->propertyId, elementIndex, peerAddr, dstPeer); } -MOBLE_RESULT Appli_Sensor_Column_Status(MOBLEUINT8* sensor_Column , MOBLEUINT32* pLength,MOBLEUINT16 prop_ID , MOBLEUINT32 length) +/** + * @brief Callback corresponding to Sensor_SeriesGet_cb + * @param Series parameters +* @retval None +*/ +void Appli_Sensor_SeriesGet(sensor_SeriesCbParams_t* pSeriesParam, + MOBLEUINT32 length, + MOBLE_ADDRESS peerAddr, + MOBLE_ADDRESS dstPeer, + MOBLEUINT8 elementIndex) { + TRACE_M(TF_SENSOR, "Property ID %X Raw Value X1 %d Raw Value X2 %d\r\n", + pSeriesParam->propertyId, + pSeriesParam->rawValueX1, + pSeriesParam->rawValueX2); +} + + +/** + * @brief Callback corresponding to Sensor_ReadDescriptor_cb + * Update SENSORX descriptor identified by sensorOffset + * Read from application to optimize RAM + * @param Sensor offset in sensor init structure + * @param descriptor parameters + * @retval Fail if sensor doesn't exist or property ID mismatch occurrs + * else Success + */ +MOBLE_RESULT Appli_Sensor_ReadDescriptor(MOBLEUINT8 sensorOffset, + sensor_DescriptorCbParams_t* pDescriptorParams) +{ + MOBLE_RESULT result = MOBLE_RESULT_SUCCESS; + const sensor_init_params_t* pSensorInitParams = NULL; - Sensor_Column_param_t Appli_Sensor_ColumnStatus[]= - { - {PRESSURE_PID,0xD9AF,0xDE03,0x0405}, - {TEMPERATURE_PID,0xacd2,0x3456,0x6537}, - {TIME_OF_FLIGHT_PID,0x8248,0xDE03,0x0405} - }; - - MOBLEUINT8 flag = 0; - - for(int i=0;i< NUMBER_OF_SENSOR ;i++) + if (sensorOffset < SensorServerInitParams.sensorsCount) { - if(prop_ID == Appli_Sensor_ColumnStatus[i].Property_ID) + pSensorInitParams = &(SensorServerInitParams.sensorInitParams[sensorOffset]); + + if (pSensorInitParams->propertyId != pDescriptorParams->propertyId) { - flag = 1; - *sensor_Column= Appli_Sensor_ColumnStatus[i].Property_ID; - *(sensor_Column+1) = Appli_Sensor_ColumnStatus[i].Property_ID>>8; - - *(sensor_Column+2)=Appli_Sensor_ColumnStatus[i].RawValueX; - *(sensor_Column+3)=Appli_Sensor_ColumnStatus[i].RawValueX; - - - *(sensor_Column+4)=Appli_Sensor_ColumnStatus[i].RawValueWidth; - *(sensor_Column+5)=Appli_Sensor_ColumnStatus[i].RawValueWidth; - - *(sensor_Column+6)=Appli_Sensor_ColumnStatus[i].RawValueY; - *(sensor_Column+7)=Appli_Sensor_ColumnStatus[i].RawValueY; - *pLength = 8; - break; + result = MOBLE_RESULT_FAIL; + } + else + { + /* */ } } - - if(flag == 0) + else { - *pLength =4; + result = MOBLE_RESULT_FAIL; } - return MOBLE_RESULT_SUCCESS; + if (pSensorInitParams != NULL && + pDescriptorParams != NULL) + { + pDescriptorParams->positiveTolerance = pSensorInitParams->positiveTolerance; + pDescriptorParams->negativeTolerance = pSensorInitParams->negativeTolerance; + pDescriptorParams->samplingFunction = pSensorInitParams->samplingFunction; + pDescriptorParams->measurementPeriod = pSensorInitParams->measurementPeriod; + pDescriptorParams->updateInterval = pSensorInitParams->updateInterval; + } + else + { + result = MOBLE_RESULT_FAIL; + } + + return result; } -MOBLE_RESULT Appli_Sensor_Series_Status(MOBLEUINT8* sensor_Series , MOBLEUINT32* pLength,MOBLEUINT16 prop_ID , MOBLEUINT32 length) +/** + * @brief Callback corresponding to Sensor_ReadValue_cb + * Read sensor value and update buffer + * data length <= 128 + * PreviousTemperatureValue, PresentTemperatureValue to be updated + * everytime sensor value is changed and call to Sensor_UpdateCadence + * @param Sensor offset in sensor init structure + * @param Value parameters + * @retval Fail if sensor doesn't exist + * else Success + */ +MOBLE_RESULT Appli_Sensor_ReadValue(MOBLEUINT8 sensorOffset, + sensor_ValueCbParams_t* pValueParams) { - Sensor_Series_param_t Appli_Sensor_SeriesStatus[NUMBER_OF_SENSOR]= - { - {PRESSURE_PID,{{0xabcd,0x73ac,0xcdef},{0xacd2,0x2345,0x1234}}}, - {TEMPERATURE_PID,{{0x00C1,0x0071,0x00DE},{0x0003,0x0004,0x0005}}}, - {TIME_OF_FLIGHT_PID,{{0x4528,0xbad3,0xdc12},{0xacd2,0x2345,0x1234}}} - }; + MOBLE_RESULT result = MOBLE_RESULT_SUCCESS; +// PRESSURE_StatusTypeDef tempStatus = PRESSURE_OK; + MOBLEINT16 temp = 0; + MOBLEINT8 temperature8 = 0; + float pressure = 0; - for(int i=0;i<NUMBER_OF_SENSOR;i++) + /* sensor offset exist */ + if (sensorOffset < SensorServerInitParams.sensorsCount) { - if( prop_ID == Appli_Sensor_SeriesStatus[i].Property_ID ) + if (sensorOffset == 0) /* Present Ambient Temperature */ { + if(AppliSensorReadFromSensor == 0) /* Normal mode */ + { + /* Temperature, Temperature8 format, M=1, d=0, b=-1 */ +// tempStatus = LPS25HB_I2C_ReadRawTemperature(&temp); +// if (tempStatus == PRESSURE_OK) + { + TRACE_M(TF_SENSOR, "Temperature sensor raw value %d\r\n" , temp); + + /* Convert temperature raw value to Temperature8 format */ + temp = (temp/240) + 85; + + if (temp < -64*2) + { + temp = -64*2; + } + else if (temp > 63.5*2) + { + temp = 63.5*2; + } + + temperature8 = temp; + + pValueParams->data[0] = (MOBLEUINT8)temperature8; + + if (pValueParams->data[0] == 0xFF) + { + /* 0xFF is unknown but here it is -1 + -1 is approximated to 0 */ + pValueParams->data[0] = 0x00; + } + + TRACE_M(TF_SENSOR, "Temperature8 raw value %d, actual value %f\r\n", + temperature8, (float)temperature8/2); + } +#if 0 + else /* error */ + { + pValueParams->data[0] = 0xFF; + } +#endif + } + else /* Value not to be read from sensor */ + { + pValueParams->data[0] = PresentTemperatureValue; + } + } + else if (sensorOffset == 1) /* Pressure */ + { +// tempStatus = LPS25HB_GetPressure(&pressure); +// if (tempStatus == PRESSURE_OK) + { + TRACE_M(TF_SENSOR, "Pressure sensor value %f mbar\r\n" , pressure); - *sensor_Series= Appli_Sensor_SeriesStatus[i].Property_ID; - *(sensor_Series+1) = Appli_Sensor_SeriesStatus[i].Property_ID>>8; - for(int y=0 ;y < SENSOR_SERIES_VALUE ;y++) + memcpy(pValueParams->data, (void*)&pressure, 4); + } +#if 0 + else /* error */ { - *(sensor_Series+2+6*y) =Appli_Sensor_SeriesStatus[i].SeriesData[y].RawValueX>>8; - *(sensor_Series+3+6*y) =Appli_Sensor_SeriesStatus[i].SeriesData[y].RawValueX; - *(sensor_Series+4+6*y) =Appli_Sensor_SeriesStatus[i].SeriesData[y].RawColumnWidth>>8; - *(sensor_Series+5+6*y) =Appli_Sensor_SeriesStatus[i].SeriesData[y].RawColumnWidth; - *(sensor_Series+6+6*y) =Appli_Sensor_SeriesStatus[i].SeriesData[y].RawValueY>>8; - *(sensor_Series+7+6*y) =Appli_Sensor_SeriesStatus[i].SeriesData[y].RawValueY; + memset(pValueParams->data, 0, 4); } - *pLength = 2 + 6*SENSOR_SERIES_VALUE ; - break; +#endif } } + else + { + result = MOBLE_RESULT_FAIL; + } -return MOBLE_RESULT_SUCCESS ; - + return result; } - + #endif + /** -* @brief Sensor Process Function will continuously monitor the sensors. -* Function used for the Publishing, data monitoring.. -* @param void -* @retval void + * @brief Callback corresponding to Appli_Sensor_Cadence_Status + * @param Descriptor parameters + * @param +* @retval None */ -void Sensor_Process(void) +void Appli_Sensor_Cadence_Status(const MOBLEUINT8 *pCadence, + MOBLEUINT32 length, + MOBLE_ADDRESS dstPeer, + MOBLEUINT8 elementIndex) { + MOBLEUINT8 i; -#ifdef ENABLE_SENSOR_PUBLICATION - float sensorValue[NUMBER_OF_SENSOR]; - if(ProvisionFlag == 1) + TRACE_M(TF_SENSOR,"Appli_Sensor_Cadence_Status callback received \r\n"); + + TRACE_M(TF_SERIAL_CTRL,"#%d! for element %d \r\n", + SENSOR_CADENCE_STATUS, + elementIndex); + for(i = 0; i < length; i++) { - Read_Sensor_Data(&sensorValue[0]); - Sensor_Publication_Process(&sensorValue[0], &Property_ID_Table[0]); + TRACE_M(TF_SERIAL_CTRL,"Cadence value: %d\n\r", pCadence[i]); } -#endif +} + + +/** + * @brief Callback corresponding to Appli_Sensor_Settings_Status + * @param Descriptor parameters + * @param +* @retval None +*/ +void Appli_Sensor_Settings_Status(const MOBLEUINT8 *pSettings, + MOBLEUINT32 length, + MOBLE_ADDRESS dstPeer, + MOBLEUINT8 elementIndex) +{ + MOBLEUINT8 i; + + TRACE_M(TF_SENSOR,"Appli_Sensor_Settings_Status callback received \r\n"); - /* Occupancy_Flag become True when ever sensor detect occupancy and get interrupt - and make flag True to run this routine. - */ - if(Occupancy_Flag == MOBLE_TRUE) + TRACE_M(TF_SERIAL_CTRL,"#%d! for element %d \r\n", + SENSOR_SETTINGS_STATUS, + elementIndex); + for(i = 0; i < length; i++) { - if(BLE_waitPeriod(CONTROLLER_WAIT_TIME)) - { -#ifdef ENABLE_SENSOR_PUBLICATION - if(ProvisionFlag == 1) - { - Read_Sensor_Data(&sensorValue[0]); - Sensor_Publication_Process(&sensorValue[0], &Property_ID_Table[0]); - } -#endif - /* publishing the command for LC Light occupancy set message in the sensor status - message . - */ - Sensor_LC_Light_Publish(); - Occupancy_Flag = MOBLE_FALSE; - } - } + TRACE_M(TF_SERIAL_CTRL,"Settings value: %d\n\r", pSettings[i]); + } } - + + /** -* @brief Function check for the couupancy in the location and send the status -* message with the ocuppancy value, when the interrupt is detected. -* @param void -* @retval void -*/ -void Sensor_LC_Light_Publish(void) + * @brief Callback corresponding to Appli_Sensor_Setting_Status + * @param Descriptor parameters + * @param +* @retval None +*/ +void Appli_Sensor_Setting_Status(const MOBLEUINT8 *pSetting, + MOBLEUINT32 length, + MOBLE_ADDRESS dstPeer, + MOBLEUINT8 elementIndex) { - MOBLEUINT8 occupancyData = 0x1; - MOBLEUINT8 sensor_Data[5]; - MOBLE_ADDRESS srcAdd; - MOBLE_RESULT result = MOBLE_RESULT_SUCCESS; + MOBLEUINT8 i; - sensor_Data[1] = (MOBLEUINT8)(PRESENCE_DETECTED_PROPERTY << 8); - sensor_Data[0] = (MOBLEUINT8)PRESENCE_DETECTED_PROPERTY; - sensor_Data[2] = occupancyData; + TRACE_M(TF_SENSOR,"Appli_Sensor_Setting_Status callback received \r\n"); - srcAdd = BLEMesh_GetAddress(); + TRACE_M(TF_SERIAL_CTRL,"#%d! for element %d \r\n", + SENSOR_SETTING_STATUS, + elementIndex); + for(i = 0; i < length; i++) + { + TRACE_M(TF_SERIAL_CTRL,"Setting value: %d\n\r", pSetting[i]); + } +} + + +/** + * @brief Callback corresponding to Appli_Sensor_Descriptor_Status + * @param Descriptor parameters + * @param +* @retval None +*/ +void Appli_Sensor_Descriptor_Status(const MOBLEUINT8 *pDescriptor, + MOBLEUINT32 length, + MOBLE_ADDRESS dstPeer, + MOBLEUINT8 elementIndex) +{ + MOBLEUINT8 i; - result = BLEMesh_SetRemotePublication(SENSOR_SERVER_MODEL_ID, srcAdd , - SENSOR_STATUS , - sensor_Data,3, - MOBLE_FALSE, MOBLE_FALSE); - - if(result) + TRACE_M(TF_SENSOR,"Appli_Sensor_Descriptor_Status callback received \r\n"); + + TRACE_M(TF_SERIAL_CTRL,"#%d! for element %d \r\n", + SENSOR_DESCRIPTOR_STATUS, + elementIndex); + for(i = 0; i < length; i++) { - TRACE_M(TF_LIGHT_LC,"Publication Error \r\n"); + TRACE_M(TF_SERIAL_CTRL,"Descriptor value: %d\n\r", pDescriptor[i]); } - } - -#if defined ENABLE_SENSOR_PUBLICATION && defined ENABLE_SENSOR_MODEL_SERVER + + /** -* @brief Function read the particular sensor value which are called inside. -* @param pSensorValue: pointer to the sensor data array. -* @retval void + * @brief Callback corresponding to Appli_Sensor_Status + * @param Descriptor parameters + * @param +* @retval None */ -void Read_Sensor_Data(float *pSensorValue) +void Appli_Sensor_Status(const MOBLEUINT8 *pStatus, + MOBLEUINT32 length, + MOBLE_ADDRESS dstPeer, + MOBLEUINT8 elementIndex) { -#if 0 - float temp,press; - LPS25HB_GetTemperature(&temp); - pSensorValue[0] = temp; - LPS25HB_GetPressure(&press); - pSensorValue[1] = press; -#endif + MOBLEUINT8 i; + + TRACE_M(TF_SENSOR,"Appli_Sensor_Status callback received \r\n"); + + TRACE_M(TF_SERIAL_CTRL,"#%d! for element %d \r\n", + SENSOR_STATUS, + elementIndex); + for(i = 0; i < length; i++) + { + TRACE_M(TF_SERIAL_CTRL,"Status value: %d\n\r", pStatus[i]); + } +#ifdef ENABLE_LIGHT_MODEL_SERVER_LC + Appli_Light_LC_SensorPropertyUpdate(elementIndex, + PRESENCE_DETECTED_PID, + (MOBLEUINT32) pStatus[length-1]); +#endif } - + + /** -* @brief Sensor Publication Process function -* @param Function will publish the sensor data according to the given conditions. -* @param void type function pointer. -* @param pSensorData: Pointer to the sensor data array. -* @param pProp_ID: Pointer to the Property id of sensor array. -* @retval void -*/ -void Sensor_Publication_Process(float* pSensorData, MODEL_Property_IDTableParam_t* pProp_ID) + * @brief Callback corresponding to Appli_Sensor_Column_Status + * @param Descriptor parameters + * @param +* @retval None +*/ +void Appli_Sensor_Column_Status(const MOBLEUINT8 *pColumn, + MOBLEUINT32 length, + MOBLE_ADDRESS dstPeer, + MOBLEUINT8 elementIndex) { - static MOBLEUINT8 sensor_Count = 0; - displayFloatToInt_t out_value; - MOBLEUINT8 devisorValue; - MOBLEUINT32 publishTime; - static MOBLEUINT32 cadenceDurationTick[NUMBER_OF_SENSOR]; - static float previousDataValue[NUMBER_OF_SENSOR]; - static PublishingDataFlag_t PublishingDataFlag[NUMBER_OF_SENSOR] = {MOBLE_FALSE}; + MOBLEUINT8 i; - floatToInt(pSensorData[sensor_Count], &out_value, 2); + TRACE_M(TF_SENSOR,"Appli_Sensor_Column_Status callback received \r\n"); - /* Taking the timestamp for the cadence publication and making flag high */ - if(PublishingDataFlag[sensor_Count].CadenceDurationFlag == MOBLE_FALSE) + TRACE_M(TF_SERIAL_CTRL,"#%d! for element %d \r\n", + SENSOR_COLUMN_STATUS, + elementIndex); + for(i = 0; i < length; i++) { - cadenceDurationTick[sensor_Count] = Clock_Time(); - PublishingDataFlag[sensor_Count].CadenceDurationFlag = MOBLE_TRUE; + TRACE_M(TF_SERIAL_CTRL,"Column Status value: %d\n\r", pColumn[i]); } - /* Taking the sensor value and store it for comparing present sensor value with - particular difference of increasing or decreasing. and making flag high. - */ - if(PublishingDataFlag[sensor_Count].DeltaDataFlag == MOBLE_FALSE) - { - previousDataValue[sensor_Count] = pSensorData[sensor_Count]; - PublishingDataFlag[sensor_Count].DeltaDataFlag = MOBLE_TRUE; - } - /* - This condition is checking for the difference of present sensor value - with prestored sensor value with user defined difference,if this condition - is true then it publish the sensor data.And making the delta flag low again. - */ - if((pSensorData[sensor_Count] >= (previousDataValue[sensor_Count] + Sensor_CadenceSet[sensor_Count].triggerDeltaUp)) || - (pSensorData[sensor_Count] <= (previousDataValue[sensor_Count] - Sensor_CadenceSet[sensor_Count].triggerDeltaDown))) - { - MOBLEUINT16 prop_id = pProp_ID[sensor_Count].Property_ID; - - SensorDataPublish((MOBLEUINT32*)&pSensorData[sensor_Count] , &prop_id); - - PublishingDataFlag[sensor_Count].DeltaDataFlag = MOBLE_FALSE; - TRACE_M(TF_SENSOR,"previous value data %.3f \r\n",previousDataValue[sensor_Count]); - TRACE_M(TF_SENSOR,"Delta publication of data %.3f\r\n",*((float*)&pSensorData[sensor_Count])); - sensor_Count++; - } - /* - This condition is continuously checking the sensor value range, if that - value is within the user defined range then publishing duration or rate will - be divided by user definedcadence devisor value and rate of publishing will - become high.And making the cadence flag low again. - */ - if(((out_value.out_int <= Sensor_CadenceSet[sensor_Count].FastCadenceHigh) && - (out_value.out_int >= Sensor_CadenceSet[sensor_Count].FastCadenceLow)) || - (Sensor_CadenceSet[sensor_Count].FastCadenceHigh < Sensor_CadenceSet[sensor_Count].FastCadenceLow)) +} + + +/** + * @brief Callback corresponding to Appli_Sensor_Series_Status + * @param Descriptor parameters + * @param +* @retval None +*/ +void Appli_Sensor_Series_Status(const MOBLEUINT8 *pSeries, + MOBLEUINT32 length, + MOBLE_ADDRESS dstPeer, + MOBLEUINT8 elementIndex) +{ + MOBLEUINT8 i; + + TRACE_M(TF_SENSOR,"Appli_Sensor_Series_Status callback received \r\n"); + + TRACE_M(TF_SERIAL_CTRL,"#%d! for element %d \r\n", + SENSOR_SERIES_STATUS, + elementIndex); + for(i = 0; i < length; i++) { - devisorValue = (MOBLEUINT8)pow(2 ,Sensor_CadenceSet[sensor_Count].FastCadenceDevisor); - publishTime = SENSOR_PUBLISH_PERIOD/devisorValue; - - if(((Clock_Time()- cadenceDurationTick[sensor_Count]) >= publishTime)) - { - MOBLEUINT16 prop_id = pProp_ID[sensor_Count].Property_ID; - - SensorDataPublish((MOBLEUINT32*)&pSensorData[sensor_Count] , &prop_id); - PublishingDataFlag[sensor_Count].CadenceDurationFlag = MOBLE_FALSE; - TRACE_M(TF_SENSOR,"Cadence publication of data %.2f \r\n",*((float*)&pSensorData[sensor_Count])); - sensor_Count++; - } + TRACE_M(TF_SERIAL_CTRL,"Series Status value: %d\n\r", pSeries[i]); } - else +} + + +/** + * @brief Callback corresponding to Sensor_ReadColumn_cb + * Fill column width and raw valye Y in data buffer + * data length <= 8 + * @param Sensor offset in sensor init structure + * @param Series column parameters + * @retval Fail if sensor doesn't exist + * else Success +*/ +MOBLE_RESULT Appli_Sensor_ReadColumn(MOBLEUINT8 sensorOffset, + MOBLEUINT8 columnOffset, + sensor_ColumnCbParams_t* pColumnParams) +{ + MOBLE_RESULT result = MOBLE_RESULT_SUCCESS; + const sensor_init_params_t* pSensorInitParams = NULL; + MOBLEUINT8 dataLength = 0; + MOBLEUINT8* data = pColumnParams->data; + + if (sensorOffset < SensorServerInitParams.sensorsCount) { - publishTime = SENSOR_PUBLISH_PERIOD ; + pSensorInitParams = &(SensorServerInitParams.sensorInitParams[sensorOffset]); - if(((Clock_Time()- cadenceDurationTick[sensor_Count]) >= SENSOR_PUBLISH_PERIOD)) - { - MOBLEUINT16 prop_id = pProp_ID[sensor_Count].Property_ID; - - SensorDataPublish((MOBLEUINT32*)&pSensorData[sensor_Count] , &prop_id); - - PublishingDataFlag[sensor_Count].CadenceDurationFlag = MOBLE_FALSE; - TRACE_M(TF_SENSOR,"Regular publication of data %.3f \r\n",*((float*)&pSensorData[sensor_Count])); - } - } - if(sensor_Count > 1) + /* fill sensor column data */ + memcpy(data+dataLength, + &(pSensorInitParams->seriesColumn[columnOffset].columnWidth), + pSensorInitParams->dataLength); + dataLength = pSensorInitParams->dataLength; + + memset(data+dataLength, 0xAA, pSensorInitParams->dataLength); + dataLength += pSensorInitParams->dataLength; + + pColumnParams->dataLength = dataLength; + } + else { - sensor_Count = 0; + result = MOBLE_RESULT_FAIL; } - + + return result; } + /** -* @brief BLEMesh Sensor Publication function -* @param Function will decide the publish address and element. -* @param pSensor_Value: Pointer to the sensor data array -* @param pProp_ID: pointer to the property id of sensor array. -* @retval void -*/ -void SensorDataPublish(MOBLEUINT32 *pSensor_Value , MOBLEUINT16* pProp_ID) + * @brief Callback corresponding to Sensor_ReadSeries_cb + * Fill sensor series state for all columns between and including X1 and X2 + * Series data to be concatenated in triplet of raw value X, column width and raw value Y + * X[n] CW[n] Y[n] X[n+1] CW[n+1] Y[n+1] ... + * data length should be less than minimum of 379 or max application packet length supported + * @param Sensor offset in sensor init structure + * @param Series parameters + * @retval Fail if sensor doesn't exist + * else Success + */ +MOBLE_RESULT Appli_Sensor_ReadSeries(MOBLEUINT8 sensorOffset, + sensor_SeriesCbParams_t* pSeriesParams) { - MOBLEUINT32 length; - MOBLEUINT8 sensor_Data[8]; - MOBLE_ADDRESS srcAdd; MOBLE_RESULT result = MOBLE_RESULT_SUCCESS; + const sensor_init_params_t* pSensorInitParams = NULL; + MOBLEUINT16 dataLength = 0; + MOBLEUINT8* data = pSeriesParams->data; - srcAdd = BLEMesh_GetAddress(); - - switch(*pProp_ID) + if (sensorOffset < SensorServerInitParams.sensorsCount) { - case TEMPERATURE_PID: - { - /*(prop_Id_Temp & 0x07) << 5) | (Len <<1) Format A - Property calculation is done like above line - */ - sensor_Data[0] = ((TEMPERATURE_PID & 0x07) << 5) | (3 <<1) ; - sensor_Data[1] = (TEMPERATURE_PID >> 3) & 0xFF; - - memcpy(&sensor_Data[2],(void*)&pSensor_Value[0],4); - length =6; - break; - } - case PRESSURE_PID: + pSensorInitParams = &(SensorServerInitParams.sensorInitParams[sensorOffset]); + + for (MOBLEUINT8 count=0; count<pSensorInitParams->seriesCount; count++) + { + /* fill sensor series data */ + if (pSensorInitParams->seriesColumn[count].rawX >= pSeriesParams->rawValueX1 && + pSensorInitParams->seriesColumn[count].rawX <= pSeriesParams->rawValueX2) { - /* Format B for Pressure sensor */ - sensor_Data[0] = ((0x03 <<1) | 0x01); - sensor_Data[1] = (MOBLEUINT8)PRESSURE_PID ; - sensor_Data[2] = (MOBLEUINT8)(PRESSURE_PID >> 8); + memcpy(data+dataLength, + &(pSensorInitParams->seriesColumn[count].rawX), + pSensorInitParams->dataLength); + dataLength += pSensorInitParams->dataLength; + memcpy(data+dataLength, + &(pSensorInitParams->seriesColumn[count].columnWidth), + pSensorInitParams->dataLength); + dataLength += pSensorInitParams->dataLength; + memset(data+dataLength, 0xAA, pSensorInitParams->dataLength); + dataLength += pSensorInitParams->dataLength; - memcpy(&sensor_Data[3],(void*)&pSensor_Value[0],4); - length =7; - break; + pSeriesParams->dataLength = dataLength; } - case TIME_OF_FLIGHT_PID: + else { - sensor_Data[0] = ((0x03 <<1) | 0x01); - sensor_Data[1] = (MOBLEUINT8)TIME_OF_FLIGHT_PID ; - sensor_Data[2] = (MOBLEUINT8)(TIME_OF_FLIGHT_PID >> 8); - - memcpy(&sensor_Data[3],(void*)&pSensor_Value[0],4); - length =7; - break; + /* */ } - default: - break; + } } + else + { + result = MOBLE_RESULT_FAIL; + } + + return result; +} - result = BLEMesh_SetRemotePublication(SENSOR_SERVER_MODEL_ID, srcAdd, - SENSOR_STATUS , - sensor_Data,length, - MOBLE_FALSE, MOBLE_FALSE); - if(result) +/** + * @brief Callback corresponding to Sensor_IsFastCadence_cb + * To check if fast cadence to be used for current sensor state + * @param Sensor offset in sensor init structure + * @param Fast Cadence Low + * @param Fast Cadence High + * @retval Trigger status + */ +MOBLEUINT8 Appli_Sensor_IsFastCadence(MOBLEUINT8 sensorOffset, + void* pFastCadenceLow, + void* pFastCadenceHigh) +{ + MOBLEUINT8 fastCadenceStatus = 0; + MOBLEUINT32 fastCadenceLow = *((MOBLEUINT32*)pFastCadenceLow); + MOBLEUINT32 fastCadenceHigh = *((MOBLEUINT32*)pFastCadenceHigh); + MOBLEUINT32 sensorValue = PresentTemperatureValue; + + if (sensorOffset == 0) + { + if (fastCadenceLow <= fastCadenceHigh) + { + fastCadenceStatus = sensorValue >= fastCadenceLow && + sensorValue <= fastCadenceHigh; + } + else + { + fastCadenceStatus = sensorValue > fastCadenceLow || + sensorValue < fastCadenceHigh; + } +} + else { - TRACE_M(TF_SENSOR,"Publication Error \r\n"); + /* Implmented only for sensor at offset 0 */ } + return fastCadenceStatus; } -#endif -#ifdef ENABLE_SENSOR_MODEL_SERVER -#if 0 /** -* @brief Appli_Sensor_GetSettingStatus: This function is callback for Application -* when sensor setting numbers status message is to be provided -* @param pSetting_Status: Pointer to the status message -* @retval MOBLE_RESULT + * @brief Callback corresponding to Sensor_IsStatusTrigger_cb + * To check if sensor change in sensor state (delta) is more than + * given trigger state value + * delta up values + * @param Sensor offset in sensor init structure + * @param Trigger type -> value or percent change + * @param Status trigger delta down + * @param Status trigger delta up + * @retval Trigger status */ -/* -MOBLE_RESULT Appli_Sensor_GetSettingStatus(MOBLEUINT8* pSetting_Status) +MOBLEUINT8 Appli_Sensor_IsStatusTrigger(MOBLEUINT8 sensorOffset, + status_trigger_type_e triggerType, + void* pDeltaDown, + void* pDeltaUp) { + const sensor_init_params_t* pSensorInitParams = NULL; + MOBLEUINT8 triggerStatus = 0; + MOBLEUINT32 deltaDown = *((MOBLEUINT32*)pDeltaDown); + MOBLEUINT32 deltaUp = *((MOBLEUINT32*)pDeltaUp); + status_trigger_delta_e statusTriggerDelta; + MOBLEUINT32 delta; - *pSetting_Status = Appli_Sensor_SettingSet.Property_ID; - *(pSetting_Status+1) = Appli_Sensor_SettingSet.Property_ID >> 8; - *(pSetting_Status+2) = Appli_Sensor_SettingSet.Sensor_Setting_ID; - *(pSetting_Status+3) = Appli_Sensor_SettingSet.Sensor_Setting_ID >> 8; - - return MOBLE_RESULT_SUCCESS; -}*/ -#endif + if (sensorOffset == 0) + { + if (PresentTemperatureValue < PreviousTemperatureValue) + { + /* status trigger delta down */ + statusTriggerDelta = STATUS_TRIGGER_DELTA_DOWN; + delta = PreviousTemperatureValue - PresentTemperatureValue; -/** -* @brief Appli_Sensor_GetSetting_IDStatus: This function is callback for Application -* when sensor setting numbers and row value status message is to be provided -* @param pSetting_Status: Pointer to the status message -* @retval MOBLE_RESULT -*/ + TRACE_M(TF_SENSOR, "Delta down value %ld\r\n", delta); + } + else + { + /* status trigger delta up */ + statusTriggerDelta = STATUS_TRIGGER_DELTA_UP; + delta = PresentTemperatureValue - PreviousTemperatureValue; -MOBLE_RESULT Appli_Sensor_GetSetting_IDStatus(MOBLEUINT8* pSetting_Status , MOBLEUINT16 prop_ID) -{ - for(int i=0 ;i<NUMBER_OF_SENSOR;i++) - { - if(prop_ID == Appli_Sensor_SettingSet[i].Property_ID) + TRACE_M(TF_SENSOR, "Delta up value %ld\r\n", delta); + } + + if (triggerType == STATUS_TRIGGER_TYPE_PC) { - *pSetting_Status = Appli_Sensor_SettingSet[i].Property_ID; - *(pSetting_Status+1) = Appli_Sensor_SettingSet[i].Property_ID >> 8; - *(pSetting_Status+2) = Appli_Sensor_SettingSet[i].Sensor_Setting_ID; - *(pSetting_Status+3) = Appli_Sensor_SettingSet[i].Sensor_Setting_ID >> 8; - *(pSetting_Status+4) = Appli_Sensor_SettingSet[i].Sensor_Setting_Access; - - if(Appli_Sensor_SettingSet[i].Sensor_Setting_Access == 0x03) + pSensorInitParams = &(SensorServerInitParams.sensorInitParams[sensorOffset]); + + if (pSensorInitParams->valuesRange != 0) { - *(pSetting_Status+5) = Appli_Sensor_SettingSet[i].Sensor_Setting_Value; - *(pSetting_Status+6) = Appli_Sensor_SettingSet[i].Sensor_Setting_Value >> 8; + /* change delta to percentage change (of 0.01 % steps) */ + delta = (MOBLEUINT32)((delta*10000)/pSensorInitParams->valuesRange); } else { - + triggerStatus = 0; } } - } - return MOBLE_RESULT_SUCCESS; + if ((statusTriggerDelta == STATUS_TRIGGER_DELTA_DOWN && delta >= deltaDown) || + (statusTriggerDelta == STATUS_TRIGGER_DELTA_UP && delta >= deltaUp)) + { + triggerStatus = 1; + } + else + { + triggerStatus = 0; + } + } + + return triggerStatus; } + + +/** +* @brief Initialize hardware interfaces for sensors and mesh sensor model structures +* Sensor init parameters to be defined in sensor_cfg_usr.h +* Sensors are initialized in the order as defined in sensor_cfg_usr.h + * LPS25HB supports pressure and temperature sensor +* @param void + * @retval + */ +MOBLE_RESULT Appli_Sensor_Init(void) + { + MOBLE_RESULT result = MOBLE_RESULT_SUCCESS; +// PRESSURE_StatusTypeDef lps25Status; + + /* Hardware interface initialization */ +#ifndef CUSTOM_BOARD_PWM_SELECTION +// PRESSURE_StatusTypeDef tempStatus; +// PRESSURE_StatusTypeDef pressStatus; +// int16_t temperature; +// int32_t pressure; + +#if 0 + /* Initiallization of sensors */ + lps25Status = LPS25HB_Init((PRESSURE_InitTypeDef*)(&Lps25InitParams)); + + if (lps25Status != PRESSURE_OK) + { + TRACE_M(TF_SENSOR, "Error initializing LPS25HB. status (%d)\r\n", lps25Status); + } + + tempStatus = LPS25HB_I2C_ReadRawTemperature(&temperature); + pressStatus = LPS25HB_I2C_ReadRawPressure(&pressure); + if (tempStatus == PRESSURE_OK && + pressStatus == PRESSURE_OK) + { + /* TRACE_M(TF_SENSOR, "Raw temperature (%d) and raw pressure (%d)\r\n", + temperature, pressure); */ + } + else + { + TRACE_M(TF_SENSOR, "Error reading LPS25HB at init\r\n"); + } +#endif + +#else + TRACE_M(TF_SENSOR, "LPS25HB not initialized\r\n"); #endif + /* initialize sensor server model */ + result = SensorServer_Init(&BufferSensorServer, + &AppliSensor_cb, + TOTAL_SENSOR_SERVER_BUFF_SIZE, + &SensorServerInitParams); + + if(MOBLE_FAILED(result)) + { + TRACE_M(TF_SENSOR, "Sensor Server init failed\r\n"); + } + + return result; + } + + /** -* @brief Check_Property_ID: This function is used for checking the Property id -* of sensor available in table. -* @param prop_ID_Table: address of the property id table array. -* @param prop_ID:received property id of sensor. -* @retval MOBLE_RESULT -*/ -MOBLE_RESULT Check_Property_ID(const MODEL_Property_IDTableParam_t prop_ID_Table[], - MOBLEUINT16 prop_ID) + * @brief Handling of serial inputs to sensor model + * @param Sensor offset in sensor init structure + * @param Sensor value + * @retval void + */ +MOBLE_RESULT Appli_Sensor_Update(MOBLEUINT8 sensorOffset, MOBLEUINT32 value) { - MOBLE_RESULT result = MOBLE_RESULT_FALSE; + MOBLE_RESULT result = MOBLE_RESULT_SUCCESS; + + AppliSensorReadFromSensor = 1; + + /* Update previous with current and current with new */ + PreviousTemperatureValue = PresentTemperatureValue; + PresentTemperatureValue = (MOBLEUINT8)value; - for(MOBLEUINT8 i=0; i<NUMBER_OF_SENSOR; i++) + /* To update cadence parameters + results in either status trigger or (and) fast cadence based on change and present + Application may decide not to update cadence parameters if senosr value is changing + very frequently in some cases to save bandwidth */ + if (PresentTemperatureValue != PreviousTemperatureValue) { - if(prop_ID_Table[i].Property_ID == prop_ID) - { - result = MOBLE_RESULT_SUCCESS; - break; - } - } + result = Sensor_UpdateCadence(sensorOffset, + SensorServerInitParams.sensorInitParams[0].elementIdx, + SensorServerInitParams.sensorInitParams[0].propertyId); + } return result; -} + } + /** -* @brief Appli_Sensor_Init: This function is callback for Initialisation of -* Application interface -* @param void -* @retval MOBLE_RESULT -*/ -MOBLE_RESULT Appli_Sensor_Init(void) + * @brief Handling of serial inputs to sensor model + * Appli_Sensor_SerialCmd can be used for testing periodic publishing and + * triggered publishing with PTS + * @param serial string + * @param serial string size + * @retval void + */ +void Appli_Sensor_SerialCmd(char *rcvdStringBuff, uint16_t rcvdStringSize) { -#if 0 - LPS25HB_Init(&InitStructure); -#endif - return MOBLE_RESULT_SUCCESS; + MOBLE_RESULT result = MOBLE_RESULT_INVALIDARG; + MOBLEUINT16 value = 0; + MOBLEUINT8 sensorOffset = 0; + + if (!strncmp(rcvdStringBuff+6, "SETV", 4)) + { + if (rcvdStringSize == 15) + { + sscanf(rcvdStringBuff+11, "%4hx", &value); + + /* Set SENSOR1 value at offset 0 */ + result = Appli_Sensor_Update(sensorOffset, value); + } + else + { + result = MOBLE_RESULT_FAIL; + BLEMesh_PrintStringCb("Invalid size of string\r\n"); + } + } + else if (!strncmp(rcvdStringBuff+6, "PUBLISH", 7)) + { + if (rcvdStringSize == 17) + { + sscanf(rcvdStringBuff+14, "%1hx", &value); + + sensorOffset = value; + + sscanf(rcvdStringBuff+16, "%1hx", &value); + + /* Enable / Disable publishing of sensor as identified by sensor offset */ + if(value == 0) /* Disable */ + { + result = Sensor_UpdatePublishState(sensorOffset, 0); + } + else /* Enable */ + { + result = Sensor_UpdatePublishState(sensorOffset, 1); + } + } + else + { + result = MOBLE_RESULT_FAIL; + BLEMesh_PrintStringCb("Invalid size of string\r\n"); + } + } + else + { + result = MOBLE_RESULT_FAIL; + } + + /* Check the result of command processing */ + if(result == MOBLE_RESULT_SUCCESS) + { + BLEMesh_PrintStringCb("Success\r\n"); + } + else if(result == MOBLE_RESULT_OUTOFMEMORY) + { + BLEMesh_PrintStringCb("Fail Out of memory\r\n"); + } + else if(result == MOBLE_RESULT_INVALIDARG) + { + BLEMesh_PrintStringCb("Fail Invalid Argument\r\n"); + } + else + { + BLEMesh_PrintStringCb("Fail\r\n"); + } } @@ -898,5 +1027,5 @@ MOBLE_RESULT Appli_Sensor_Init(void) * @} */ -/******************* (C) COPYRIGHT 2019 STMicroelectronics *****END OF FILE****/ +/******************* (C) COPYRIGHT 2020 STMicroelectronics *****END OF FILE****/ |