pre-PRD

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);

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 */
 

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 */

Core/Src/sts_weight_scale.c

@@ -21,13 +21,13 @@
 #include "sts_weight_scale.h"
 #include <stdio.h>
 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 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);
-	 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); 	//计算实物的实际重量
-		}
 
 
-		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) {
+	//APP_LOG(TS_OFF, VLEVEL_M, "\r\n --------Calibrated GapValue =%u \r\n", (int)sts_gap_value);
-
-			sts_gap_value -=0.1;
-		}
-
-		if ((diff_value <= 0.1) && (diff_value >=0))
-			break;
-
-	}
 
 #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;
+	PME_ON;
-	//HAL_Delay(500);
+	//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
+	last_net_weight = net_weight;
-	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;
 
+	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);
 	}
 }
 

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, (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));
+      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)+10;
+      AppData.BufferSize = sizeof(YUNHORN_STS_PRD_STRING);
-      LmHandlerParams.IsTxConfirmed = true;
+      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
     {

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

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];