diff options
Diffstat (limited to 'Projects/P-NUCLEO-WB55.USBDongle/Applications/BLE/BLE_MeshLightingPRFNode/STM32_WPAN/app/appli_light.c')
| -rw-r--r-- | Projects/P-NUCLEO-WB55.USBDongle/Applications/BLE/BLE_MeshLightingPRFNode/STM32_WPAN/app/appli_light.c | 1189 |
1 files changed, 754 insertions, 435 deletions
diff --git a/Projects/P-NUCLEO-WB55.USBDongle/Applications/BLE/BLE_MeshLightingPRFNode/STM32_WPAN/app/appli_light.c b/Projects/P-NUCLEO-WB55.USBDongle/Applications/BLE/BLE_MeshLightingPRFNode/STM32_WPAN/app/appli_light.c index 318929ffc..19face0da 100644 --- a/Projects/P-NUCLEO-WB55.USBDongle/Applications/BLE/BLE_MeshLightingPRFNode/STM32_WPAN/app/appli_light.c +++ b/Projects/P-NUCLEO-WB55.USBDongle/Applications/BLE/BLE_MeshLightingPRFNode/STM32_WPAN/app/appli_light.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 @@ -41,7 +41,9 @@ * @{ */ -MOBLE_RESULT Appli_Light_GetLightnessLastStatus(MOBLEUINT8* lLastState); +MOBLE_RESULT Appli_Light_GetLightnessLastStatus(MOBLEUINT8* lLastState, + MOBLEUINT16 dstPeer, + MOBLEUINT8 elementIndex); /* Private typedef -----------------------------------------------------------*/ /* Private define ------------------------------------------------------------*/ /* Private macro -------------------------------------------------------------*/ @@ -55,9 +57,8 @@ Following Variables are used for the LIGHTING Lightness MODEL /******************************************************************************/ #ifdef ENABLE_LIGHT_MODEL_SERVER_LIGHTNESS /******************************************************************************/ - -Appli_Light_lightnessSet ApplilightnessSet = {1,0,0,0,0,0}; -Appli_Light_lightnessLinearSet ApplilightnessLinearSet; +Appli_Light_lightnessSet ApplilightnessSet[APPLICATION_NUMBER_OF_ELEMENTS] = {{1,0,0,0,0,0}}; +Appli_Light_lightnessLinearSet ApplilightnessLinearSet[APPLICATION_NUMBER_OF_ELEMENTS]; /******************************************************************************/ #endif /* #ifdef ENABLE_LIGHT_MODEL_SERVER_LIGHTNESS */ @@ -70,10 +71,9 @@ Following Variables are used for the LIGHTING CTL MODEL /******************************************************************************/ #ifdef ENABLE_LIGHT_MODEL_SERVER_CTL /******************************************************************************/ - -Appli_Light_CtlSet AppliCtlSet; -Appli_Light_CtlTemperatureRangeSet AppliCtlTemperatureRangeSet; -Appli_Light_CtlDefaultSet AppliCtlDefaultSet; + Appli_Light_CtlSet AppliCtlSet[APPLICATION_NUMBER_OF_ELEMENTS]; + Appli_Light_CtlTemperatureRangeSet AppliCtlTemperatureRangeSet[APPLICATION_NUMBER_OF_ELEMENTS]; + Appli_Light_CtlDefaultSet AppliCtlDefaultSet[APPLICATION_NUMBER_OF_ELEMENTS]; /******************************************************************************/ #endif /* #ifdef ENABLE_LIGHT_MODEL_SERVER_CTL */ @@ -83,14 +83,11 @@ Appli_Light_CtlDefaultSet AppliCtlDefaultSet; Following Variables are used for the LIGHTING HSL MODEL *******************************************************************************/ -/*******************************************************************************/ #ifdef ENABLE_LIGHT_MODEL_SERVER_HSL -/*******************************************************************************/ - - Appli_Light_HslSet AppliHslSet; - Appli_Light_HslDefaultSet Appli_HslDefaultSet = {0x7FFF,0x7FFF,0x7FFF}; - Appli_Light_RGBSet Appli_RGBParam; - Appli_Light_HslRangeSet AppliHslRangeSet; + Appli_Light_HslSet AppliHslSet[APPLICATION_NUMBER_OF_ELEMENTS]; + Appli_Light_HslDefaultSet Appli_HslDefaultSet[APPLICATION_NUMBER_OF_ELEMENTS] = {{0x7FFF,0x7FFF,0x7FFF}}; + Appli_Light_RGBSet Appli_RGBParam[APPLICATION_NUMBER_OF_ELEMENTS]; + Appli_Light_HslRangeSet AppliHslRangeSet[APPLICATION_NUMBER_OF_ELEMENTS]; /*******************************************************************************/ #endif /*End of the LIGHTING HSL MODEL variables */ @@ -117,22 +114,28 @@ extern MOBLEUINT16 IntensityValue; * when Light Lightness Set message is received * @param pLight_LightnessParam: Pointer to the parameters received for message * @param OptionalValid: Flag to inform about the validity of optional parameters +* @param dstPeer: destination send by peer for this node. It can be a +* unicast or group address +* @param elementIndex: index of the element received from peer for this node which +* is elementNumber-1 * @retval MOBLE_RESULT */ MOBLE_RESULT Appli_Light_Lightness_Set(Light_LightnessStatus_t* pLight_LightnessParam, - MOBLEUINT8 OptionalValid) + MOBLEUINT8 OptionalValid, MOBLEUINT16 dstPeer, + MOBLEUINT8 elementIndex) { MOBLEUINT16 duty; static MOBLEUINT16 previousIntensity = 0; - TRACE_M(TF_SERIAL_CTRL,"#824C!\n\r"); + TRACE_M(TF_LIGHT,"Light_Lightness_Set callback received for element %d \r\n", elementIndex); + TRACE_M(TF_SERIAL_CTRL,"#824C!\r\n"); - ApplilightnessSet.PresentState16 = pLight_LightnessParam->LightnessPresentValue16; - ApplilightnessSet.LastLightness16 = pLight_LightnessParam->LightnessLastStatus; + ApplilightnessSet[elementIndex].PresentState16 = pLight_LightnessParam->LightnessPresentValue16; + ApplilightnessSet[elementIndex].LastLightness16 = pLight_LightnessParam->LightnessLastStatus; if(pLight_LightnessParam->LightnessPresentValue16 != 0x00) { - ApplilightnessSet.LastLightness16 = pLight_LightnessParam->LightnessPresentValue16; + ApplilightnessSet[elementIndex].LastLightness16 = pLight_LightnessParam->LightnessPresentValue16; } if(((IntensityValue > previousIntensity) && (IntensityValue <PWM_TIME_PERIOD)) || @@ -146,6 +149,7 @@ MOBLE_RESULT Appli_Light_Lightness_Set(Light_LightnessStatus_t* pLight_Lightness } previousIntensity = IntensityValue; +#if 0 /* For demo, if Level is more than 100, switch ON the LED */ if(pLight_LightnessParam->LightnessPresentValue16 >= 0x8000) { @@ -155,16 +159,17 @@ MOBLE_RESULT Appli_Light_Lightness_Set(Light_LightnessStatus_t* pLight_Lightness { BSP_LED_Off(LED_BLUE); } - TRACE_M(TF_SERIAL_CTRL,"#8206%04hx!\n\r",ApplilightnessSet.PresentState16); +#endif + + TRACE_M(TF_SERIAL_CTRL,"#8206%04hx!\n\r", + ApplilightnessSet[elementIndex].PresentState16); - duty = PwmValueMapping(ApplilightnessSet.PresentState16 , 0xfFFF ,0); + duty = PwmValueMapping(ApplilightnessSet[elementIndex].PresentState16 , 0xfFFF ,0); Appli_LightPwmValue.IntensityValue = duty; Light_UpdateLedValue(LOAD_STATE , Appli_LightPwmValue); /* set the flag value for NVM store */ - RestoreFlag = LIGHT_LIGHTNESS_NVM_FLAG; - - AppliNvm_SaveMessageParam(); + NvmStatePowerFlag_Set(LIGHT_LIGHTNESS_NVM_FLAG, elementIndex); return MOBLE_RESULT_SUCCESS; @@ -181,18 +186,18 @@ MOBLE_RESULT Appli_Light_Lightness_Set(Light_LightnessStatus_t* pLight_Lightness * @param pLength: length of data * @retval MOBLE_RESULT */ -MOBLE_RESULT Appli_Light_Lightness_Status(MOBLEUINT8 const *pLightness_status, MOBLEUINT32 pLength) +MOBLE_RESULT Appli_Light_Lightness_Status(MOBLEUINT8 const *pLightness_status, MOBLEUINT32 pLength, MOBLEUINT16 dstPeer, + MOBLEUINT8 elementIndex) { -#ifdef CFG_DEBUG_TRACE +#if ( CFG_DEBUG_TRACE != 0 ) MOBLEUINT32 i; MOBLEUINT16 value = 0; #endif - TRACE_M(TF_LIGHT,"Light_Lightness_Status callback received \r\n"); + TRACE_M(TF_LIGHT,"Light_Lightness_Status callback received for element %d \r\n", elementIndex); + TRACE_M(TF_SERIAL_CTRL,"#824E!\r\n"); - TRACE_M(TF_SERIAL_CTRL,"#824E! \n\r"); - -#ifdef CFG_DEBUG_TRACE +#if ( CFG_DEBUG_TRACE != 0 ) for(i = 0; i < pLength; i++) { if((i == 0) || (i == 2)) @@ -201,28 +206,33 @@ MOBLE_RESULT Appli_Light_Lightness_Status(MOBLEUINT8 const *pLightness_status, M } else if(i == 1) { - TRACE_M(TF_LIGHT,"Present Lightness: %d \r\n", - value << 8 | pLightness_status[i]); + TRACE_M(TF_LIGHT,"Present Lightness: 0x%x (%d)\r\n", + value | pLightness_status[i] << 8, + value | pLightness_status[i] << 8); } else if(i == 3) { - TRACE_M(TF_LIGHT,"Target Lightness: %d \r\n", - value << 8 | pLightness_status[i]); + TRACE_M(TF_LIGHT,"Target Lightness: 0x%x (%d)\r\n", + value | pLightness_status[i] << 8, + value | pLightness_status[i] << 8); } else if(i == 4) { - TRACE_M(TF_LIGHT,"Remaining Time: %d \r\n", + TRACE_M(TF_LIGHT,"Remaining Time: 0x%x (%d)\r\n", + pLightness_status[i], pLightness_status[i]); } } #endif + return MOBLE_RESULT_SUCCESS; } + /******************************************************************************/ #ifdef ENABLE_LIGHT_MODEL_SERVER_LIGHTNESS /******************************************************************************/ - + /** * @brief Appli_Light_Lightness_Linear_Set: This function is callback for Application * when Light Lightness Linear Set message is received @@ -231,11 +241,13 @@ MOBLE_RESULT Appli_Light_Lightness_Status(MOBLEUINT8 const *pLightness_status, M * @retval MOBLE_RESULT */ MOBLE_RESULT Appli_Light_Lightness_Linear_Set(Light_LightnessStatus_t* pLight_LightnessLinearParam, - MOBLEUINT8 OptionalValid) + MOBLEUINT8 OptionalValid, MOBLEUINT16 dstPeer, + MOBLEUINT8 elementIndex) { - ApplilightnessLinearSet.PresentState16 = pLight_LightnessLinearParam->LinearPresentValue16; + ApplilightnessLinearSet[elementIndex].PresentState16 = pLight_LightnessLinearParam->LinearPresentValue16; - TRACE_M(TF_SERIAL_CTRL,"#8250!\n\r"); + TRACE_M(TF_LIGHT,"Light_Lightness_Linear_Set callback received for element %d \r\n", elementIndex); + TRACE_M(TF_SERIAL_CTRL,"#8250!\r\n"); return MOBLE_RESULT_SUCCESS; } @@ -248,20 +260,25 @@ MOBLE_RESULT Appli_Light_Lightness_Linear_Set(Light_LightnessStatus_t* pLight_Li * @brief Appli_Light_Lightness_Linear_Status: This function is callback for Application * when Light Lightness Linear status message is received * @param pLightnessLinear_status: Pointer to the parameters received for message +* @param dstPeer: destination send by peer for this node. It can be a +* unicast or group address +* @param elementIndex: index of the element received from peer for this node which +* is elementNumber-1 * @param pLength: length of data * @retval MOBLE_RESULT */ -MOBLE_RESULT Appli_Light_Lightness_Linear_Status(MOBLEUINT8 const *pLightnessLinear_status, MOBLEUINT32 pLength) +MOBLE_RESULT Appli_Light_Lightness_Linear_Status(MOBLEUINT8 const *pLightnessLinear_status, MOBLEUINT32 pLength, MOBLEUINT16 dstPeer, + MOBLEUINT8 elementIndex) { -#ifdef CFG_DEBUG_TRACE +#if ( CFG_DEBUG_TRACE != 0 ) MOBLEUINT32 i; MOBLEUINT16 value = 0; #endif - TRACE_M(TF_LIGHT,"Light_Lightness_Linear_Status callback received \r\n"); - TRACE_M(TF_SERIAL_CTRL,"#8252! \n\r"); + TRACE_M(TF_LIGHT,"Light_Lightness_Linear_Status callback received for element %d \r\n", elementIndex); + TRACE_M(TF_SERIAL_CTRL,"#8252!\r\n"); -#ifdef CFG_DEBUG_TRACE +#if ( CFG_DEBUG_TRACE != 0 ) for(i = 0; i < pLength; i++) { if((i == 0) || (i == 2)) @@ -270,24 +287,29 @@ MOBLE_RESULT Appli_Light_Lightness_Linear_Status(MOBLEUINT8 const *pLightnessLin } else if(i == 1) { - TRACE_M(TF_LIGHT,"Present Lightness: %d \r\n", - value << 8 | pLightnessLinear_status[i]); + TRACE_M(TF_LIGHT,"Present Lightness: 0x%x (%d)\r\n", + value | pLightnessLinear_status[i] << 8, + value | pLightnessLinear_status[i] << 8); } else if(i == 3) { - TRACE_M(TF_LIGHT,"Target Lightness: %d \r\n", - value << 8 | pLightnessLinear_status[i]); + TRACE_M(TF_LIGHT,"Target Lightness: 0x%x (%d)\r\n", + value | pLightnessLinear_status[i] << 8, + value | pLightnessLinear_status[i] << 8); } else if(i == 4) { - TRACE_M(TF_LIGHT,"Remaining Time: %d \r\n", + TRACE_M(TF_LIGHT,"Remaining Time: 0x%x (%d)\r\n", + pLightnessLinear_status[i], pLightnessLinear_status[i]); } } #endif + return MOBLE_RESULT_SUCCESS; } + /******************************************************************************/ #ifdef ENABLE_LIGHT_MODEL_SERVER_LIGHTNESS_SETUP /******************************************************************************/ @@ -297,11 +319,17 @@ MOBLE_RESULT Appli_Light_Lightness_Linear_Status(MOBLEUINT8 const *pLightnessLin * when Light Lightness Default Set message is received * @param pLight_LightnessDefaultParam: Pointer to the parameters received for message * @param OptionalValid: Flag to inform about the validity of optional parameters +* @param dstPeer: destination send by peer for this node. It can be a +* unicast or group address +* @param elementIndex: index of the element received from peer for this node which +* is elementNumber-1 * @retval MOBLE_RESULT */ MOBLE_RESULT Appli_Light_Lightness_Default_Set(Light_LightnessDefaultParam_t* pLight_LightnessDefaultParam, - MOBLEUINT8 OptionalValid) + MOBLEUINT8 OptionalValid, MOBLEUINT16 dstPeer, + MOBLEUINT8 elementIndex) { +#if 0 if(pLight_LightnessDefaultParam->LightnessDefaultStatus > 0) { BSP_LED_On(LED_BLUE); @@ -310,14 +338,16 @@ MOBLE_RESULT Appli_Light_Lightness_Default_Set(Light_LightnessDefaultParam_t* pL { BSP_LED_Off(LED_BLUE); } - ApplilightnessSet.LightnessDefault = pLight_LightnessDefaultParam->LightnessDefaultStatus; +#endif + + ApplilightnessSet[elementIndex].LightnessDefault = + pLight_LightnessDefaultParam->LightnessDefaultStatus; + + TRACE_M(TF_LIGHT,"Light_Lightness_Default_Set callback received for element %d \r\n", elementIndex); + TRACE_M(TF_SERIAL_CTRL,"#8259! \r\n"); - TRACE_M(TF_SERIAL_CTRL,"#8259!\n\r"); - /* set the flag value for NVM store */ - RestoreFlag = LIGHT_LIGHTNESS_NVM_FLAG; - - AppliNvm_SaveMessageParam(); + NvmStatePowerFlag_Set(LIGHT_LIGHTNESS_NVM_FLAG,elementIndex); return MOBLE_RESULT_SUCCESS; } @@ -331,19 +361,25 @@ MOBLE_RESULT Appli_Light_Lightness_Default_Set(Light_LightnessDefaultParam_t* pL * when Light Lightness Default status message is received * @param pLightnessDefault_status: Pointer to the parameters received for message * @param pLength: length of data +* @param dstPeer: destination send by peer for this node. It can be a +* unicast or group address +* @param elementIndex: index of the element received from peer for this node which +* is elementNumber-1 * @retval MOBLE_RESULT */ -MOBLE_RESULT Appli_Light_Lightness_Default_Status(MOBLEUINT8 const *pLightnessDefault_status, MOBLEUINT32 pLength) +MOBLE_RESULT Appli_Light_Lightness_Default_Status(MOBLEUINT8 const *pLightnessDefault_status, MOBLEUINT32 pLength + , MOBLEUINT16 dstPeer, + MOBLEUINT8 elementIndex) { -#ifdef CFG_DEBUG_TRACE +#if ( CFG_DEBUG_TRACE != 0 ) MOBLEUINT32 i; - MOBLEUINT16 value = 0; - #endif - TRACE_M(TF_LIGHT,"Light_Lightness_Default_Status callback received \r\n"); + MOBLEUINT16 value; +#endif - TRACE_M(TF_SERIAL_CTRL,"#8256! \n\r"); + TRACE_M(TF_LIGHT,"Light_Lightness_Default_Status callback received for element %d \r\n", elementIndex); + TRACE_M(TF_SERIAL_CTRL,"#8256!\r\n"); -#ifdef CFG_DEBUG_TRACE +#if ( CFG_DEBUG_TRACE != 0 ) for(i = 0; i < pLength; i++) { if(i == 0) @@ -352,14 +388,61 @@ MOBLE_RESULT Appli_Light_Lightness_Default_Status(MOBLEUINT8 const *pLightnessDe } else if(i == 1) { - TRACE_M(TF_LIGHT,"Lightness: %d \r\n", - value << 8 | pLightnessDefault_status[i]); + TRACE_M(TF_LIGHT,"Lightness Default: 0x%x (%d)\r\n", + value | pLightnessDefault_status[i] << 8, + value | pLightnessDefault_status[i] << 8); } } #endif + return MOBLE_RESULT_SUCCESS; } + +/** +* @brief Appli_Light_Lightness_Last_Status: This function is callback for Application +* when Light Lightness Last status message is received +* @param pLightnessDefault_status: Pointer to the parameters received for message +* @param pLength: length of data +* @param dstPeer: destination send by peer for this node. It can be a +* unicast or group address +* @param elementIndex: index of the element received from peer for this node which +* is elementNumber-1 +* @retval MOBLE_RESULT +*/ +MOBLE_RESULT Appli_Light_Lightness_Last_Status(MOBLEUINT8 const *pLightnessLast_status, + MOBLEUINT32 pLength, + MOBLEUINT16 dstPeer, + MOBLEUINT8 elementIndex) +{ +#if ( CFG_DEBUG_TRACE != 0 ) + MOBLEUINT32 i; + MOBLEUINT16 value; +#endif + + TRACE_M(TF_LIGHT,"Light_Lightness_Last_Status callback received for element %d \r\n", elementIndex); + TRACE_M(TF_SERIAL_CTRL,"#8256!\r\n"); + +#if ( CFG_DEBUG_TRACE != 0 ) + for(i = 0; i < pLength; i++) + { + if(i == 0) + { + value = pLightnessLast_status[i]; + } + else if(i == 1) + { + TRACE_M(TF_LIGHT,"Lightness Last: 0x%x (%d)\r\n", + value | pLightnessLast_status[i] << 8, + value | pLightnessLast_status[i] << 8); + } + } +#endif + + return MOBLE_RESULT_SUCCESS; +} + + /******************************************************************************/ #ifdef ENABLE_LIGHT_MODEL_SERVER_LIGHTNESS_SETUP /******************************************************************************/ @@ -369,16 +452,22 @@ MOBLE_RESULT Appli_Light_Lightness_Default_Status(MOBLEUINT8 const *pLightnessDe * when Light Lightness Range Set message is received * @param pLight_LightnessRangeParam: Pointer to the parameters received for message * @param OptionalValid: Flag to inform about the validity of optional parameters +* @param dstPeer: destination send by peer for this node. It can be a +* unicast or group address +* @param elementIndex: index of the element received from peer for this node which +* is elementNumber-1 * @retval MOBLE_RESULT */ MOBLE_RESULT Appli_Light_Lightness_Range_Set(Light_LightnessRangeParam_t* pLight_LightnessRangeParam, - MOBLEUINT8 OptionalValid) + MOBLEUINT8 OptionalValid, MOBLEUINT16 dstPeer, + MOBLEUINT8 elementIndex) { - ApplilightnessSet.StatusCode = pLight_LightnessRangeParam->StatusCode; - ApplilightnessSet.RangeMin = pLight_LightnessRangeParam->MinRangeStatus; - ApplilightnessSet.RangeMax = pLight_LightnessRangeParam->MaxRangeStatus; + ApplilightnessSet[elementIndex].StatusCode = pLight_LightnessRangeParam->StatusCode; + ApplilightnessSet[elementIndex].RangeMin = pLight_LightnessRangeParam->MinRangeStatus; + ApplilightnessSet[elementIndex].RangeMax = pLight_LightnessRangeParam->MaxRangeStatus; - TRACE_M(TF_SERIAL_CTRL,"#825B! \n\r"); + TRACE_M(TF_LIGHT,"Light_Lightness_Range_Set callback received for element %d \r\n", elementIndex); + TRACE_M(TF_SERIAL_CTRL,"#825B!\r\n"); return MOBLE_RESULT_SUCCESS; } @@ -392,45 +481,56 @@ MOBLE_RESULT Appli_Light_Lightness_Range_Set(Light_LightnessRangeParam_t* pLight * when Light Lightness range ststus message is received * @param pLightnessRange_status: Pointer to the parameters received for message * @param pLength: length of data +* @param dstPeer: destination send by peer for this node. It can be a +* unicast or group address +* @param elementIndex: index of the element received from peer for this node which +* is elementNumber-1 * @retval MOBLE_RESULT */ -MOBLE_RESULT Appli_Light_Lightness_Range_Status(MOBLEUINT8 const *pLightnessRange_status, MOBLEUINT32 pLength) +MOBLE_RESULT Appli_Light_Lightness_Range_Status(MOBLEUINT8 const *pLightnessRange_status, MOBLEUINT32 pLength + , MOBLEUINT16 dstPeer, + MOBLEUINT8 elementIndex) { -#ifdef CFG_DEBUG_TRACE +#if ( CFG_DEBUG_TRACE != 0 ) MOBLEUINT32 i; - MOBLEUINT16 value = 0; + MOBLEUINT16 value; #endif - TRACE_M(TF_LIGHT,"Light_Lightness_Range_Status callback received \r\n"); - - TRACE_M(TF_SERIAL_CTRL,"#8258! \n\r"); -#ifdef CFG_DEBUG_TRACE + TRACE_M(TF_LIGHT,"Light_Lightness_Range_Status callback received for element %d \r\n", elementIndex); + TRACE_M(TF_SERIAL_CTRL,"#8258!\r\n"); + +#if ( CFG_DEBUG_TRACE != 0 ) for(i = 0; i < pLength; i++) { if(i == 0) { - TRACE_M(TF_LIGHT,"Status Code: %d \r\n", - value << 8 | pLightnessRange_status[i]); + TRACE_M(TF_LIGHT,"Status Code: 0x%x (%d)\r\n", + pLightnessRange_status[i], + pLightnessRange_status[i]); } else if((i == 1) || (i == 3)) { value = pLightnessRange_status[i]; } - else if(i == 1) + else if(i == 2) { - TRACE_M(TF_LIGHT,"Range Min: %d \r\n", - value << 8 | pLightnessRange_status[i]); + TRACE_M(TF_LIGHT,"Range Min: 0x%x (%d)\r\n", + value | pLightnessRange_status[i] << 8, + value | pLightnessRange_status[i] << 8); } - else if(i == 3) + else if(i == 4) { - TRACE_M(TF_LIGHT,"Range Max: %d \r\n", - value << 8 | pLightnessRange_status[i]); + TRACE_M(TF_LIGHT,"Range Max: 0x%x (%d)\r\n", + value | pLightnessRange_status[i] << 8, + value | pLightnessRange_status[i] << 8); } } #endif + return MOBLE_RESULT_SUCCESS; } + /******************************************************************************/ #ifdef ENABLE_LIGHT_MODEL_SERVER_CTL /******************************************************************************/ @@ -440,22 +540,34 @@ MOBLE_RESULT Appli_Light_Lightness_Range_Status(MOBLEUINT8 const *pLightnessRang * when Light Ctl Set message is received * @param pLight_CtlParam: Pointer to the parameters received for message * @param OptionalValid: Flag to inform about the validity of optional parameters +* @param dstPeer: destination send by peer for this node. It can be a +* unicast or group address +* @param elementIndex: index of the element received from peer for this node which +* is elementNumber-1 * @retval MOBLE_RESULT */ MOBLE_RESULT Appli_Light_Ctl_Set(Light_CtlStatus_t* pLight_CtlParam, - MOBLEUINT8 OptionalValid) + MOBLEUINT8 OptionalValid, MOBLEUINT16 dstPeer, + MOBLEUINT8 elementIndex) { float colourRatio; float brightRatio; - TRACE_M(TF_SERIAL_CTRL,"#825E! \n\r"); + TRACE_M(TF_LIGHT,"Appli_Light_Ctl_Set callback received for element %d \r\n", elementIndex); + TRACE_M(TF_SERIAL_CTRL,"#825E!\r\n"); - AppliCtlSet.PresentLightness16 = pLight_CtlParam->PresentCtlLightness16; - AppliCtlSet.PresentTemperature16 = pLight_CtlParam->PresentCtlTemperature16; - AppliCtlSet.PresentCtlDelta16 = pLight_CtlParam->PresentCtlDelta16; - colourRatio = Ratio_CalculateValue(AppliCtlSet.PresentTemperature16 ,MAX_CTL_TEMP_RANGE ,MIN_CTL_TEMP_RANGE); + AppliCtlSet[elementIndex].PresentLightness16 = pLight_CtlParam->PresentCtlLightness16; + AppliCtlSet[elementIndex].PresentTemperature16 = pLight_CtlParam->PresentCtlTemperature16; + AppliCtlSet[elementIndex].PresentCtlDelta16 = pLight_CtlParam->PresentCtlDelta16; - brightRatio = Ratio_CalculateValue(AppliCtlSet.PresentLightness16 ,0XFFFF ,0); + /* Save target parameters if transition is available */ + AppliCtlSet[elementIndex].TargetLightness16 = pLight_CtlParam->TargetCtlLightness16; + AppliCtlSet[elementIndex].TargetTemperature16 = pLight_CtlParam->TargetCtlTemperature16; + AppliCtlSet[elementIndex].TargetCtlDelta16 = pLight_CtlParam->TargetCtlDeltaUv16; + + colourRatio = Ratio_CalculateValue(AppliCtlSet[elementIndex].PresentTemperature16 ,MAX_CTL_TEMP_RANGE ,MIN_CTL_TEMP_RANGE); + + brightRatio = Ratio_CalculateValue(AppliCtlSet[elementIndex].PresentLightness16 ,0XFFFF ,0); Appli_LightPwmValue.PwmCoolValue = PWM_CoolValue(colourRatio , brightRatio); Appli_LightPwmValue.PwmWarmValue = PWM_WarmValue(colourRatio , brightRatio); @@ -464,15 +576,8 @@ MOBLE_RESULT Appli_Light_Ctl_Set(Light_CtlStatus_t* pLight_CtlParam, Light_UpdateLedValue(LOAD_STATE , Appli_LightPwmValue); - TRACE_M(TF_SERIAL_CTRL,"#825E%04hx%04hx%04hx!\n\r", - AppliCtlSet.PresentLightness16, - AppliCtlSet.PresentTemperature16, - AppliCtlSet.PresentCtlDelta16); - /* set the flag value for NVM store */ - RestoreFlag = LIGHT_CTL_NVM_FLAG; - - AppliNvm_SaveMessageParam(); + NvmStatePowerFlag_Set(LIGHT_CTL_NVM_FLAG, elementIndex); return MOBLE_RESULT_SUCCESS; } @@ -488,18 +593,18 @@ MOBLE_RESULT Appli_Light_Ctl_Set(Light_CtlStatus_t* pLight_CtlParam, * @param pLength: length of data * @retval MOBLE_RESULT */ -MOBLE_RESULT Appli_Light_Ctl_Status(MOBLEUINT8 const *pLightCtl_status, - MOBLEUINT32 pLength) +MOBLE_RESULT Appli_Light_Ctl_Status(MOBLEUINT8 const *pLightCtl_status, MOBLEUINT32 pLength, MOBLEUINT16 dstPeer, + MOBLEUINT8 elementIndex) { -#ifdef CFG_DEBUG_TRACE +#if ( CFG_DEBUG_TRACE != 0 ) MOBLEUINT32 i; MOBLEUINT16 value = 0; #endif - TRACE_M(TF_LIGHT,"Light_Ctl_Status callback received \r\n"); - - TRACE_M(TF_SERIAL_CTRL,"#8260! \n\r"); + + TRACE_M(TF_LIGHT,"Light_Ctl_Status callback received for element %d \r\n", elementIndex); + TRACE_M(TF_SERIAL_CTRL,"#8260!\r\n"); -#ifdef CFG_DEBUG_TRACE +#if ( CFG_DEBUG_TRACE != 0 ) for(i = 0; i < pLength; i++) { if((i == 0) || (i == 2) || (i == 4) || (i == 6)) @@ -508,34 +613,41 @@ MOBLE_RESULT Appli_Light_Ctl_Status(MOBLEUINT8 const *pLightCtl_status, } else if(i == 1) { - TRACE_M(TF_LIGHT,"Present CTL Lightness: %d \r\n", - value << 8 | pLightCtl_status[i]); + TRACE_M(TF_LIGHT,"Present CTL Lightness: 0x%x (%d)\r\n", + value | pLightCtl_status[i] << 8, + value | pLightCtl_status[i] << 8); } else if(i == 3) { - TRACE_M(TF_LIGHT,"Present CTL Temperature: %d \r\n", - value << 8 | pLightCtl_status[i]); + TRACE_M(TF_LIGHT,"Present CTL Temperature: 0x%x (%d)\r\n", + value | pLightCtl_status[i] << 8, + value | pLightCtl_status[i] << 8); } else if(i == 5) { - TRACE_M(TF_LIGHT,"Target CTL Lightness: %d \r\n", - value << 8 | pLightCtl_status[i]); + TRACE_M(TF_LIGHT,"Target CTL Lightness: 0x%x (%d)\r\n", + value | pLightCtl_status[i] << 8, + value | pLightCtl_status[i] << 8); } else if(i == 7) { - TRACE_M(TF_LIGHT,"Target CTL Temperature: %d \r\n", - value << 8 | pLightCtl_status[i]); + TRACE_M(TF_LIGHT,"Target CTL Temperature: 0x%x (%d)\r\n", + value | pLightCtl_status[i] << 8, + value | pLightCtl_status[i] << 8); } else if(i == 8) { - TRACE_M(TF_LIGHT,"Remaining Time: %d \r\n", + TRACE_M(TF_LIGHT,"Remaining Time:0x%x (%d)\r\n", + pLightCtl_status[i], pLightCtl_status[i]); } } #endif + return MOBLE_RESULT_SUCCESS; } + /******************************************************************************/ #ifdef ENABLE_LIGHT_MODEL_SERVER_CTL_TEMPERATURE /******************************************************************************/ @@ -545,21 +657,32 @@ MOBLE_RESULT Appli_Light_Ctl_Status(MOBLEUINT8 const *pLightCtl_status, * when Light Ctl Temperature Set message is received * @param pLight_CtltempParam: Pointer to the parameters received for message * @param OptionalValid: Flag to inform about the validity of optional parameters +* @param dstPeer: destination send by peer for this node. It can be a +* unicast or group address +* @param elementIndex: index of the element received from peer for this node which +* is elementNumber-1 * @retval MOBLE_RESULT */ MOBLE_RESULT Appli_Light_CtlTemperature_Set(Light_CtlStatus_t* pLight_CtltempParam, - MOBLEUINT8 OptionalValid) + MOBLEUINT8 OptionalValid, MOBLEUINT16 dstPeer, + MOBLEUINT8 elementIndex) { float colourRatio; float brightRatio; - TRACE_M(TF_SERIAL_CTRL,"#8264!\n\r"); - AppliCtlSet.PresentTemperature16 = pLight_CtltempParam->PresentCtlTemperature16; - AppliCtlSet.PresentCtlDelta16 = pLight_CtltempParam->PresentCtlDelta16; + TRACE_M(TF_LIGHT,"Appli_Light_CtlTemperature_Set callback received for element %d \r\n", elementIndex); + TRACE_M(TF_SERIAL_CTRL,"#8264!\r\n"); + + AppliCtlSet[elementIndex].PresentTemperature16 = pLight_CtltempParam->PresentCtlTemperature16; + AppliCtlSet[elementIndex].PresentCtlDelta16 = pLight_CtltempParam->PresentCtlDelta16; - colourRatio = Ratio_CalculateValue(AppliCtlSet.PresentTemperature16 ,MAX_CTL_TEMP_RANGE ,MIN_CTL_TEMP_RANGE); + /* Made a copy of target in case of transition values change */ + AppliCtlSet[elementIndex].TargetTemperature16 = pLight_CtltempParam->TargetCtlTemperature16; + AppliCtlSet[elementIndex].TargetCtlDelta16 = pLight_CtltempParam->TargetCtlDeltaUv16; - brightRatio = Ratio_CalculateValue(AppliCtlSet.PresentLightness16 ,0XFFFF ,0); + colourRatio = Ratio_CalculateValue(AppliCtlSet[elementIndex].PresentTemperature16 ,MAX_CTL_TEMP_RANGE ,MIN_CTL_TEMP_RANGE); + + brightRatio = Ratio_CalculateValue(AppliCtlSet[elementIndex].PresentLightness16 ,0XFFFF ,0); Appli_LightPwmValue.PwmCoolValue = PWM_CoolValue(colourRatio , brightRatio); Appli_LightPwmValue.PwmWarmValue = PWM_WarmValue(colourRatio , brightRatio); @@ -568,9 +691,7 @@ MOBLE_RESULT Appli_Light_CtlTemperature_Set(Light_CtlStatus_t* pLight_CtltempPar Light_UpdateLedValue(LOAD_STATE , Appli_LightPwmValue); /* set the flag value for NVM store */ - RestoreFlag = LIGHT_CTL_NVM_FLAG; - - AppliNvm_SaveMessageParam(); + NvmStatePowerFlag_Set(LIGHT_CTL_NVM_FLAG, elementIndex); return MOBLE_RESULT_SUCCESS; } @@ -584,19 +705,25 @@ MOBLE_RESULT Appli_Light_CtlTemperature_Set(Light_CtlStatus_t* pLight_CtltempPar * when Light CTL temperature status message is received * @param pLightCtlTemp_status: Pointer to the parameters received for message * @param pLength: length of data +* @param dstPeer: destination send by peer for this node. It can be a +* unicast or group address +* @param elementIndex: index of the element received from peer for this node which +* is elementNumber-1 * @retval MOBLE_RESULT */ -MOBLE_RESULT Appli_Light_CtlTemperature_Status(MOBLEUINT8 const *pLightCtlTemp_status, MOBLEUINT32 pLength) +MOBLE_RESULT Appli_Light_CtlTemperature_Status(MOBLEUINT8 const *pLightCtlTemp_status, MOBLEUINT32 pLength + , MOBLEUINT16 dstPeer, + MOBLEUINT8 elementIndex) { -#ifdef CFG_DEBUG_TRACE +#if ( CFG_DEBUG_TRACE != 0 ) MOBLEUINT32 i; MOBLEUINT16 value = 0; #endif - TRACE_M(TF_LIGHT,"Light_CtlTemperature_Status callback received \r\n"); - TRACE_M(TF_SERIAL_CTRL,"#8266! \n\r"); + TRACE_M(TF_LIGHT,"Light_CtlTemperature_Status callback received for element %d \r\n", elementIndex); + TRACE_M(TF_SERIAL_CTRL,"#8266!\r\n"); -#ifdef CFG_DEBUG_TRACE +#if ( CFG_DEBUG_TRACE != 0 ) for(i = 0; i < pLength; i++) { if((i == 0) || (i == 2) || (i == 4) || (i == 6)) @@ -605,35 +732,42 @@ MOBLE_RESULT Appli_Light_CtlTemperature_Status(MOBLEUINT8 const *pLightCtlTemp_s } else if(i == 1) { - TRACE_M(TF_LIGHT,"Present CTL Temperature: %d \r\n", - value << 8 | pLightCtlTemp_status[i]); + TRACE_M(TF_LIGHT,"Present CTL Temperature: 0x%x (%d)\r\n", + value | pLightCtlTemp_status[i] << 8, + value | pLightCtlTemp_status[i] << 8); } else if(i == 3) { - TRACE_M(TF_LIGHT,"Present CTL Delta UV: %d \r\n", - value << 8 | pLightCtlTemp_status[i]); + TRACE_M(TF_LIGHT,"Present CTL Delta UV: 0x%x (%d)\r\n", + value | pLightCtlTemp_status[i] << 8, + value | pLightCtlTemp_status[i] << 8); } else if(i == 5) { - TRACE_M(TF_LIGHT,"Target CTL Temperature: %d \r\n", - value << 8 | pLightCtlTemp_status[i]); + TRACE_M(TF_LIGHT,"Target CTL Temperature: 0x%x (%d)\r\n", + value | pLightCtlTemp_status[i] << 8, + value | pLightCtlTemp_status[i] << 8); } else if(i == 7) { - TRACE_M(TF_LIGHT,"Target CTL Delta UV: %d \r\n", - value << 8 | pLightCtlTemp_status[i]); + TRACE_M(TF_LIGHT,"Target CTL Delta UV: 0x%x (%d)\r\n", + value | pLightCtlTemp_status[i] << 8, + value | pLightCtlTemp_status[i] << 8); } else if(i == 8) { - TRACE_M(TF_LIGHT,"Remaining Time: %d \r\n", + TRACE_M(TF_LIGHT,"Remaining Time: 0x%x (%d)\r\n", + pLightCtlTemp_status[i], pLightCtlTemp_status[i]); } } #endif + return MOBLE_RESULT_SUCCESS; } + /******************************************************************************/ #ifdef ENABLE_LIGHT_MODEL_SERVER_CTL_SETUP /******************************************************************************/ @@ -643,16 +777,22 @@ MOBLE_RESULT Appli_Light_CtlTemperature_Status(MOBLEUINT8 const *pLightCtlTemp_s * when Light Ctl Temperature range Set message is received * @param pLight_CtlTempRangeParam: Pointer to the parameters received for message * @param OptionalValid: Flag to inform about the validity of optional parameters +* @param dstPeer: destination send by peer for this node. It can be a +* unicast or group address +* @param elementIndex: index of the element received from peer for this node which +* is elementNumber-1 * @retval MOBLE_RESULT */ MOBLE_RESULT Appli_Light_CtlTemperature_Range_Set(Light_CtlTemperatureRangeParam_t* pLight_CtlTempRangeParam, - MOBLEUINT8 OptionalValid) + MOBLEUINT8 OptionalValid, MOBLEUINT16 dstPeer, + MOBLEUINT8 elementIndex) { - AppliCtlTemperatureRangeSet.RangeMin = pLight_CtlTempRangeParam->MinRangeStatus; - AppliCtlTemperatureRangeSet.RangeMax = pLight_CtlTempRangeParam->MaxRangeStatus; - AppliCtlTemperatureRangeSet.StatusCode = pLight_CtlTempRangeParam->StatusCode; + AppliCtlTemperatureRangeSet[elementIndex].RangeMin = pLight_CtlTempRangeParam->MinRangeStatus; + AppliCtlTemperatureRangeSet[elementIndex].RangeMax = pLight_CtlTempRangeParam->MaxRangeStatus; + AppliCtlTemperatureRangeSet[elementIndex].StatusCode = pLight_CtlTempRangeParam->StatusCode; - TRACE_M(TF_SERIAL_CTRL,"#826B!\n\r"); + TRACE_M(TF_LIGHT,"Light_CtlTemperature_Range_Set callback received for element %d \r\n", elementIndex); + TRACE_M(TF_SERIAL_CTRL,"#826B!\r\n"); return MOBLE_RESULT_SUCCESS; } @@ -667,28 +807,34 @@ MOBLE_RESULT Appli_Light_CtlTemperature_Range_Set(Light_CtlTemperatureRangeParam * when Light CTL temperature range status message is received * @param pCtlTempRange_status: Pointer to the parameters received for message * @param pLength: length of data +* @param dstPeer: destination send by peer for this node. It can be a +* unicast or group address +* @param elementIndex: index of the element received from peer for this node which +* is elementNumber-1 * @retval MOBLE_RESULT */ -MOBLE_RESULT Appli_Light_CtlTemperature_Range_Status(MOBLEUINT8 const *pCtlTempRange_status, MOBLEUINT32 pLength) +MOBLE_RESULT Appli_Light_CtlTemperature_Range_Status(MOBLEUINT8 const *pCtlTempRange_status, MOBLEUINT32 pLength, MOBLEUINT16 dstPeer, + MOBLEUINT8 elementIndex) { -#ifdef CFG_DEBUG_TRACE +#if ( CFG_DEBUG_TRACE != 0 ) MOBLEUINT32 i; - MOBLEUINT16 value = 0; + MOBLEUINT16 value; #endif - TRACE_M(TF_LIGHT,"Light_CtlTemperature_Range_Status callback received \r\n"); - TRACE_M(TF_SERIAL_CTRL,"#8263! \n\r"); + TRACE_M(TF_LIGHT,"Light_CtlTemperature_Range_Status callback received for element %d \r\n", elementIndex); + TRACE_M(TF_SERIAL_CTRL,"#8263!\r\n"); - RestoreFlag = LIGHT_CTL_NVM_FLAG; + RestoreFlag = LIGHT_CTL_NVM_FLAG; AppliNvm_SaveMessageParam(); -#ifdef CFG_DEBUG_TRACE +#if ( CFG_DEBUG_TRACE != 0 ) for(i = 0; i < pLength; i++) { if(i == 0) { - TRACE_M(TF_LIGHT,"Status Code: %d \r\n", + TRACE_M(TF_LIGHT,"Status Code: 0x%x (%d)\r\n", + pCtlTempRange_status[i], pCtlTempRange_status[i]); } else if((i == 1) || (i == 3)) @@ -697,19 +843,23 @@ MOBLE_RESULT Appli_Light_CtlTemperature_Range_Status(MOBLEUINT8 const *pCtlTempR } else if(i == 2) { - TRACE_M(TF_LIGHT,"Range Min: %d \r\n", - value << 8 | pCtlTempRange_status[i]); + TRACE_M(TF_LIGHT,"Range Min: 0x%x (%d)\r\n", + value | pCtlTempRange_status[i] << 8, + value | pCtlTempRange_status[i] << 8 ); } else if(i == 4) { - TRACE_M(TF_LIGHT,"Range Max: %d \r\n", - value << 8 | pCtlTempRange_status[i]); + TRACE_M(TF_LIGHT,"Range Max: 0x%x (%d)\r\n", + value | pCtlTempRange_status[i] << 8, + value | pCtlTempRange_status[i] << 8 ); } } #endif + return MOBLE_RESULT_SUCCESS; } + /******************************************************************************/ #ifdef ENABLE_LIGHT_MODEL_SERVER_CTL_SETUP /******************************************************************************/ @@ -719,16 +869,22 @@ MOBLE_RESULT Appli_Light_CtlTemperature_Range_Status(MOBLEUINT8 const *pCtlTempR * when Light Ctl Default Set message is received * @param pLight_CtlDefaultParam: Pointer to the parameters received for message * @param OptionalValid: Flag to inform about the validity of optional parameters +* @param dstPeer: destination send by peer for this node. It can be a +* unicast or group address +* @param elementIndex: index of the element received from peer for this node which +* is elementNumber-1 * @retval MOBLE_RESULT */ MOBLE_RESULT Appli_Light_CtlDefault_Set(Light_CtlDefaultParam_t* pLight_CtlDefaultParam, - MOBLEUINT8 OptionalValid) + MOBLEUINT8 OptionalValid, MOBLEUINT16 dstPeer, + MOBLEUINT8 elementIndex) { - AppliCtlDefaultSet.CtlDefaultLightness16 = pLight_CtlDefaultParam->CtlDefaultLightness16; - AppliCtlDefaultSet.CtlDefaultTemperature16 = pLight_CtlDefaultParam->CtlDefaultTemperature16; - AppliCtlDefaultSet.CtlDefaultDeltaUv = pLight_CtlDefaultParam->CtlDefaultDeltaUv; + AppliCtlDefaultSet[elementIndex].CtlDefaultLightness16 = pLight_CtlDefaultParam->CtlDefaultLightness16; + AppliCtlDefaultSet[elementIndex].CtlDefaultTemperature16 = pLight_CtlDefaultParam->CtlDefaultTemperature16; + AppliCtlDefaultSet[elementIndex].CtlDefaultDeltaUv = pLight_CtlDefaultParam->CtlDefaultDeltaUv; - TRACE_M(TF_SERIAL_CTRL,"#8269!\n\r"); + TRACE_M(TF_LIGHT,"Light_CtlDefault_Set callback received for element %d \r\n", elementIndex); + TRACE_M(TF_SERIAL_CTRL,"#8269!\r\n"); return MOBLE_RESULT_SUCCESS; } @@ -742,19 +898,24 @@ MOBLE_RESULT Appli_Light_CtlDefault_Set(Light_CtlDefaultParam_t* pLight_CtlDefau * when Light CTL Default status message is received * @param pCtlDefault_status: Pointer to the parameters received for message * @param pLength: length of data +* @param dstPeer: destination send by peer for this node. It can be a +* unicast or group address +* @param elementIndex: index of the element received from peer for this node which +* is elementNumber-1 * @retval MOBLE_RESULT */ -MOBLE_RESULT Appli_Light_CtlDefault_Status(MOBLEUINT8 const *pCtlDefault_status, MOBLEUINT32 pLength) +MOBLE_RESULT Appli_Light_CtlDefault_Status(MOBLEUINT8 const *pCtlDefault_status, MOBLEUINT32 pLength, MOBLEUINT16 dstPeer, + MOBLEUINT8 elementIndex) { -#ifdef CFG_DEBUG_TRACE +#if ( CFG_DEBUG_TRACE != 0 ) MOBLEUINT32 i; MOBLEUINT16 value = 0; #endif - TRACE_M(TF_LIGHT,"Light_Ctl_DefaultStatus callback received \r\n"); - TRACE_M(TF_SERIAL_CTRL,"#8268! \n\r"); + TRACE_M(TF_LIGHT,"Light_Ctl_DefaultStatus callback received for element %d \r\n", elementIndex); + TRACE_M(TF_SERIAL_CTRL,"#8268!\r\n"); -#ifdef CFG_DEBUG_TRACE +#if ( CFG_DEBUG_TRACE != 0 ) for(i = 0; i < pLength; i++) { if((i == 0) || (i == 2) || (i == 4)) @@ -763,24 +924,29 @@ MOBLE_RESULT Appli_Light_CtlDefault_Status(MOBLEUINT8 const *pCtlDefault_status, } else if(i == 1) { - TRACE_M(TF_LIGHT,"Lightness: %d \r\n", - value << 8 | pCtlDefault_status[i]); + TRACE_M(TF_LIGHT,"Lightness: 0x%x (%d)\n\r", + value | pCtlDefault_status[i] << 8, + value | pCtlDefault_status[i] << 8); } else if(i == 3) { - TRACE_M(TF_LIGHT,"Temperature: %d \r\n", - value << 8 | pCtlDefault_status[i]); + TRACE_M(TF_LIGHT,"Temperature: 0x%x (%d)\n\r", + value | pCtlDefault_status[i] << 8, + value | pCtlDefault_status[i] << 8); } else if(i == 5) { - TRACE_M(TF_LIGHT,"Delta UV: %d \r\n", - value << 8 | pCtlDefault_status[i]); + TRACE_M(TF_LIGHT,"Delta UV: 0x%x (%d)\n\r", + value | pCtlDefault_status[i] << 8, + value | pCtlDefault_status[i] << 8); } } #endif + return MOBLE_RESULT_SUCCESS; } + /******************************************************************************/ #ifdef ENABLE_LIGHT_MODEL_SERVER_HSL /******************************************************************************/ @@ -790,32 +956,41 @@ MOBLE_RESULT Appli_Light_CtlDefault_Status(MOBLEUINT8 const *pCtlDefault_status, * when Light Hsl Set message is received * @param pLight_HslParam: Pointer to the parameters received for message * @param OptionalValid: Flag to inform about the validity of optional parameters +* @param dstPeer: destination send by peer for this node. It can be a +* unicast or group address +* @param elementIndex: index of the element received from peer for this node which +* is elementNumber-1 * @retval MOBLE_RESULT */ MOBLE_RESULT Appli_Light_Hsl_Set(Light_HslStatus_t* pLight_HslParam, - MOBLEUINT8 OptionalValid) + MOBLEUINT8 OptionalValid, MOBLEUINT16 dstPeer, + MOBLEUINT8 elementIndex) { - TRACE_M(TF_SERIAL_CTRL,"#8276!\n\r"); + TRACE_M(TF_LIGHT,"Appli_Light_Hsl_Set callback received for element %d \r\n", elementIndex); + TRACE_M(TF_SERIAL_CTRL,"#8276!\r\n"); - AppliHslSet.HslLightness16 = pLight_HslParam->PresentHslLightness16; - AppliHslSet.HslHueLightness16 = pLight_HslParam->PresentHslHueLightness16; - AppliHslSet.HslSaturation16 = pLight_HslParam->PresentHslSaturation16; + AppliHslSet[elementIndex].HslLightness16 = pLight_HslParam->PresentHslLightness16; + AppliHslSet[elementIndex].HslHueLightness16 = pLight_HslParam->PresentHslHueLightness16; + AppliHslSet[elementIndex].HslSaturation16 = pLight_HslParam->PresentHslSaturation16; + /* Save target parameters if transition is available */ + AppliHslSet[elementIndex].TargetHslLightness16 = pLight_HslParam->TargetHslLightness16; + AppliHslSet[elementIndex].TargetHslHueLightness16 = pLight_HslParam->TargetHslHueLightness16; + AppliHslSet[elementIndex].TargetHslSaturation16 = pLight_HslParam->TargetHslSaturation16; + /* Function to convert HSL values in RGB values */ - HSL2RGB_Conversion(); + HSL2RGB_Conversion(elementIndex); - Appli_LightPwmValue.PwmRedValue = PwmValueMapping(Appli_RGBParam.Red_Value ,0xFFFF ,0x00); - Appli_LightPwmValue.PwmGreenValue = PwmValueMapping(Appli_RGBParam.Green_Value ,0xFFFF ,0x00); - Appli_LightPwmValue.PwmBlueValue = PwmValueMapping(Appli_RGBParam.Blue_Value ,0xFFFF ,0x00); + Appli_LightPwmValue.PwmRedValue = PwmValueMapping(Appli_RGBParam[elementIndex].Red_Value ,0xFFFF ,0x00); + Appli_LightPwmValue.PwmGreenValue = PwmValueMapping(Appli_RGBParam[elementIndex].Green_Value ,0xFFFF ,0x00); + Appli_LightPwmValue.PwmBlueValue = PwmValueMapping(Appli_RGBParam[elementIndex].Blue_Value ,0xFFFF ,0x00); /* when HSL is set, make CTL pwm will bw zero */ Ctl_LedOffState(); Light_UpdateLedValue(LOAD_STATE , Appli_LightPwmValue); /* set the flag value for NVM store */ - RestoreFlag = LIGHT_HSL_NVM_FLAG; - - AppliNvm_SaveMessageParam(); + NvmStatePowerFlag_Set(LIGHT_HSL_NVM_FLAG, elementIndex); return MOBLE_RESULT_SUCCESS; } @@ -829,19 +1004,24 @@ MOBLE_RESULT Appli_Light_Hsl_Set(Light_HslStatus_t* pLight_HslParam, * when Light HSL status message is received * @param pHsl_status: Pointer to the parameters received for message * @param pLength: length of data +* @param dstPeer: destination send by peer for this node. It can be a +* unicast or group address +* @param elementIndex: index of the element received from peer for this node which +* is elementNumber-1 * @retval MOBLE_RESULT */ -MOBLE_RESULT Appli_Light_Hsl_Status(MOBLEUINT8 const *pHsl_status, MOBLEUINT32 pLength) +MOBLE_RESULT Appli_Light_Hsl_Status(MOBLEUINT8 const *pHsl_status, MOBLEUINT32 pLength, MOBLEUINT16 dstPeer, + MOBLEUINT8 elementIndex) { -#ifdef CFG_DEBUG_TRACE +#if ( CFG_DEBUG_TRACE != 0 ) MOBLEUINT32 i; MOBLEUINT16 value = 0; #endif - TRACE_M(TF_LIGHT,"Light_Hsl_Status callback received \r\n"); - - TRACE_M(TF_SERIAL_CTRL,"#8278! \n\r"); + + TRACE_M(TF_LIGHT,"Light_Hsl_Status callback received for element %d \r\n", elementIndex); + TRACE_M(TF_SERIAL_CTRL,"#8278!\r\n"); -#ifdef CFG_DEBUG_TRACE +#if ( CFG_DEBUG_TRACE != 0 ) for(i = 0; i < pLength; i++) { if((i == 0) || (i == 2) || (i == 4)) @@ -850,29 +1030,35 @@ MOBLE_RESULT Appli_Light_Hsl_Status(MOBLEUINT8 const *pHsl_status, MOBLEUINT32 p } else if(i == 1) { - TRACE_M(TF_LIGHT,"HSL Lightness: %d \r\n", - value << 8 | pHsl_status[i]); + TRACE_M(TF_LIGHT,"HSL Lightness: 0x%x (%d)\n\r", + value | pHsl_status[i] << 8, + value | pHsl_status[i] << 8); } else if(i == 3) { - TRACE_M(TF_LIGHT,"HSL Hue: %d \r\n", - value << 8 | pHsl_status[i]); + TRACE_M(TF_LIGHT,"HSL Hue: 0x%x (%d)\n\r", + value | pHsl_status[i] << 8, + value | pHsl_status[i] << 8); } else if(i == 5) { - TRACE_M(TF_LIGHT,"HSL Saturation: %d \r\n", - value << 8 | pHsl_status[i]); + TRACE_M(TF_LIGHT,"HSL Saturation: 0x%x (%d)\n\r", + value | pHsl_status[i] << 8, + value | pHsl_status[i] << 8); } else if(i == 6) { - TRACE_M(TF_LIGHT,"Remaining Time: %d \r\n", + TRACE_M(TF_LIGHT,"Remaining Time: 0x%x (%d)\n\r", + pHsl_status[i], pHsl_status[i]); } } #endif + return MOBLE_RESULT_SUCCESS; } + /******************************************************************************/ #ifdef ENABLE_LIGHT_MODEL_SERVER_HSL_HUE /******************************************************************************/ @@ -882,28 +1068,32 @@ MOBLE_RESULT Appli_Light_Hsl_Status(MOBLEUINT8 const *pHsl_status, MOBLEUINT32 p * when Light Hsl Hue Set message is received * @param pLight_HslHueParam: Pointer to the parameters received for message * @param OptionalValid: Flag to inform about the validity of optional parameters +* @param dstPeer: destination send by peer for this node. It can be a +* unicast or group address +* @param elementIndex: index of the element received from peer for this node which +* is elementNumber-1 * @retval MOBLE_RESULT */ MOBLE_RESULT Appli_Light_HslHue_Set(Light_HslStatus_t* pLight_HslHueParam, - MOBLEUINT8 OptionalValid) + MOBLEUINT8 OptionalValid, MOBLEUINT16 dstPeer, + MOBLEUINT8 elementIndex) { - TRACE_M(TF_SERIAL_CTRL,"#826F! \n\r"); + TRACE_M(TF_LIGHT,"Light_HslHue_Set callback received for element %d \r\n", elementIndex); + TRACE_M(TF_SERIAL_CTRL,"#826F!\r\n"); - AppliHslSet.HslHueLightness16 = pLight_HslHueParam->PresentHslHueLightness16; + AppliHslSet[elementIndex].HslHueLightness16 = pLight_HslHueParam->PresentHslHueLightness16; - HSL2RGB_Conversion(); + HSL2RGB_Conversion(elementIndex); - Appli_LightPwmValue.PwmRedValue = PwmValueMapping(Appli_RGBParam.Red_Value ,0xFFFF ,0x00); - Appli_LightPwmValue.PwmGreenValue = PwmValueMapping(Appli_RGBParam.Green_Value ,0xFFFF ,0x00); - Appli_LightPwmValue.PwmBlueValue = PwmValueMapping(Appli_RGBParam.Blue_Value ,0xFFFF ,0x00); + Appli_LightPwmValue.PwmRedValue = PwmValueMapping(Appli_RGBParam[elementIndex].Red_Value ,0xFFFF ,0x00); + Appli_LightPwmValue.PwmGreenValue = PwmValueMapping(Appli_RGBParam[elementIndex].Green_Value ,0xFFFF ,0x00); + Appli_LightPwmValue.PwmBlueValue = PwmValueMapping(Appli_RGBParam[elementIndex].Blue_Value ,0xFFFF ,0x00); Ctl_LedOffState(); Light_UpdateLedValue(LOAD_STATE , Appli_LightPwmValue); /* set the flag value for NVM store */ - RestoreFlag = LIGHT_HSL_NVM_FLAG; - - AppliNvm_SaveMessageParam(); + NvmStatePowerFlag_Set(LIGHT_HSL_NVM_FLAG, elementIndex); return MOBLE_RESULT_SUCCESS; @@ -918,19 +1108,24 @@ MOBLE_RESULT Appli_Light_HslHue_Set(Light_HslStatus_t* pLight_HslHueParam, * when Light HSL HUE status message is received * @param pHslHue_status: Pointer to the parameters received for message * @param pLength: length of data +* @param dstPeer: destination send by peer for this node. It can be a +* unicast or group address +* @param elementIndex: index of the element received from peer for this node which +* is elementNumber-1 * @retval MOBLE_RESULT */ -MOBLE_RESULT Appli_Light_HslHue_Status(MOBLEUINT8 const *pHslHue_status, MOBLEUINT32 pLength) +MOBLE_RESULT Appli_Light_HslHue_Status(MOBLEUINT8 const *pHslHue_status, MOBLEUINT32 pLength, MOBLEUINT16 dstPeer, + MOBLEUINT8 elementIndex) { -#ifdef CFG_DEBUG_TRACE +#if ( CFG_DEBUG_TRACE != 0 ) MOBLEUINT32 i; MOBLEUINT16 value = 0; #endif - TRACE_M(TF_LIGHT,"Light_HslHue_Status callback received \r\n"); - TRACE_M(TF_SERIAL_CTRL,"#8271! \n\r"); + TRACE_M(TF_LIGHT,"Light_HslHue_Status callback received for element %d \r\n", elementIndex); + TRACE_M(TF_SERIAL_CTRL,"#8271!\r\n"); -#ifdef CFG_DEBUG_TRACE +#if ( CFG_DEBUG_TRACE != 0 ) for(i = 0; i < pLength; i++) { if((i == 0) || (i == 2)) @@ -939,24 +1134,29 @@ MOBLE_RESULT Appli_Light_HslHue_Status(MOBLEUINT8 const *pHslHue_status, MOBLEUI } else if(i == 1) { - TRACE_M(TF_LIGHT,"Present Hue: %d \r\n", - value << 8 | pHslHue_status[i]); + TRACE_M(TF_LIGHT,"Present Hue: 0x%x (%d)\n\r", + value | pHslHue_status[i] << 8, + value | pHslHue_status[i] << 8); } else if(i == 3) { - TRACE_M(TF_LIGHT,"Target Hue: %d \r\n", - value << 8 | pHslHue_status[i]); + TRACE_M(TF_LIGHT,"Target Hue: 0x%x (%d)\n\r", + value | pHslHue_status[i] << 8, + value | pHslHue_status[i] << 8); } else if(i == 4) { - TRACE_M(TF_LIGHT,"Remaining Time: %d \r\n", + TRACE_M(TF_LIGHT,"Remaining Time: 0x%x (%d)\n\r", + pHslHue_status[i], pHslHue_status[i]); } } #endif + return MOBLE_RESULT_SUCCESS; } + /******************************************************************************/ #ifdef ENABLE_LIGHT_MODEL_SERVER_HSL_SATURATION /******************************************************************************/ @@ -966,28 +1166,32 @@ MOBLE_RESULT Appli_Light_HslHue_Status(MOBLEUINT8 const *pHslHue_status, MOBLEUI * when Light Hsl Saturation Set message is received * @param pLight_HslSaturationParam: Pointer to the parameters received for message * @param OptionalValid: Flag to inform about the validity of optional parameters +* @param dstPeer: destination send by peer for this node. It can be a +* unicast or group address +* @param elementIndex: index of the element received from peer for this node which +* is elementNumber-1 * @retval MOBLE_RESULT */ MOBLE_RESULT Appli_Light_HslSaturation_Set(Light_HslStatus_t* pLight_HslSaturationParam, - MOBLEUINT8 OptionalValid) + MOBLEUINT8 OptionalValid, MOBLEUINT16 dstPeer, + MOBLEUINT8 elementIndex) { - TRACE_M(TF_SERIAL_CTRL,"#8273! \n\r"); + TRACE_M(TF_LIGHT,"Appli_Light_HslSaturation_Set callback received for element %d \r\n", elementIndex); + TRACE_M(TF_SERIAL_CTRL,"#8273!\r\n"); - AppliHslSet.HslSaturation16 = pLight_HslSaturationParam->PresentHslSaturation16; + AppliHslSet[elementIndex].HslSaturation16 = pLight_HslSaturationParam->PresentHslSaturation16; - HSL2RGB_Conversion(); + HSL2RGB_Conversion(elementIndex); - Appli_LightPwmValue.PwmRedValue = PwmValueMapping(Appli_RGBParam.Red_Value ,0xFFFF ,0x00); - Appli_LightPwmValue.PwmGreenValue = PwmValueMapping(Appli_RGBParam.Green_Value ,0xFFFF ,0x00); - Appli_LightPwmValue.PwmBlueValue = PwmValueMapping(Appli_RGBParam.Blue_Value ,0xFFFF ,0x00); + Appli_LightPwmValue.PwmRedValue = PwmValueMapping(Appli_RGBParam[elementIndex].Red_Value ,0xFFFF ,0x00); + Appli_LightPwmValue.PwmGreenValue = PwmValueMapping(Appli_RGBParam[elementIndex].Green_Value ,0xFFFF ,0x00); + Appli_LightPwmValue.PwmBlueValue = PwmValueMapping(Appli_RGBParam[elementIndex].Blue_Value ,0xFFFF ,0x00); Ctl_LedOffState(); Light_UpdateLedValue(LOAD_STATE , Appli_LightPwmValue); /* set the flag value for NVM store */ - RestoreFlag = LIGHT_HSL_NVM_FLAG; - - AppliNvm_SaveMessageParam(); + NvmStatePowerFlag_Set(LIGHT_HSL_NVM_FLAG, elementIndex); return MOBLE_RESULT_SUCCESS; } @@ -1001,19 +1205,24 @@ MOBLE_RESULT Appli_Light_HslSaturation_Set(Light_HslStatus_t* pLight_HslSaturati * when Light HSL Saturation status message is received * @param pHslSaturation_status: Pointer to the parameters received for message * @param pLength: length of data +* @param dstPeer: destination send by peer for this node. It can be a +* unicast or group address +* @param elementIndex: index of the element received from peer for this node which +* is elementNumber-1 * @retval MOBLE_RESULT */ -MOBLE_RESULT Appli_Light_HslSaturation_Status(MOBLEUINT8 const *pHslSaturation_status, MOBLEUINT32 pLength) +MOBLE_RESULT Appli_Light_HslSaturation_Status(MOBLEUINT8 const *pHslSaturation_status, MOBLEUINT32 pLength, MOBLEUINT16 dstPeer, + MOBLEUINT8 elementIndex) { -#ifdef CFG_DEBUG_TRACE +#if ( CFG_DEBUG_TRACE != 0 ) MOBLEUINT32 i; MOBLEUINT16 value = 0; #endif - TRACE_M(TF_LIGHT,"Light_HslSaturation_Status callback received \r\n"); - TRACE_M(TF_SERIAL_CTRL,"#8275! \n\r"); - -#ifdef CFG_DEBUG_TRACE + TRACE_M(TF_LIGHT,"Light_HslSaturation_Status callback received for element %d \r\n", elementIndex); + TRACE_M(TF_SERIAL_CTRL,"#8275!\r\n"); + +#if ( CFG_DEBUG_TRACE != 0 ) for(i = 0; i < pLength; i++) { if((i == 0) || (i == 2)) @@ -1022,24 +1231,29 @@ MOBLE_RESULT Appli_Light_HslSaturation_Status(MOBLEUINT8 const *pHslSaturation_s } else if(i == 1) { - TRACE_M(TF_LIGHT,"Present Saturation: %d \r\n", - value << 8 | pHslSaturation_status[i]); + TRACE_M(TF_LIGHT,"Present Saturation: 0x%x (%d)\n\r", + value | pHslSaturation_status[i] << 8, + value | pHslSaturation_status[i] << 8); } else if(i == 3) { - TRACE_M(TF_LIGHT,"Target Saturation: %d \r\n", - value << 8 | pHslSaturation_status[i]); + TRACE_M(TF_LIGHT,"Target Saturation: 0x%x (%d)\n\r", + value | pHslSaturation_status[i] << 8, + value | pHslSaturation_status[i] << 8); } else if(i == 4) { - TRACE_M(TF_LIGHT,"Remaining Time: %d \r\n", + TRACE_M(TF_LIGHT,"Remaining Time: 0x%x (%d)\n\r", + pHslSaturation_status[i], pHslSaturation_status[i]); } } #endif + return MOBLE_RESULT_SUCCESS; } + /******************************************************************************/ #ifdef ENABLE_LIGHT_MODEL_SERVER_HSL_SETUP /******************************************************************************/ @@ -1049,34 +1263,38 @@ MOBLE_RESULT Appli_Light_HslSaturation_Status(MOBLEUINT8 const *pHslSaturation_s * when Light Hsl Default Set message is received * @param pLight_HslDefaultParam: Pointer to the parameters received for message * @param OptionalValid: Flag to inform about the validity of optional parameters +* @param dstPeer: destination send by peer for this node. It can be a +* unicast or group address +* @param elementIndex: index of the element received from peer for this node which +* is elementNumber-1 * @retval MOBLE_RESULT */ MOBLE_RESULT Appli_Light_HslDefault_Set(Light_HslStatus_t* pLight_HslDefaultParam, - MOBLEUINT8 OptionalValid) + MOBLEUINT8 OptionalValid, MOBLEUINT16 dstPeer, + MOBLEUINT8 elementIndex) { - TRACE_M(TF_SERIAL_CTRL,"#827F! \n\r"); + TRACE_M(TF_LIGHT,"Appli_Light_HslDefault_Set callback received for element %d \r\n", elementIndex); + TRACE_M(TF_SERIAL_CTRL,"#827F!\r\n"); - Appli_HslDefaultSet.HslDefaultLightness16 = pLight_HslDefaultParam->PresentHslLightness16; - Appli_HslDefaultSet.HslDefaultHueLightness16 = pLight_HslDefaultParam->PresentHslHueLightness16; - Appli_HslDefaultSet.HslDefaultSaturation16 = pLight_HslDefaultParam->PresentHslSaturation16; + Appli_HslDefaultSet[elementIndex].HslDefaultLightness16 = pLight_HslDefaultParam->PresentHslLightness16; + Appli_HslDefaultSet[elementIndex].HslDefaultHueLightness16 = pLight_HslDefaultParam->PresentHslHueLightness16; + Appli_HslDefaultSet[elementIndex].HslDefaultSaturation16 = pLight_HslDefaultParam->PresentHslSaturation16; - AppliHslSet.HslLightness16 = Appli_HslDefaultSet.HslDefaultLightness16; - AppliHslSet.HslHueLightness16 = Appli_HslDefaultSet.HslDefaultHueLightness16; - AppliHslSet.HslSaturation16 = Appli_HslDefaultSet.HslDefaultSaturation16; + AppliHslSet[elementIndex].HslLightness16 = Appli_HslDefaultSet[elementIndex].HslDefaultLightness16; + AppliHslSet[elementIndex].HslHueLightness16 = Appli_HslDefaultSet[elementIndex].HslDefaultHueLightness16; + AppliHslSet[elementIndex].HslSaturation16 = Appli_HslDefaultSet[elementIndex].HslDefaultSaturation16; - HSL2RGB_Conversion(); + HSL2RGB_Conversion(elementIndex); - Appli_LightPwmValue.PwmRedValue = PwmValueMapping(Appli_RGBParam.Red_Value ,0xFFFF ,0x00); - Appli_LightPwmValue.PwmGreenValue = PwmValueMapping(Appli_RGBParam.Green_Value ,0xFFFF ,0x00); - Appli_LightPwmValue.PwmBlueValue = PwmValueMapping(Appli_RGBParam.Blue_Value ,0xFFFF ,0x00); + Appli_LightPwmValue.PwmRedValue = PwmValueMapping(Appli_RGBParam[elementIndex].Red_Value ,0xFFFF ,0x00); + Appli_LightPwmValue.PwmGreenValue = PwmValueMapping(Appli_RGBParam[elementIndex].Green_Value ,0xFFFF ,0x00); + Appli_LightPwmValue.PwmBlueValue = PwmValueMapping(Appli_RGBParam[elementIndex].Blue_Value ,0xFFFF ,0x00); Ctl_LedOffState(); Light_UpdateLedValue(LOAD_STATE , Appli_LightPwmValue); /* set the flag value for NVM store */ - RestoreFlag = LIGHT_HSL_NVM_FLAG; - - AppliNvm_SaveMessageParam(); + NvmStatePowerFlag_Set(LIGHT_HSL_NVM_FLAG, elementIndex); return MOBLE_RESULT_SUCCESS; } @@ -1092,17 +1310,18 @@ MOBLE_RESULT Appli_Light_HslDefault_Set(Light_HslStatus_t* pLight_HslDefaultPara * @param pLength: length of data * @retval MOBLE_RESULT */ -MOBLE_RESULT Appli_Light_HslDefault_Status(MOBLEUINT8 const *pHslDefault_status, MOBLEUINT32 pLength) +MOBLE_RESULT Appli_Light_HslDefault_Status(MOBLEUINT8 const *pHslDefault_status, MOBLEUINT32 pLength, MOBLEUINT16 dstPeer, + MOBLEUINT8 elementIndex) { -#ifdef CFG_DEBUG_TRACE +#if ( CFG_DEBUG_TRACE != 0 ) MOBLEUINT32 i; MOBLEUINT16 value = 0; #endif - TRACE_M(TF_LIGHT,"Light_HslDefault_Status callback received \r\n"); - TRACE_M(TF_SERIAL_CTRL,"#827C! \n\r"); - -#ifdef CFG_DEBUG_TRACE + TRACE_M(TF_LIGHT,"Light_HslDefault_Status callback received for element %d \r\n", elementIndex); + TRACE_M(TF_SERIAL_CTRL,"#827C!\r\n"); + +#if ( CFG_DEBUG_TRACE != 0 ) for(i = 0; i < pLength; i++) { if((i == 0) || (i == 2) || (i == 4)) @@ -1111,24 +1330,29 @@ MOBLE_RESULT Appli_Light_HslDefault_Status(MOBLEUINT8 const *pHslDefault_status, } else if(i == 1) { - TRACE_M(TF_LIGHT,"Lightness: %d \r\n", - value << 8 | pHslDefault_status[i]); + TRACE_M(TF_LIGHT,"Lightness: 0x%x (%d)\n\r", + value | pHslDefault_status[i] << 8, + value | pHslDefault_status[i] << 8); } else if(i == 3) { - TRACE_M(TF_LIGHT,"Hue: %d \r\n", - value << 8 | pHslDefault_status[i]); + TRACE_M(TF_LIGHT,"Hue: 0x%x (%d)\n\r", + value | pHslDefault_status[i] << 8, + value | pHslDefault_status[i] << 8); } - else if(i == 4) + else if(i == 5) { - TRACE_M(TF_LIGHT,"Saturation: %d \r\n", - value << 8 | pHslDefault_status[i]); + TRACE_M(TF_LIGHT,"Saturation: 0x%x (%d)\n\r", + value | pHslDefault_status[i] << 8, + value | pHslDefault_status[i] << 8); } } #endif + return MOBLE_RESULT_SUCCESS; } + /******************************************************************************/ #ifdef ENABLE_LIGHT_MODEL_SERVER_HSL_SETUP /******************************************************************************/ @@ -1141,14 +1365,16 @@ MOBLE_RESULT Appli_Light_HslDefault_Status(MOBLEUINT8 const *pHslDefault_status, * @retval MOBLE_RESULT */ MOBLE_RESULT Appli_Light_HslRange_Set(Light_HslRangeParam_t* pLight_HslRangeParam, - MOBLEUINT8 OptionalValid) + MOBLEUINT8 OptionalValid, MOBLEUINT16 dstPeer, + MOBLEUINT8 elementIndex) { - TRACE_M(TF_SERIAL_CTRL,"#8281! \n\r"); + TRACE_M(TF_LIGHT,"Light_HslRange_Set callback received for element %d \r\n", elementIndex); + TRACE_M(TF_SERIAL_CTRL,"#8281!\r\n"); - AppliHslRangeSet.HslHueMinRange16 = pLight_HslRangeParam->HslHueMinRange16; - AppliHslRangeSet.HslHueMaxRange16 = pLight_HslRangeParam->HslHueMaxRange16; - AppliHslRangeSet.HslMinSaturation16 = pLight_HslRangeParam->HslMinSaturation16; - AppliHslRangeSet.HslMaxSaturation16 = pLight_HslRangeParam->HslMaxSaturation16; + AppliHslRangeSet[elementIndex].HslHueMinRange16 = pLight_HslRangeParam->HslHueMinRange16; + AppliHslRangeSet[elementIndex].HslHueMaxRange16 = pLight_HslRangeParam->HslHueMaxRange16; + AppliHslRangeSet[elementIndex].HslMinSaturation16 = pLight_HslRangeParam->HslMinSaturation16; + AppliHslRangeSet[elementIndex].HslMaxSaturation16 = pLight_HslRangeParam->HslMaxSaturation16; return MOBLE_RESULT_SUCCESS; } @@ -1162,24 +1388,31 @@ MOBLE_RESULT Appli_Light_HslRange_Set(Light_HslRangeParam_t* pLight_HslRangePara * when Light HSL range status message is received * @param pHslRange_status: Pointer to the parameters received for message * @param pLength: length of data +* @param dstPeer: destination send by peer for this node. It can be a +* unicast or group address +* @param elementIndex: index of the element received from peer for this node which +* is elementNumber-1 * @retval MOBLE_RESULT */ -MOBLE_RESULT Appli_Light_HslRange_Status(MOBLEUINT8 const *pHslRange_status, MOBLEUINT32 pLength) +MOBLE_RESULT Appli_Light_HslRange_Status(MOBLEUINT8 const *pHslRange_status, MOBLEUINT32 pLength, MOBLEUINT16 dstPeer, + MOBLEUINT8 elementIndex) { -#ifdef CFG_DEBUG_TRACE +#if ( CFG_DEBUG_TRACE != 0 ) MOBLEUINT32 i; MOBLEUINT16 value = 0; #endif - TRACE_M(TF_LIGHT,"Light_HslRange_Status callback received \r\n"); - TRACE_M(TF_SERIAL_CTRL,"#827E! \n\r"); + TRACE_M(TF_LIGHT,"Light_HslRange_Status callback received for element %d \r\n", elementIndex); + TRACE_M(TF_SERIAL_CTRL,"#827E!\r\n"); + -#ifdef CFG_DEBUG_TRACE +#if ( CFG_DEBUG_TRACE != 0 ) for(i = 0; i < pLength; i++) { if(i == 0) { - TRACE_M(TF_LIGHT,"Status Code: %d \r\n", + TRACE_M(TF_LIGHT,"Status Code: 0x%x (%d)\n\r", + pHslRange_status[i], pHslRange_status[i]); } else if((i == 1) || (i == 3) || (i == 5) || (i == 7)) @@ -1188,30 +1421,36 @@ MOBLE_RESULT Appli_Light_HslRange_Status(MOBLEUINT8 const *pHslRange_status, MOB } else if(i == 2) { - TRACE_M(TF_LIGHT,"Hue Range Min: %d \r\n", - value << 8 | pHslRange_status[i]); + TRACE_M(TF_LIGHT,"Hue Range Min: 0x%x (%d)\n\r", + value | pHslRange_status[i] << 8, + value | pHslRange_status[i] << 8); } else if(i == 4) { - TRACE_M(TF_LIGHT,"Hue Range Max: %d \r\n", - value << 8 | pHslRange_status[i]); + TRACE_M(TF_LIGHT,"Hue Range Max: 0x%x (%d)\n\r", + value | pHslRange_status[i] << 8, + value | pHslRange_status[i] << 8); } else if(i == 6) { - TRACE_M(TF_LIGHT,"Saturation Range Min: %d \r\n", - value << 8 | pHslRange_status[i]); + TRACE_M(TF_LIGHT,"Saturation Range Min: 0x%x (%d)\n\r", + value | pHslRange_status[i] << 8, + value | pHslRange_status[i] << 8); } else if(i == 8) { - TRACE_M(TF_LIGHT,"Saturation Range Max: %d \r\n", - value << 8 | pHslRange_status[i]); + TRACE_M(TF_LIGHT,"Saturation Range Max: 0x%x (%d)\n\r", + value | pHslRange_status[i] << 8, + value | pHslRange_status[i] << 8); } } #endif + return MOBLE_RESULT_SUCCESS; } + /******************************************************************************* Following Functions are used for the LIGHTING Lightness MODEL *******************************************************************************/ @@ -1224,14 +1463,19 @@ Following Functions are used for the LIGHTING Lightness MODEL * @brief Appli_Light_GetLightnessStatus: This function is callback for Application * to get the application values in middleware used for transition change. * @param lLightnessState: Pointer to the status message +* @param dstPeer: destination send by peer for this node. It can be a +* unicast or group address +* @param elementIndex: index of the element received from peer for this node which +* is elementNumber-1 * @retval MOBLE_RESULT */ -MOBLE_RESULT Appli_Light_GetLightnessStatus(MOBLEUINT8* lLightnessState) +MOBLE_RESULT Appli_Light_GetLightnessStatus(MOBLEUINT8* lLightnessState, MOBLEUINT16 dstPeer, + MOBLEUINT8 elementIndex) { - *(lLightnessState) = ApplilightnessSet.PresentState16; - *(lLightnessState+1) = ApplilightnessSet.PresentState16 >> 8; - *(lLightnessState+2) = ApplilightnessSet.LastLightness16 ; - *(lLightnessState+3) = ApplilightnessSet.LastLightness16 >> 8; + *(lLightnessState) = ApplilightnessSet[elementIndex].PresentState16; + *(lLightnessState+1) = ApplilightnessSet[elementIndex].PresentState16 >> 8; + *(lLightnessState+2) = ApplilightnessSet[elementIndex].LastLightness16 ; + *(lLightnessState+3) = ApplilightnessSet[elementIndex].LastLightness16 >> 8; return MOBLE_RESULT_SUCCESS; } @@ -1241,17 +1485,19 @@ MOBLE_RESULT Appli_Light_GetLightnessStatus(MOBLEUINT8* lLightnessState) * @brief Appli_Light_GetLightnessLinearStatus: This function is callback for Application * to get the application values in middleware used for transition change. * @param lLightnessState: Pointer to the status message +* @param dstPeer: destination send by peer for this node. It can be a +* unicast or group address +* @param elementIndex: index of the element received from peer for this node which +* is elementNumber-1 * @retval MOBLE_RESULT */ -MOBLE_RESULT Appli_Light_GetLightnessLinearStatus(MOBLEUINT8* lLightnessState) +MOBLE_RESULT Appli_Light_GetLightnessLinearStatus(MOBLEUINT8* lLightnessState, MOBLEUINT16 dstPeer, + MOBLEUINT8 elementIndex) { - *(lLightnessState) = ApplilightnessLinearSet.PresentState16; - *(lLightnessState+1) = ApplilightnessLinearSet.PresentState16 >> 8; - *(lLightnessState+2) = ApplilightnessSet.LastLightness16 ; - *(lLightnessState+3) = ApplilightnessSet.LastLightness16 >> 8; - TRACE_M(TF_SERIAL_CTRL,"Get Lighness Linear Status: present: %d last: %d\n\r", - ApplilightnessLinearSet.PresentState16, - ApplilightnessSet.LastLightness16); + *(lLightnessState) = ApplilightnessLinearSet[elementIndex].PresentState16; + *(lLightnessState+1) = ApplilightnessLinearSet[elementIndex].PresentState16 >> 8; + *(lLightnessState+2) = ApplilightnessSet[elementIndex].LastLightness16 ; + *(lLightnessState+3) = ApplilightnessSet[elementIndex].LastLightness16 >> 8; return MOBLE_RESULT_SUCCESS; } @@ -1261,14 +1507,17 @@ MOBLE_RESULT Appli_Light_GetLightnessLinearStatus(MOBLEUINT8* lLightnessState) * @brief Appli_Light_GetLightnessDefaultStatus: This function is callback for Application * to get the application values in middleware used for transition change. * @param lDefaultState: Pointer to the status message +* @param dstPeer: destination send by peer for this node. It can be a +* unicast or group address +* @param elementIndex: index of the element received from peer for this node which +* is elementNumber-1 * @retval MOBLE_RESULT */ -MOBLE_RESULT Appli_Light_GetLightnessDefaultStatus(MOBLEUINT8* lDefaultState) +MOBLE_RESULT Appli_Light_GetLightnessDefaultStatus(MOBLEUINT8* lDefaultState, MOBLEUINT16 dstPeer, + MOBLEUINT8 elementIndex) { - *(lDefaultState) = ApplilightnessSet.LightnessDefault; - *(lDefaultState+1) = ApplilightnessSet.LightnessDefault >> 8; - TRACE_M(TF_SERIAL_CTRL,"Get Lighness Default Status: %d\n\r", - ApplilightnessSet.LightnessDefault); + *(lDefaultState) = ApplilightnessSet[elementIndex].LightnessDefault; + *(lDefaultState+1) = ApplilightnessSet[elementIndex].LightnessDefault >> 8; return MOBLE_RESULT_SUCCESS; } @@ -1280,13 +1529,11 @@ MOBLE_RESULT Appli_Light_GetLightnessDefaultStatus(MOBLEUINT8* lDefaultState) * @param lLastState: Pointer to the status message * @retval MOBLE_RESULT */ -MOBLE_RESULT Appli_Light_GetLightnessLastStatus(MOBLEUINT8* lLastState) +MOBLE_RESULT Appli_Light_GetLightnessLastStatus(MOBLEUINT8* lLastState, MOBLEUINT16 dstPeer, + MOBLEUINT8 elementIndex) { - *(lLastState) = ApplilightnessSet.LastLightness16; - *(lLastState+1) = ApplilightnessSet.LastLightness16 >> 8; - - TRACE_M(TF_SERIAL_CTRL,"Get Lighness Last Status: status: %d \n\r", - ApplilightnessSet.LastLightness16); + *(lLastState) = ApplilightnessSet[elementIndex].LastLightness16; + *(lLastState+1) = ApplilightnessSet[elementIndex].LastLightness16 >> 8; return MOBLE_RESULT_SUCCESS; } @@ -1295,19 +1542,20 @@ MOBLE_RESULT Appli_Light_GetLightnessLastStatus(MOBLEUINT8* lLastState) * @brief Appli_Light_GetLightnessRangeStatus: This function is callback for Application * to get the application values in middleware used for transition change. * @param lRangeState: Pointer to the status message +* @param dstPeer: destination send by peer for this node. It can be a +* unicast or group address +* @param elementIndex: index of the element received from peer for this node which +* is elementNumber-1 * @retval MOBLE_RESULT */ -MOBLE_RESULT Appli_Light_GetLightnessRangeStatus(MOBLEUINT8* lRangeState) +MOBLE_RESULT Appli_Light_GetLightnessRangeStatus(MOBLEUINT8* lRangeState, MOBLEUINT16 dstPeer, + MOBLEUINT8 elementIndex) { - *(lRangeState) = ApplilightnessSet.StatusCode; - *(lRangeState+1) = ApplilightnessSet.RangeMin; - *(lRangeState+2) = ApplilightnessSet.RangeMin >> 8; - *(lRangeState+3) = ApplilightnessSet.RangeMax; - *(lRangeState+4) = ApplilightnessSet.RangeMax >> 8; - TRACE_M(TF_SERIAL_CTRL,"Get Lighness Range Status: status: %d Min: %d Max: %d\n\r", - ApplilightnessSet.StatusCode, - ApplilightnessSet.RangeMin, - ApplilightnessSet.RangeMax); + *(lRangeState) = ApplilightnessSet[elementIndex].StatusCode; + *(lRangeState+1) = ApplilightnessSet[elementIndex].RangeMin; + *(lRangeState+2) = ApplilightnessSet[elementIndex].RangeMin >> 8; + *(lRangeState+3) = ApplilightnessSet[elementIndex].RangeMax; + *(lRangeState+4) = ApplilightnessSet[elementIndex].RangeMax >> 8; return MOBLE_RESULT_SUCCESS; } @@ -1328,40 +1576,67 @@ Following Functions are used for the LIGHTING CTL MODEL * @brief Appli_Light_GetCtlLightStatus: This function is callback for Application * to get the application values in middleware used for transition change. * @param lCtlLightState: Pointer to the status message +* @param dstPeer: destination send by peer for this node. It can be a +* unicast or group address +* @param elementIndex: index of the element received from peer for this node which +* is elementNumber-1 * @retval MOBLE_RESULT */ -MOBLE_RESULT Appli_Light_GetCtlLightStatus(MOBLEUINT8* lCtlLightState) +MOBLE_RESULT Appli_Light_GetCtlLightStatus(MOBLEUINT8* lCtlLightState, MOBLEUINT16 dstPeer, + MOBLEUINT8 elementIndex) { - *(lCtlLightState) = AppliCtlSet.PresentLightness16; - *(lCtlLightState+1) = AppliCtlSet.PresentLightness16 >> 8; - *(lCtlLightState+2) = AppliCtlSet.PresentTemperature16; - *(lCtlLightState+3) = AppliCtlSet.PresentTemperature16 >>8; - *(lCtlLightState+4) = AppliCtlSet.PresentCtlDelta16; - *(lCtlLightState+5) = AppliCtlSet.PresentCtlDelta16 >>8; - TRACE_M(TF_SERIAL_CTRL,"Get Ctl Light Status: lightness: %d temp: %d delta: %d\n\r", - AppliCtlSet.PresentLightness16, - AppliCtlSet.PresentTemperature16, - AppliCtlSet.PresentCtlDelta16); + *(lCtlLightState) = AppliCtlSet[elementIndex].PresentLightness16; + *(lCtlLightState+1) = AppliCtlSet[elementIndex].PresentLightness16 >> 8; + *(lCtlLightState+2) = AppliCtlSet[elementIndex].PresentTemperature16; + *(lCtlLightState+3) = AppliCtlSet[elementIndex].PresentTemperature16 >>8; + *(lCtlLightState+4) = AppliCtlSet[elementIndex].PresentCtlDelta16; + *(lCtlLightState+5) = AppliCtlSet[elementIndex].PresentCtlDelta16 >>8; return MOBLE_RESULT_SUCCESS; } /** +* @brief Appli_Light_GetCtlTargetStatus: This function is callback for Application +* to get the application values in middleware used for target state. +* @param lCtlLightState: Pointer to the status message +* @param dstPeer: destination send by peer for this node. It can be a +* unicast or group address +* @param elementIndex: index of the element received from peer for this node which +* is elementNumber-1 +* @retval MOBLE_RESULT +*/ +MOBLE_RESULT Appli_Light_GetCtlTargetStatus(MOBLEUINT8* lCtlLightState, MOBLEUINT16 dstPeer, + MOBLEUINT8 elementIndex) +{ + *(lCtlLightState) = AppliCtlSet[elementIndex].TargetLightness16; + *(lCtlLightState+1) = AppliCtlSet[elementIndex].TargetLightness16 >> 8; + *(lCtlLightState+2) = AppliCtlSet[elementIndex].TargetTemperature16; + *(lCtlLightState+3) = AppliCtlSet[elementIndex].TargetTemperature16 >>8; + *(lCtlLightState+4) = AppliCtlSet[elementIndex].TargetCtlDelta16; + *(lCtlLightState+5) = AppliCtlSet[elementIndex].TargetCtlDelta16 >>8; + + return MOBLE_RESULT_SUCCESS; +} + + +/** * @brief Appli_Light_GetCtlTeperatureStatus: This function is callback for Application * to get the application values in middleware used for transition change. * @param lCtlTempState: Pointer to the status message +* @param dstPeer: destination send by peer for this node. It can be a +* unicast or group address +* @param elementIndex: index of the element received from peer for this node which +* is elementNumber-1 * @retval MOBLE_RESULT */ -MOBLE_RESULT Appli_Light_GetCtlTemperatureStatus(MOBLEUINT8* lCtlTempState) +MOBLE_RESULT Appli_Light_GetCtlTemperatureStatus(MOBLEUINT8* lCtlTempState, MOBLEUINT16 dstPeer, + MOBLEUINT8 elementIndex) { - *(lCtlTempState) = AppliCtlSet.PresentTemperature16; - *(lCtlTempState+1) = AppliCtlSet.PresentTemperature16 >> 8; - *(lCtlTempState+2) = AppliCtlSet.PresentCtlDelta16; - *(lCtlTempState+3) = AppliCtlSet.PresentCtlDelta16 >>8; - TRACE_M(TF_SERIAL_CTRL,"Get Ctl Temperature Status: temp: %d delta: %d\n\r", - AppliCtlSet.PresentTemperature16, - AppliCtlSet.PresentCtlDelta16); + *(lCtlTempState) = AppliCtlSet[elementIndex].PresentTemperature16; + *(lCtlTempState+1) = AppliCtlSet[elementIndex].PresentTemperature16 >> 8; + *(lCtlTempState+2) = AppliCtlSet[elementIndex].PresentCtlDelta16; + *(lCtlTempState+3) = AppliCtlSet[elementIndex].PresentCtlDelta16 >>8; return MOBLE_RESULT_SUCCESS; } @@ -1371,19 +1646,20 @@ MOBLE_RESULT Appli_Light_GetCtlTemperatureStatus(MOBLEUINT8* lCtlTempState) * @brief Appli_Light_GetCtlTemperatureRange: This function is callback for Application * to get the application values in middleware used for transition change. * @param lCtlTempRange: Pointer to the status message +* @param dstPeer: destination send by peer for this node. It can be a +* unicast or group address +* @param elementIndex: index of the element received from peer for this node which +* is elementNumber-1 * @retval MOBLE_RESULT */ -MOBLE_RESULT Appli_Light_GetCtlTemperatureRange(MOBLEUINT8* lCtlTempRange) +MOBLE_RESULT Appli_Light_GetCtlTemperatureRange(MOBLEUINT8* lCtlTempRange, MOBLEUINT16 dstPeer, + MOBLEUINT8 elementIndex) { - *(lCtlTempRange) = AppliCtlTemperatureRangeSet.StatusCode; - *(lCtlTempRange+1) = AppliCtlTemperatureRangeSet.RangeMin; - *(lCtlTempRange+2) = AppliCtlTemperatureRangeSet.RangeMin >> 8; - *(lCtlTempRange+3) = AppliCtlTemperatureRangeSet.RangeMax; - *(lCtlTempRange+4) = AppliCtlTemperatureRangeSet.RangeMax >>8; - TRACE_M(TF_SERIAL_CTRL,"Get Ctl Temperature Range: status: %d Min: %d Max: %d\n\r", - AppliCtlTemperatureRangeSet.StatusCode, - AppliCtlTemperatureRangeSet.RangeMin, - AppliCtlTemperatureRangeSet.RangeMax); + *(lCtlTempRange) = AppliCtlTemperatureRangeSet[elementIndex].StatusCode; + *(lCtlTempRange+1) = AppliCtlTemperatureRangeSet[elementIndex].RangeMin; + *(lCtlTempRange+2) = AppliCtlTemperatureRangeSet[elementIndex].RangeMin >> 8; + *(lCtlTempRange+3) = AppliCtlTemperatureRangeSet[elementIndex].RangeMax; + *(lCtlTempRange+4) = AppliCtlTemperatureRangeSet[elementIndex].RangeMax >>8; return MOBLE_RESULT_SUCCESS; } @@ -1393,20 +1669,21 @@ MOBLE_RESULT Appli_Light_GetCtlTemperatureRange(MOBLEUINT8* lCtlTempRange) * @brief Appli_Light_GetCtlDefaultStatus: This function is callback for Application * to get the application values in middleware used for transition change. * @param lCtlDefaultState: Pointer to the status message +* @param dstPeer: destination send by peer for this node. It can be a +* unicast or group address +* @param elementIndex: index of the element received from peer for this node which +* is elementNumber-1 * @retval MOBLE_RESULT */ -MOBLE_RESULT Appli_Light_GetCtlDefaultStatus(MOBLEUINT8* lCtlDefaultState) +MOBLE_RESULT Appli_Light_GetCtlDefaultStatus(MOBLEUINT8* lCtlDefaultState, MOBLEUINT16 dstPeer, + MOBLEUINT8 elementIndex) { - *(lCtlDefaultState) = AppliCtlDefaultSet.CtlDefaultLightness16; - *(lCtlDefaultState+1) = AppliCtlDefaultSet.CtlDefaultLightness16 >> 8; - *(lCtlDefaultState+2) = AppliCtlDefaultSet.CtlDefaultTemperature16; - *(lCtlDefaultState+3) = AppliCtlDefaultSet.CtlDefaultTemperature16 >>8; - *(lCtlDefaultState+4) = AppliCtlDefaultSet.CtlDefaultDeltaUv; - *(lCtlDefaultState+5) = AppliCtlDefaultSet.CtlDefaultDeltaUv >>8; - TRACE_M(TF_SERIAL_CTRL,"Get Ctl Default Status: lightness: %d temp: %d deltaUV: %d\n\r", - AppliCtlDefaultSet.CtlDefaultLightness16, - AppliCtlDefaultSet.CtlDefaultTemperature16, - AppliCtlDefaultSet.CtlDefaultDeltaUv); + *(lCtlDefaultState) = AppliCtlDefaultSet[elementIndex].CtlDefaultLightness16; + *(lCtlDefaultState+1) = AppliCtlDefaultSet[elementIndex].CtlDefaultLightness16 >> 8; + *(lCtlDefaultState+2) = AppliCtlDefaultSet[elementIndex].CtlDefaultTemperature16; + *(lCtlDefaultState+3) = AppliCtlDefaultSet[elementIndex].CtlDefaultTemperature16 >>8; + *(lCtlDefaultState+4) = AppliCtlDefaultSet[elementIndex].CtlDefaultDeltaUv; + *(lCtlDefaultState+5) = AppliCtlDefaultSet[elementIndex].CtlDefaultDeltaUv >> 8; return MOBLE_RESULT_SUCCESS; } @@ -1427,36 +1704,65 @@ Following Functions are used for the LIGHTING HSL MODEL * @brief Appli_Light_GetHslStatus: This function is callback for Application * to get the application values in middleware used for transition change. * @param lHslState: Pointer to the status message +* @param dstPeer: destination send by peer for this node. It can be a +* unicast or group address +* @param elementIndex: index of the element received from peer for this node which +* is elementNumber-1 * @retval MOBLE_RESULT */ -MOBLE_RESULT Appli_Light_GetHslStatus(MOBLEUINT8* lHslState) +MOBLE_RESULT Appli_Light_GetHslStatus(MOBLEUINT8* lHslState, MOBLEUINT16 dstPeer, + MOBLEUINT8 elementIndex) { - *(lHslState) = AppliHslSet.HslLightness16; - *(lHslState+1) = AppliHslSet.HslLightness16 >> 8; - *(lHslState+2) = AppliHslSet.HslHueLightness16; - *(lHslState+3) = AppliHslSet.HslHueLightness16 >>8; - *(lHslState+4) = AppliHslSet.HslSaturation16; - *(lHslState+5) = AppliHslSet.HslSaturation16 >>8; - TRACE_M(TF_SERIAL_CTRL,"Get Hsl Status: lightness: %d hue: %d saturation: %d\n\r", - AppliHslSet.HslLightness16, - AppliHslSet.HslHueLightness16, - AppliHslSet.HslSaturation16); + *(lHslState) = AppliHslSet[elementIndex].HslLightness16; + *(lHslState+1) = AppliHslSet[elementIndex].HslLightness16 >> 8; + *(lHslState+2) = AppliHslSet[elementIndex].HslHueLightness16; + *(lHslState+3) = AppliHslSet[elementIndex].HslHueLightness16 >>8; + *(lHslState+4) = AppliHslSet[elementIndex].HslSaturation16; + *(lHslState+5) = AppliHslSet[elementIndex].HslSaturation16 >>8; return MOBLE_RESULT_SUCCESS; } + +/** +* @brief Appli_Light_GetHslTargetStatus: This function is callback for Application +* to get the application values in middleware used for target state. +* @param lHslState: Pointer to the status message +* @param dstPeer: destination send by peer for this node. It can be a +* unicast or group address +* @param elementIndex: index of the element received from peer for this node which +* is elementNumber-1 +* @retval MOBLE_RESULT +*/ +MOBLE_RESULT Appli_Light_GetHslTargetStatus(MOBLEUINT8* lHslState, MOBLEUINT16 dstPeer, + MOBLEUINT8 elementIndex) +{ + *(lHslState) = AppliHslSet[elementIndex].TargetHslLightness16; + *(lHslState+1) = AppliHslSet[elementIndex].TargetHslLightness16 >> 8; + *(lHslState+2) = AppliHslSet[elementIndex].TargetHslHueLightness16; + *(lHslState+3) = AppliHslSet[elementIndex].TargetHslHueLightness16 >>8; + *(lHslState+4) = AppliHslSet[elementIndex].TargetHslSaturation16; + *(lHslState+5) = AppliHslSet[elementIndex].TargetHslSaturation16 >>8; + + return MOBLE_RESULT_SUCCESS; +} + + /** * @brief Appli_Light_GetHslHueStatus: This function is callback for Application * to get the application values in middleware used for transition change. * @param lHslHueState: Pointer to the status message +* @param dstPeer: destination send by peer for this node. It can be a +* unicast or group address +* @param elementIndex: index of the element received from peer for this node which +* is elementNumber-1 * @retval MOBLE_RESULT */ -MOBLE_RESULT Appli_Light_GetHslHueStatus(MOBLEUINT8* lHslHueState) +MOBLE_RESULT Appli_Light_GetHslHueStatus(MOBLEUINT8* lHslHueState, MOBLEUINT16 dstPeer, + MOBLEUINT8 elementIndex) { - *(lHslHueState) = AppliHslSet.HslHueLightness16; - *(lHslHueState+1) = AppliHslSet.HslHueLightness16 >>8; - TRACE_M(TF_SERIAL_CTRL,"Get Hsl Hue Status: %d\n\r", - AppliHslSet.HslHueLightness16); + *(lHslHueState) = AppliHslSet[elementIndex].HslHueLightness16; + *(lHslHueState+1) = AppliHslSet[elementIndex].HslHueLightness16 >>8; return MOBLE_RESULT_SUCCESS; } @@ -1466,14 +1772,17 @@ MOBLE_RESULT Appli_Light_GetHslHueStatus(MOBLEUINT8* lHslHueState) * @brief Appli_Light_GetHslSaturationStatus: This function is callback for Application * to get the application values in middleware used for transition change * @param lHslSaturationState: Pointer to the status message +* @param dstPeer: destination send by peer for this node. It can be a +* unicast or group address +* @param elementIndex: index of the element received from peer for this node which +* is elementNumber-1 * @retval MOBLE_RESULT */ -MOBLE_RESULT Appli_Light_GetHslSaturationStatus(MOBLEUINT8* lHslSaturationState) +MOBLE_RESULT Appli_Light_GetHslSaturationStatus(MOBLEUINT8* lHslSaturationState, MOBLEUINT16 dstPeer, + MOBLEUINT8 elementIndex) { - *(lHslSaturationState) = AppliHslSet.HslSaturation16; - *(lHslSaturationState+1) = AppliHslSet.HslSaturation16 >>8; - TRACE_M(TF_SERIAL_CTRL,"Get Hsl Saturation Status: %d\n\r", - AppliHslSet.HslSaturation16); + *(lHslSaturationState) = AppliHslSet[elementIndex].HslSaturation16; + *(lHslSaturationState+1) = AppliHslSet[elementIndex].HslSaturation16 >>8; return MOBLE_RESULT_SUCCESS; } @@ -1482,16 +1791,21 @@ MOBLE_RESULT Appli_Light_GetHslSaturationStatus(MOBLEUINT8* lHslSaturationState) * @brief Appli_Light_GetHslDefaultStatus: This function is callback for Application * to get the application values in middleware used for transition change. * @param lHslDefaultState: Pointer to the status message +* @param dstPeer: destination send by peer for this node. It can be a +* unicast or group address +* @param elementIndex: index of the element received from peer for this node which +* is elementNumber-1 * @retval MOBLE_RESULT */ -MOBLE_RESULT Appli_Light_GetHslDefaultStatus(MOBLEUINT8* lHslDefaultState) +MOBLE_RESULT Appli_Light_GetHslDefaultStatus(MOBLEUINT8* lHslDefaultState, MOBLEUINT16 dstPeer, + MOBLEUINT8 elementIndex) { - *(lHslDefaultState) = Appli_HslDefaultSet.HslDefaultLightness16; - *(lHslDefaultState+1) = Appli_HslDefaultSet.HslDefaultLightness16 >> 8; - *(lHslDefaultState+2) = Appli_HslDefaultSet.HslDefaultHueLightness16; - *(lHslDefaultState+3) = Appli_HslDefaultSet.HslDefaultHueLightness16 >>8; - *(lHslDefaultState+4) = Appli_HslDefaultSet.HslDefaultSaturation16; - *(lHslDefaultState+5) = Appli_HslDefaultSet.HslDefaultSaturation16 >>8; + *(lHslDefaultState) = Appli_HslDefaultSet[elementIndex].HslDefaultLightness16; + *(lHslDefaultState+1) = Appli_HslDefaultSet[elementIndex].HslDefaultLightness16 >> 8; + *(lHslDefaultState+2) = Appli_HslDefaultSet[elementIndex].HslDefaultHueLightness16; + *(lHslDefaultState+3) = Appli_HslDefaultSet[elementIndex].HslDefaultHueLightness16 >>8; + *(lHslDefaultState+4) = Appli_HslDefaultSet[elementIndex].HslDefaultSaturation16; + *(lHslDefaultState+5) = Appli_HslDefaultSet[elementIndex].HslDefaultSaturation16 >>8; return MOBLE_RESULT_SUCCESS; } @@ -1500,19 +1814,20 @@ MOBLE_RESULT Appli_Light_GetHslDefaultStatus(MOBLEUINT8* lHslDefaultState) * @brief Appli_Light_GetHslSatRange: This function is callback for Application * to get the application values in middleware used for transition change * @param lHslSatRange: Pointer to the status message +* @param dstPeer: destination send by peer for this node. It can be a +* unicast or group address +* @param elementIndex: index of the element received from peer for this node which +* is elementNumber-1 * @retval MOBLE_RESULT */ -MOBLE_RESULT Appli_Light_GetHslSatRange(MOBLEUINT8* lHslSatRange) +MOBLE_RESULT Appli_Light_GetHslSatRange(MOBLEUINT8* lHslSatRange, MOBLEUINT16 dstPeer, + MOBLEUINT8 elementIndex) { - *(lHslSatRange) = AppliHslRangeSet.StatusCode; - *(lHslSatRange+1) = AppliHslRangeSet.HslMinSaturation16; - *(lHslSatRange+2) = AppliHslRangeSet.HslMinSaturation16 >> 8; - *(lHslSatRange+3) = AppliHslRangeSet.HslMaxSaturation16; - *(lHslSatRange+4) = AppliHslRangeSet.HslMaxSaturation16 >>8; - TRACE_M(TF_SERIAL_CTRL,"Get Hsl Saturation Range: status: %d min: %d max: %d\n\r", - AppliHslRangeSet.StatusCode, - AppliHslRangeSet.HslMinSaturation16, - AppliHslRangeSet.HslMaxSaturation16); + *(lHslSatRange) = AppliHslRangeSet[elementIndex].StatusCode; + *(lHslSatRange+1) = AppliHslRangeSet[elementIndex].HslMinSaturation16; + *(lHslSatRange+2) = AppliHslRangeSet[elementIndex].HslMinSaturation16 >> 8; + *(lHslSatRange+3) = AppliHslRangeSet[elementIndex].HslMaxSaturation16; + *(lHslSatRange+4) = AppliHslRangeSet[elementIndex].HslMaxSaturation16 >>8; return MOBLE_RESULT_SUCCESS; } @@ -1521,19 +1836,20 @@ MOBLE_RESULT Appli_Light_GetHslSatRange(MOBLEUINT8* lHslSatRange) * @brief Appli_Light_GetHslHueRange: This function is callback for Application * to get the application values in middleware used for transition change. * @param lHslHueRange: Pointer to the status message +* @param dstPeer: destination send by peer for this node. It can be a +* unicast or group address +* @param elementIndex: index of the element received from peer for this node which +* is elementNumber-1 * @retval MOBLE_RESULT */ -MOBLE_RESULT Appli_Light_GetHslHueRange(MOBLEUINT8* lHslHueRange) +MOBLE_RESULT Appli_Light_GetHslHueRange(MOBLEUINT8* lHslHueRange, MOBLEUINT16 dstPeer, + MOBLEUINT8 elementIndex) { - *(lHslHueRange) = AppliHslRangeSet.StatusCode; - *(lHslHueRange+1) = AppliHslRangeSet.HslHueMinRange16; - *(lHslHueRange+2) = AppliHslRangeSet.HslHueMinRange16 >> 8; - *(lHslHueRange+3) = AppliHslRangeSet.HslHueMaxRange16; - *(lHslHueRange+4) = AppliHslRangeSet.HslHueMaxRange16 >>8; - TRACE_M(TF_SERIAL_CTRL,"Get Hsl Hue Range: status: %d min: %d max: %d\n\r", - AppliHslRangeSet.StatusCode, - AppliHslRangeSet.HslHueMinRange16, - AppliHslRangeSet.HslHueMaxRange16); + *(lHslHueRange) = AppliHslRangeSet[elementIndex].StatusCode; + *(lHslHueRange+1) = AppliHslRangeSet[elementIndex].HslHueMinRange16; + *(lHslHueRange+2) = AppliHslRangeSet[elementIndex].HslHueMinRange16 >> 8; + *(lHslHueRange+3) = AppliHslRangeSet[elementIndex].HslHueMaxRange16; + *(lHslHueRange+4) = AppliHslRangeSet[elementIndex].HslHueMaxRange16 >>8; return MOBLE_RESULT_SUCCESS; } @@ -1563,21 +1879,24 @@ void Appli_Light_PwmInit() * @param value1: This value corresponds to red led. * @param value2: This value corresponds to green led . * @param value3: This value corresponds to blue led . +* @param elementIndex: index of the element received from peer for this node which +* is elementNumber-1 * @retval void */ -void RgbF_Create(MOBLEUINT16 value1, MOBLEUINT16 value2, MOBLEUINT16 value3) +void RgbF_Create(MOBLEUINT16 value1, MOBLEUINT16 value2, MOBLEUINT16 value3, MOBLEUINT8 elementIndex) { - Appli_RGBParam.Red_Value = (MOBLEUINT16)(65535 * value1/1000); - Appli_RGBParam.Green_Value = (MOBLEUINT16)(65535 * value2/1000); - Appli_RGBParam.Blue_Value = (MOBLEUINT16)(65535 * value3/1000); + Appli_RGBParam[elementIndex].Red_Value = (MOBLEUINT16)(65535 * value1/1000); + Appli_RGBParam[elementIndex].Green_Value = (MOBLEUINT16)(65535 * value2/1000); + Appli_RGBParam[elementIndex].Blue_Value = (MOBLEUINT16)(65535 * value3/1000); } /** * @brief Function to convert the HSL values in RGB values. -* @param void +* @param elementIndex: index of the element received from peer for this node which +* is elementNumber-1 * @retval void */ -void HSL2RGB_Conversion(void) +void HSL2RGB_Conversion(MOBLEUINT8 elementIndex) { MOBLEUINT16 hueValue; @@ -1587,24 +1906,24 @@ void HSL2RGB_Conversion(void) MOBLEUINT16 mValue; /* intermediate value used for creating the r,g,b baseline */ MOBLEUINT16 xValue; /* intermediate value used for computing r,g,b */ - if(AppliHslSet.HslSaturation16 == 0) + if(AppliHslSet[elementIndex].HslSaturation16 == 0) { - Appli_RGBParam.Red_Value = AppliHslSet.HslLightness16 ; - Appli_RGBParam.Green_Value = AppliHslSet.HslLightness16 ; - Appli_RGBParam.Blue_Value = AppliHslSet.HslLightness16 ; + Appli_RGBParam[elementIndex].Red_Value = AppliHslSet[elementIndex].HslLightness16 ; + Appli_RGBParam[elementIndex].Green_Value = AppliHslSet[elementIndex].HslLightness16 ; + Appli_RGBParam[elementIndex].Blue_Value = AppliHslSet[elementIndex].HslLightness16 ; } - else if((AppliHslSet.HslLightness16 == 0xFFFF) || (AppliHslSet.HslLightness16 == 0x00)) + else if((AppliHslSet[elementIndex].HslLightness16 == 0xFFFF) || (AppliHslSet[elementIndex].HslLightness16 == 0x00)) { - Appli_RGBParam.Red_Value = AppliHslSet.HslLightness16 ; - Appli_RGBParam.Green_Value = AppliHslSet.HslLightness16 ; - Appli_RGBParam.Blue_Value = AppliHslSet.HslLightness16 ; + Appli_RGBParam[elementIndex].Red_Value = AppliHslSet[elementIndex].HslLightness16 ; + Appli_RGBParam[elementIndex].Green_Value = AppliHslSet[elementIndex].HslLightness16 ; + Appli_RGBParam[elementIndex].Blue_Value = AppliHslSet[elementIndex].HslLightness16 ; } else { /* Hue is calculated for angular value. so converting in between 0 to 360 degree */ - hueValue = (MOBLEUINT16)(360 * (float)AppliHslSet.HslHueLightness16/65535); - lightnessvalue = (float)AppliHslSet.HslLightness16/65535; - saturationValue = (float)AppliHslSet.HslSaturation16/65535; + hueValue = (MOBLEUINT16)(360 * (float)AppliHslSet[elementIndex].HslHueLightness16/65535); + lightnessvalue = (float)AppliHslSet[elementIndex].HslLightness16/65535; + saturationValue = (float)AppliHslSet[elementIndex].HslSaturation16/65535; /* Formula to get the values used for RGB conversion */ cValue = (MOBLEUINT16)(((1- fabs(2 * lightnessvalue-1))*saturationValue) * 1000); @@ -1614,33 +1933,33 @@ void HSL2RGB_Conversion(void) /* Conditons applied for the different angle of hue value */ if (hueValue > 0 && hueValue < (HUE_UPPER_LIMIT / 6)) { - RgbF_Create(cValue + mValue, xValue + mValue, mValue); + RgbF_Create(cValue + mValue, xValue + mValue, mValue, elementIndex); } else if (hueValue >= (HUE_UPPER_LIMIT / 6) && hueValue < (HUE_UPPER_LIMIT / 3)) { - RgbF_Create(xValue + mValue, cValue + mValue, mValue); + RgbF_Create(xValue + mValue, cValue + mValue, mValue, elementIndex); } else if (hueValue >= (HUE_UPPER_LIMIT / 3) && hueValue < (HUE_UPPER_LIMIT / 2)) { - RgbF_Create(mValue, cValue + mValue, xValue + mValue); + RgbF_Create(mValue, cValue + mValue, xValue + mValue, elementIndex); } else if (hueValue >= (HUE_UPPER_LIMIT / 2) && hueValue < (2 * HUE_UPPER_LIMIT / 3)) { - RgbF_Create(mValue, xValue + mValue, cValue + mValue); + RgbF_Create(mValue, xValue + mValue, cValue + mValue, elementIndex); } else if (hueValue >= (2 * HUE_UPPER_LIMIT / 3) && hueValue < (5 * HUE_UPPER_LIMIT / 6)) { - RgbF_Create(xValue + mValue, mValue, cValue + mValue); + RgbF_Create(xValue + mValue, mValue, cValue + mValue, elementIndex); } else if ((hueValue >= (5 * HUE_UPPER_LIMIT / 6) && hueValue <= HUE_UPPER_LIMIT) || (hueValue == 0)) { - RgbF_Create(cValue + mValue, mValue, xValue + mValue); + RgbF_Create(cValue + mValue, mValue, xValue + mValue, elementIndex); } else { - RgbF_Create(mValue, mValue, mValue); + RgbF_Create(mValue, mValue, mValue, elementIndex); } } } @@ -1778,5 +2097,5 @@ void Light_UpdateLedValue(MOBLEUINT8 state ,Appli_LightPwmValue_t light_state) /** * @} */ -/******************* (C) COPYRIGHT 2019 STMicroelectronics *****END OF FILE****/ +/******************* (C) COPYRIGHT 2020 STMicroelectronics *****END OF FILE****/ |