diff --git a/Core/Inc/sts_weight_scale.h b/Core/Inc/sts_weight_scale.h index 4367621..33b623d 100644 --- a/Core/Inc/sts_weight_scale.h +++ b/Core/Inc/sts_weight_scale.h @@ -44,6 +44,22 @@ typedef struct } sts_sensor_t; +typedef struct +{ + uint32_t weight_scale_value; + uint8_t tare_off; + uint8_t calibration_knob_value; + uint8_t zero; + uint8_t measure_unit; /* 01: g, 02: kg, 03:pnd, 04: ton */ + float gapvalue; + float gapvalue_default; + uint8_t calibrated; /* 0: not calibrated, 1: calibrated */ + uint16_t range_high; + uint16_t range_low; + uint16_t resolution; + uint16_t range_overload; + +} sts_weight_scale_cfg_t; void sts_weight_scale_init(void); void sts_weight_scale(void); diff --git a/Core/Src/main.c b/Core/Src/main.c index 3264a4b..510ff9b 100644 --- a/Core/Src/main.c +++ b/Core/Src/main.c @@ -104,7 +104,8 @@ int main(void) /* Initialize all configured peripherals */ MX_GPIO_Init(); PME_ON; -#if 0 + //vcom_DeInit(); +#if 1 if(__HAL_PWR_GET_FLAG(PWR_FLAG_SB) != RESET) { __HAL_PWR_CLEAR_FLAG(PWR_FLAG_SB); @@ -120,7 +121,7 @@ int main(void) MX_LoRaWAN_Init(); } - sts_weight_scale_init(); + //sts_weight_scale_init(); /* USER CODE BEGIN 2 */ diff --git a/Core/Src/stm32_lpm_if.c b/Core/Src/stm32_lpm_if.c index 5523477..6e7824b 100644 --- a/Core/Src/stm32_lpm_if.c +++ b/Core/Src/stm32_lpm_if.c @@ -78,22 +78,56 @@ const struct UTIL_LPM_Driver_s UTIL_PowerDriver = void PWR_EnterOffMode(void) { +#if 1 /* USER CODE BEGIN EnterOffMode_1 */ + HAL_GPIO_DeInit(GPIOA,GPIO_PIN_All); + HAL_GPIO_DeInit(GPIOB,GPIO_PIN_All); + HAL_GPIO_DeInit(GPIOC,GPIO_PIN_All); + HAL_SuspendTick(); + // SHOULD ADD FOLLOWING LINES + /* Clear Status Flag before entering STOP/STANDBY Mode */ + LL_PWR_ClearFlag_C1STOP_C1STB(); + + + HAL_PWR_EnterSTANDBYMode(); +#endif /* USER CODE END EnterOffMode_1 */ } void PWR_ExitOffMode(void) { +#if 1 /* USER CODE BEGIN ExitOffMode_1 */ + /* USER CODE BEGIN ExitOffMode_1 */ + HAL_ResumeTick(); + // SHOULD ADD FOLLOWING LINES + PME_ON; + /*Not retained periph: + ADC interface + DAC interface USARTx, TIMx, i2Cx, SPIx + SRAM ctrls, DMAx, DMAMux, AES, RNG, HSEM */ + + /* Resume not retained USARTx and DMA */ + //vcom_Resume(); + /* USER CODE BEGIN ExitStopMode_2 */ + MX_GPIO_Init(); + MX_DMA_Init(); + MX_I2C2_Init(); +#endif /* USER CODE END ExitOffMode_1 */ } void PWR_EnterStopMode(void) { /* USER CODE BEGIN EnterStopMode_1 */ - + PME_OFF; +#if 1 + HAL_GPIO_DeInit(GPIOA,GPIO_PIN_All); + HAL_GPIO_DeInit(GPIOB,GPIO_PIN_All); + HAL_GPIO_DeInit(GPIOC,GPIO_PIN_All); +#endif /* USER CODE END EnterStopMode_1 */ HAL_SuspendTick(); /* Clear Status Flag before entering STOP/STANDBY Mode */ diff --git a/Core/Src/sts_weight_scale.c b/Core/Src/sts_weight_scale.c index ff44407..1fd31a7 100644 --- a/Core/Src/sts_weight_scale.c +++ b/Core/Src/sts_weight_scale.c @@ -21,13 +21,13 @@ #include "sts_weight_scale.h" #include uint32_t HX711_Buffer=0; -volatile uint32_t gross_weight; +volatile uint32_t gross_weight=0; volatile int32_t net_weight; uint8_t Flag_Error; volatile uint32_t last_net_weight=0; volatile sts_sensor_t sts_sensor_data; volatile uint32_t sts_weight_scale_value_g = 0, sts_weight_tare_g=0; - +volatile sts_weight_scale_cfg_t ws_cfg={0, 0, 1, 0, 1, 276.2394, 276.2394, 0, 5000, 0, 1,6000}; //校准参数 @@ -51,6 +51,14 @@ void sts_weight_scale_init(void) { HX711_Init(); Get_GrossWeight(); + if (ws_cfg.calibrated !=0) + { + sts_gap_value = ws_cfg.gapvalue; + } else { + sts_gap_value = ws_cfg.gapvalue_default; + } + + //APP_LOG(TS_OFF, VLEVEL_M, "\r\n --- GapValue=%u \r\n", (int)sts_gap_value); } void sts_weight_scale_tare_off(void) @@ -64,48 +72,25 @@ void sts_weight_scale_zero(void) } void sts_weight_calibration(uint8_t knob_weights_in_kg) { - uint32_t diff_value=0.0, tmp_gap_value=0; + float calibrated_gap_value=0.0; HX711_Buffer = HX711_Read(); if(HX711_Buffer >= gross_weight) { net_weight = HX711_Buffer; net_weight = net_weight - gross_weight; //获取实物的AD采样数值。 - tmp_gap_value = net_weight/(1000*knob_weights_in_kg); + calibrated_gap_value = (float)net_weight/(1000.0*knob_weights_in_kg); } - APP_LOG(TS_OFF, VLEVEL_M, "\r\n gap Value =%u \r\n", tmp_gap_value); - - APP_LOG(TS_OFF, VLEVEL_M, "\r\n GapValue == %u \r\n", sts_gap_value); - - while(0) - { - HX711_Buffer = HX711_Read(); - if(HX711_Buffer >= gross_weight) - { - net_weight = HX711_Buffer; - net_weight = net_weight - gross_weight; //获取实物的AD采样数值。 - tmp_gap_value = net_weight/(1000*knob_weights_in_kg); - - //net_weight = (int32_t)((float)net_weight/(float)GapValue); //计算实物的实际重量 - net_weight = (int32_t)((float)net_weight/(float)sts_gap_value); //计算实物的实际重量 - } + //APP_LOG(TS_OFF, VLEVEL_M, "\r\n Previous GapValue == %u \r\n", (int)sts_gap_value); + //APP_LOG(TS_OFF, VLEVEL_M, "\r\n Calibrated GapValue == %u \r\n", (int)calibrated_gap_value); - diff_value = (int32_t)(net_weight - knob_weights_in_kg*1000); - if ( diff_value > 0 ) - { - sts_gap_value +=0.1; + ws_cfg.calibrated = 1; + sts_gap_value = calibrated_gap_value; + ws_cfg.gapvalue = calibrated_gap_value; - } else if (diff_value < 0) { - - sts_gap_value -=0.1; - } - - if ((diff_value <= 0.1) && (diff_value >=0)) - break; - - } + //APP_LOG(TS_OFF, VLEVEL_M, "\r\n --------Calibrated GapValue =%u \r\n", (int)sts_gap_value); #if 0 APP_LOG(TS_OFF, VLEVEL_M, "\r\n ##### Knob Weight=%u, We got =%u, Diff =%u GapValue=%u\r\n", @@ -122,37 +107,19 @@ void sts_weight_calibration(uint8_t knob_weights_in_kg) void sts_weight_scale(void) { - //PME_ON; - //HAL_Delay(500); + PME_ON; + //APP_LOG(TS_OFF, VLEVEL_M, "\r\n STS_GAP_VALUE=%u \r\n STS_CALIBRATED=%u \r\n STS_GAP_DEFAULT=%u \r\n GapValue\r\n", + //(int)sts_gap_value, (int)ws_cfg.calibrated, (int)ws_cfg.gapvalue_default, (int)ws_cfg.gapvalue); + HAL_Delay(100); + Get_NetWeight(); + sts_weight_scale_value_g = net_weight; -#if 0 - for (uint8_t cnt=0;cnt<20;cnt++) - { - Get_NetWeight(); - sum_tmp_net_weight += net_weight; - } - net_weight = (uint32_t)((float)sum_tmp_net_weight/20.0); - - APP_LOG(TS_OFF, VLEVEL_M, "\r\nAverage Net Weight = %d g \r\n", net_weight); - - sts_weight_scale_value_g = net_weight; - - // re-calibrate or Zero if changes > 100g - if ((fabs(last_net_weight - net_weight) > 100) && (net_weight > 100)) - { - APP_LOG(TS_OFF, VLEVEL_M, "\r\n Zero ...Get Gross weight\r\n"); - Get_GrossWeight(); - APP_LOG(TS_OFF, VLEVEL_M, "\r\n Zero ...done Gross=%d \r\n",gross_weight); - //HAL_Delay(2000); - //Get_NetWeight(); - } -#endif - last_net_weight = net_weight; + last_net_weight = net_weight; + APP_LOG(TS_OFF, VLEVEL_M, "\r\n STS_WEIGHT SCALE =%u \r\n", (int)net_weight); //HAL_Delay(2000); - //PME_OFF; } @@ -210,7 +177,7 @@ uint32_t HX711_Read(void) //增益128 if (HAL_GPIO_ReadPin(HX711_DOUT_PORT, HX711_DOUT_PIN)==GPIO_PIN_SET) delay_us(1); else break; - }while (timer++<500000); + }while (timer++<500000); // keep this no touch, otherwise get 0x800000 for ever #endif delay_us(1); @@ -261,8 +228,8 @@ void Get_GrossWeight(void) void Get_NetWeight(void) { HX711_Buffer = HX711_Read(); - //APP_LOG(TS_OFF, VLEVEL_M, "\r\n ----- Get Netweight =%d while last gross weight=%d \r\n", HX711_Buffer, gross_weight); - if(HX711_Buffer >= gross_weight) + + if(HX711_Buffer > gross_weight) { net_weight = HX711_Buffer; net_weight = net_weight - gross_weight; //获取实物的AD采样数值。 @@ -277,7 +244,7 @@ void Get_NetWeight(void) } else { net_weight = 0; - APP_LOG(TS_OFF, VLEVEL_M, "\r\n ----- less than gross weight\r\n"); + APP_LOG(TS_OFF, VLEVEL_L, "\r\n %d----- less than gross weight\r\n", net_weight); } } diff --git a/LoRaWAN/App/lora_app.c b/LoRaWAN/App/lora_app.c index 86f465c..0d02395 100644 --- a/LoRaWAN/App/lora_app.c +++ b/LoRaWAN/App/lora_app.c @@ -1118,7 +1118,7 @@ static void SendTxData(void) AppData.BufferSize = i&(~sts_service_mask); - APP_LOG(TS_OFF, VLEVEL_M, "\r\nAppdata.buffersize = %d", AppData.BufferSize); + //APP_LOG(TS_OFF, VLEVEL_M, "\r\nAppdata.buffersize = [ %d ]\r\n", AppData.BufferSize); if ((JoinLedTimer.IsRunning) && (LmHandlerJoinStatus() == LORAMAC_HANDLER_SET)) { @@ -1252,14 +1252,15 @@ static void OnJoinRequest(LmHandlerJoinParams_t *joinParams) { APP_LOG(TS_OFF, VLEVEL_M, "OTAA =====================\r\n"); } + AppData.Port = 1; AppData.BufferSize = 16; - UTIL_MEM_cpy_8((uint8_t*)AppData.Buffer, (uint8_t *)"YUNHORN168", 10); - UTIL_MEM_cpy_8((uint8_t*)AppData.Buffer+10, (uint8_t *)(uint8_t*)YUNHORN_STS_PRD_STRING, sizeof(YUNHORN_STS_PRD_STRING)); - AppData.BufferSize = sizeof(YUNHORN_STS_PRD_STRING)+10; - LmHandlerParams.IsTxConfirmed = true; + //UTIL_MEM_cpy_8((uint8_t*)AppData.Buffer, (uint8_t *)"YUNHORN168", 10); + UTIL_MEM_cpy_8((uint8_t*)AppData.Buffer, (uint8_t*)YUNHORN_STS_PRD_STRING, sizeof(YUNHORN_STS_PRD_STRING)); + AppData.BufferSize = sizeof(YUNHORN_STS_PRD_STRING); + LmHandlerParams.IsTxConfirmed = LORAMAC_HANDLER_CONFIRMED_MSG; LmHandlerErrorStatus_t status = LmHandlerSend(&AppData, LmHandlerParams.IsTxConfirmed, false); - if (status ==LORAMAC_HANDLER_SUCCESS ) LmHandlerParams.IsTxConfirmed = false; + if (status ==LORAMAC_HANDLER_SUCCESS ) LmHandlerParams.IsTxConfirmed = !LORAMAC_HANDLER_CONFIRMED_MSG; } else { diff --git a/STM32CubeIDE/Release/WLE5CC_NODE_STS.elf b/STM32CubeIDE/Release/WLE5CC_NODE_STS.elf index fee4a8b..e38afe9 100644 Binary files a/STM32CubeIDE/Release/WLE5CC_NODE_STS.elf and b/STM32CubeIDE/Release/WLE5CC_NODE_STS.elf differ diff --git a/STS/Core/Inc/yunhorn_sts_sensors.h b/STS/Core/Inc/yunhorn_sts_sensors.h index 88fbac2..1bdb6cb 100644 --- a/STS/Core/Inc/yunhorn_sts_sensors.h +++ b/STS/Core/Inc/yunhorn_sts_sensors.h @@ -47,7 +47,11 @@ enum cfg_cmd_order{ CFG_CMD3, // # Z {H, S, C} M {0,1,2,3,4] CFG_CMD4, // # CFG_CMD5, // 'S','M','H' - CFG_CMD6 + CFG_CMD6, + CFG_CMD7, + CFG_CMD8, + CFG_CMD9, + CFG_CMD10 }; enum p_cmd_order{ P_CMD=0, //'P' //P_MTM_CODE, // #1 @@ -162,11 +166,18 @@ typedef struct sts_cfg_nvm { uint8_t sts_ioc_mask; // I/O Control mask enable all 0xFF, Disable all 0x00 0b0000 0000 uint8_t length; // length of following parameters except AC CODE(20bytes) uint8_t p[STS_CFG_PCFG_SIZE]; +#ifdef STS_R6 + uint8_t ws_cfg_1; + uint8_t ws_cfg_2; + uint8_t ws_cfg_3; + uint8_t ws_cfg_4; +#else uint8_t reserve02; uint8_t reserve03; uint8_t sensor_install_height_in_10cm; uint8_t alarm_parameter05; +#endif uint8_t alarm_mute_reset_timer_in_10sec; //60(0x3C) sec alarm_mute_or_reset_expire_timer_in_sec uint8_t alarm_lamp_bar_flashing_color; //Lamp Bar Flashing color define, 0x20, 2==STS_RED, 0 = STS_DARK, 0x23, 2=STS_RED, 3=STS_BLUE uint8_t occupancy_overtime_threshold_in_10min; // 0 - 9： 0：disable, 1-9 occupy over time threshold * 10 min diff --git a/STS/Core/Src/yunhorn_sts_process.c b/STS/Core/Src/yunhorn_sts_process.c index 0a35d5f..595a041 100644 --- a/STS/Core/Src/yunhorn_sts_process.c +++ b/STS/Core/Src/yunhorn_sts_process.c @@ -86,6 +86,11 @@ volatile sts_cfg_nvm_t sts_cfg_nvm = { 0x0,0x8,0x10,0x0,0x3,0x8,0x21,0x1,0xaf,0xe7, //current work config profile short 0x1,0x8,0x10,0x0,0x3,0x8,0x21,0x1,0xaf,0xe7, //current work config profile long, after measured distance // change the max distance, min distance, SPAD, front center and back center, etc. +#elif defined(STS_R6) + 0x00, //tare off + 0x01, // calibration knob value in kg + 0x00, // zero + 0x01, // measure unit, 01:g, 02:kg, 03:pnd, 04:ton #else 0x08, //start_m [8]*0.1 meter =0.8 0x19, //lenght_m 0x19=[25]*0.1=2.5f meter @@ -137,6 +142,7 @@ volatile uint8_t sensor_data_ready=0; #if defined(STS_WS)||defined(STS_R6) extern volatile uint32_t sts_weight_scale_value_g, sts_weight_tare_g; +extern volatile sts_weight_scale_cfg_t ws_cfg; #endif #if defined(STS_R1)||defined(STS_R5)||defined(STS_R4)||defined(STS_R1D)||defined(STS_O5)||defined(STS_M1)||defined(STS_R6) @@ -576,6 +582,7 @@ void STS_YunhornSTSEventP9_Process(void) //sts_weight_scale_init(); sts_weight_scale(); + #endif } @@ -673,9 +680,9 @@ void STS_O5_SENSOR_Read(STS_OO_SensorDataTypeDef *oo_data) void USER_APP_Parse_CMD_P(uint8_t *parse_buffer, uint8_t parse_buffer_size) { -#if defined(STS_P2)||defined(STS_O6T)||defined(STS_T6)||defined(STS_O7)||defined(STS_O5) - switch (parse_buffer_size) { + switch (parse_buffer_size) { +#if defined(STS_P2)||defined(STS_O6T)||defined(STS_T6)||defined(STS_O7)||defined(STS_O5) case 4: sts_work_mode = (uint8_t)(parse_buffer[CFG_CMD4]-0x30); switch (sts_work_mode) { @@ -711,10 +718,72 @@ void USER_APP_Parse_CMD_P(uint8_t *parse_buffer, uint8_t parse_buffer_size) break; } break; +#endif + case 5: break; + +#ifdef STS_R6 + // Weight Scale STS_R6 + // P11WXYY + case 7: + if ((parse_buffer[CFG_CMD4]=='W') && (parse_buffer[CFG_CMD5]>='0')&& (parse_buffer[CFG_CMD5]<='9')) + { + uint8_t sts_ws_cfg_index = (uint8_t)(parse_buffer[CFG_CMD5]-0x30); + uint8_t sts_ws_cfg_value = (parse_buffer[CFG_CMD6]-0x30)*10+(parse_buffer[CFG_CMD7]-0x30); + APP_LOG(TS_OFF, VLEVEL_M, "\r\nCFG_CMD Index=%d, VALUE =0X%02X =%d \r\n", sts_ws_cfg_index, sts_ws_cfg_value,sts_ws_cfg_value); + switch (sts_ws_cfg_index) { + case 1: // head level height threshold + ws_cfg.tare_off = sts_ws_cfg_value; + sts_weight_scale_tare_off(); + break; + case 2: + ws_cfg.calibration_knob_value = sts_ws_cfg_value; + sts_weight_calibration(ws_cfg.calibration_knob_value); + break; + case 3: + ws_cfg.zero = sts_ws_cfg_value; + sts_weight_scale_zero(); + break; + case 4: + ws_cfg.measure_unit = sts_ws_cfg_value; + + break; + + + default: + break; + } + sts_cfg_nvm.ws_cfg_1 = ws_cfg.tare_off; + sts_cfg_nvm.ws_cfg_2 = ws_cfg.zero; + sts_cfg_nvm.ws_cfg_3 = ws_cfg.calibration_knob_value; + sts_cfg_nvm.ws_cfg_4 = ws_cfg.measure_unit; + + OnStoreSTSCFGContextRequest(); + // 2024-11-18 + UTIL_MEM_set_8((void*)outbuf, 0x0, sizeof(outbuf)); + UTIL_MEM_cpy_8((void*)outbuf,(void*)parse_buffer,parse_buffer_size); + uint8_t i = parse_buffer_size; + + + if (ws_cfg.calibrated) { + i++; + uint32_t gap_report=ws_cfg.gapvalue*1000;; + + outbuf[i++] = gap_report<<24&0xff; + outbuf[i++] = gap_report<<16&0xff; + outbuf[i++] = gap_report<<8&0xff; + outbuf[i++] = gap_report&0xff; + } + + STS_SENSOR_Upload_Message(YUNHORN_STS_USER_APP_CTRL_REPLY_PORT, i, (uint8_t *)outbuf); + + } + break; +#endif case 12: break; +#ifdef STS_P2 case 13: for (uint8_t i=0; i<10; i++) { sts_cfg_nvm.p[i] = (uint8_t)parse_buffer[CFG_CMD4+i]; @@ -730,11 +799,11 @@ void USER_APP_Parse_CMD_P(uint8_t *parse_buffer, uint8_t parse_buffer_size) ppc_cfg[parse_buffer[CFG_CMD4]].front_zone_center = (uint8_t)parse_buffer[CFG_CMD4+8]; ppc_cfg[parse_buffer[CFG_CMD4]].back_zone_center = (uint8_t)parse_buffer[CFG_CMD4+9]; break; - +#endif default: break; } -#endif + } // following to be fill up @@ -1141,6 +1210,7 @@ void USER_APP_AUTO_RESPONDER_Parse(uint8_t *parse_buffer, uint8_t parse_buffer_s STS_SENSOR_Upload_Message(YUNHORN_STS_USER_APP_CTRL_REPLY_PORT, i, (uint8_t *)outbuf); break; case 'D': /* "YZD": Distance/Install height Measure */ +#if defined(STS_O6)||defined(STS_P2)||defined(STS_L8)||defined(STS_O7) STS_SENSOR_Distance_Test_Process(); sts_cfg_nvm.sensor_install_height_in_10cm = sts_sensor_install_height/100; //in 10 cm, say 4500mm=450cm=45 dm APP_LOG(TS_OFF, VLEVEL_M, "\n STS CFG NVM -> SENSOR INSTALL HEIGHT STORED = %d dm(10cm)\n", sts_cfg_nvm.sensor_install_height_in_10cm); @@ -1153,6 +1223,7 @@ void USER_APP_AUTO_RESPONDER_Parse(uint8_t *parse_buffer, uint8_t parse_buffer_s outbuf[i++] = (uint8_t)sts_hardware_ver; outbuf[i++] = (uint8_t)(99*((GetBatteryLevel()/254)&0xff)); outbuf[i++] = (uint8_t)(2); //two bytes for distance +#endif #if defined(VL53LX)||defined(VL53L0) #if 0 outbuf[i++] = (uint8_t)(sts_sensor_install_height/1000+0x30)&0xff; @@ -1165,6 +1236,7 @@ void USER_APP_AUTO_RESPONDER_Parse(uint8_t *parse_buffer, uint8_t parse_buffer_s #endif STS_SENSOR_Upload_Message(YUNHORN_STS_USER_APP_CTRL_REPLY_PORT, i, (uint8_t *)outbuf); + break; case 'M': /* "YZM": Mask level */ i = 0; @@ -1611,11 +1683,18 @@ void OnStoreSTSCFGContextRequest(void) for (j = 0; j < STS_CFG_PCFG_SIZE; j++) { to_store__value[i++] = (sts_cfg_nvm.p[j]); } +#ifdef STS_R6 + to_store__value[i++] = sts_cfg_nvm.ws_cfg_1; + to_store__value[i++] = sts_cfg_nvm.ws_cfg_2; + to_store__value[i++] = sts_cfg_nvm.ws_cfg_3; + to_store__value[i++] = sts_cfg_nvm.ws_cfg_4; +#else to_store__value[i++] = sts_cfg_nvm.reserve02; to_store__value[i++] = sts_cfg_nvm.reserve03; to_store__value[i++] = sts_cfg_nvm.sensor_install_height_in_10cm; to_store__value[i++] = sts_cfg_nvm.alarm_parameter05; +#endif to_store__value[i++] = sts_cfg_nvm.alarm_mute_reset_timer_in_10sec; to_store__value[i++] = sts_cfg_nvm.alarm_lamp_bar_flashing_color; to_store__value[i++] = sts_cfg_nvm.occupancy_overtime_threshold_in_10min; @@ -1708,11 +1787,18 @@ void STS_REBOOT_CONFIG_Init(void) for (uint8_t j=0; j< sts_cfg_nvm.length; j++) { sts_cfg_nvm.p[j] = (uint8_t)nvm_store_value[NVM_CFG_START+j]; } +#ifdef STS_R6 + sts_cfg_nvm.ws_cfg_1 =(uint8_t)nvm_store_value[NVM_RESERVE02]; + sts_cfg_nvm.ws_cfg_2 =(uint8_t)nvm_store_value[NVM_RESERVE03]; + sts_cfg_nvm.ws_cfg_3 =(uint8_t)nvm_store_value[NVM_SENSOR_INSTALL_HEIGHT]; + sts_cfg_nvm.ws_cfg_4 =(uint8_t)nvm_store_value[NVM_ALARM_PARAMETER05]; +#else sts_cfg_nvm.reserve02 =(uint8_t)nvm_store_value[NVM_RESERVE02]; sts_cfg_nvm.reserve03 =(uint8_t)nvm_store_value[NVM_RESERVE03]; sts_cfg_nvm.sensor_install_height_in_10cm =(uint8_t)nvm_store_value[NVM_SENSOR_INSTALL_HEIGHT]; sts_cfg_nvm.alarm_parameter05 =(uint8_t)nvm_store_value[NVM_ALARM_PARAMETER05]; +#endif sts_cfg_nvm.alarm_mute_reset_timer_in_10sec = (uint8_t)nvm_store_value[NVM_ALARM_MUTE_RESET_TIMER]; sts_cfg_nvm.alarm_lamp_bar_flashing_color = (uint8_t)nvm_store_value[NVM_ALARM_LAMP_BAR_FLASHING_COLOR]; sts_cfg_nvm.occupancy_overtime_threshold_in_10min = (uint8_t)nvm_store_value[NVM_OCCUPANCY_OVERTIME_THRESHOLD];