sundp
/
WLE5CC_NODE_STS
1
0
Fork 1
Code Issues Pull Requests Packages Projects Releases Wiki Activity

pre-PRD

This commit is contained in:
Yunhorn 2024-12-03 23:08:45 +08:00
parent 9ddfd8b156
commit b167d2c1d9
8 changed files with 193 additions and 77 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
Core/Inc/sts_weight_scale.h
View File

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

5
Core/Src/main.c
View File

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

36
Core/Src/stm32_lpm_if.c
View File

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

87
Core/Src/sts_weight_scale.c
View File

@ -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);
}
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); //计算实物的实际重量
calibrated_gap_value = (float)net_weight/(1000.0*knob_weights_in_kg);
}
//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);
Get_NetWeight();
sts_weight_scale_value_g = net_weight;
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);
#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;
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);
}
}

13
LoRaWAN/App/lora_app.c
View File

@ -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
{

BIN
STM32CubeIDE/Release/WLE5CC_NODE_STS.elf
View File

Binary file not shown.

13
STS/Core/Inc/yunhorn_sts_sensors.h
View File

@ -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

94
STS/Core/Src/yunhorn_sts_process.c
View File

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