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

revised command response features

This commit is contained in:
Yunhorn 2023-06-29 13:07:00 +08:00
parent 6055588ceb
commit 0eee23bc0e
6 changed files with 313 additions and 253 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
Core/Inc/yunhorn_sts_prd_conf.h
View File

@ -219,6 +219,12 @@
#define YUNHORN_STS_MAX_NVM_CFG_SIZE 64U
#define YUNHORN_STS_AC_CODE_SIZE 20U
#define STS_NVM_CFG_SIZE 32U
#define STS_CFG_PCFG_SIZE 28U
#define STS_CFG_CMD_SIZE 30U
#define STS_CFG_CMD_SHORT_LEN 8U
#define STS_MODE_COLOR_CMD_LEN 5U
#define STS_R0_NVM_CFG_SIZE 16U
#define STS_R0_CFG_CMD_SIZE 12U
#define CFG_CMD_TOF_SIMPLE_SIZE (STS_R0_CFG_CMD_SIZE)

44
Core/Inc/yunhorn_sts_sensors.h
View File

@ -532,23 +532,32 @@ typedef struct
/* USER CODE END EM */
/* Exported functions prototypes ---------------------------------------------*/
// 0 --- 10 11 12 -- 39 40 41 42 43 44-63
// LEN P RSS FALL_DETECTION AC_CODE
enum nvm_order {
NVM_MTM1=0,
NVM_MTM2,
NVM_VER,
NVM_HWV,
NVM_PERIODICITY_H,
NVM_PERIODICITY_L,
NVM_PERIODICITY,
NVM_UNIT,
NVM_SAMPLING_H,
NVM_SAMPLING_L,
NVM_SAMPLING,
NVM_S_UNIT,
NVM_WORK_MODE,
NVM_SERVICE_MASK,
NVM_LEN,
NVM_CFG_START,
NVM_AC_CODE_START
NVM_RESERVE01, //10
NVM_LEN, //11, 32=0x20
NVM_CFG_START, //12, p[0] bytes for configs,
//13, p[1]
//14, p[2]
// ...
//39, P[27]
NVM_FALL_DETECTION_ACC_THRESHOLD=40, //40
NVM_FALL_DETECTION_DEPTH_THRESHOLD, //41
NVM_FALL_DETECTION_RESERVE, //42
NVM_OCCUPANCY_OVERTIME_THRESHOLD, //43
NVM_AC_CODE_START=44 //STORED, NO UPLOAD
//63, 20 bytes for AC code
};
typedef struct sts_cfg_nvm {
@ -556,16 +565,19 @@ typedef struct sts_cfg_nvm {
uint8_t mtmcode2;
uint8_t version;
uint8_t hardware_ver;
uint8_t periodicity_h; //count of uplink duty cycle duration high {0,9}
uint8_t periodicity_l; //count of uplink duty cycle duration low {0,9}
uint8_t unit; // uplink time unit of duty cycle duration, in 'S', 'M','H' seconds, minutes, hours
uint8_t heartbeat_h; //count of heart-beat duty cycle duration high {0,9}
uint8_t heartbeat_l; //count of heart-beat duty cycle duration low {0,9}
uint8_t s_unit; // sampling time unit of duty cycle duration, in 'S', 'M','H' seconds, minutes, hours
uint8_t periodicity; //count of uplink duty cycle duration high {99}
uint8_t unit; // uplink time unit of duty cycle duration, in 'S', 'M','H' seconds, minutes, hours
uint8_t sampling; //count of sampling duty cycle duration high {99}
uint8_t s_unit; // sampling time unit of duty cycle duration, in 'S', 'M','H' seconds, minutes, hours
uint8_t work_mode;
uint8_t sts_service_mask;
uint8_t length;
uint8_t p[YUNHORN_STS_MAX_NVM_CFG_SIZE]; //max 64 bytes
uint8_t reseve01;
uint8_t length; // length of following parameters except AC CODE(20bytes)
uint8_t p[STS_CFG_PCFG_SIZE];
uint8_t fall_detection_acc_threshold; // 0 - 9: 0:disable: 1-9 accelaration mg/s2
uint8_t fall_detection_depth_threshold; // 0 - 9: 0:disable: 1-9 fall down depth * 10 cm
uint8_t fall_detection_reserve;
uint8_t occupancy_overtime_threshold; // 0 - 9： 0：disable, 1-9 occupy over time threshold * 10 min
uint8_t ac[YUNHORN_STS_AC_CODE_SIZE]; // authorization code, 20 bytes MCU UUID coded
} sts_cfg_nvm_t;

11
Core/Src/yunhorn_sts_process.c
View File

@ -39,7 +39,8 @@ extern volatile sts_cfg_nvm_t sts_cfg_nvm;
extern volatile uint8_t sts_ac_code[20];
volatile uint8_t sts_service_mask;
volatile uint32_t rfac_timer;
extern volatile uint8_t sensor_data_ready;
volatile uint32_t event_start_time, event_stop_time;
#if (defined(YUNHORN_STS_O6_ENABLED) && defined(USE_ACCONEER_A111))
extern volatile STS_OO_RSS_SensorTuneDataTypeDef sts_presence_rss_config;
@ -118,7 +119,10 @@ void STS_YunhornAuthenticationCode_Process(void)
}
sts_service_mask = (sts_hmac_verify()!= 0)? STS_SERVICE_MASK_L2:STS_SERVICE_MASK_L0;
APP_LOG(TS_OFF, VLEVEL_M, "STS_SERVICE_MASK:%d \r\n",sts_service_mask);
if (sts_service_mask == STS_SERVICE_MASK_L2) {
sts_ac_code[0] = 0x0;
}
APP_LOG(TS_OFF, VLEVEL_H, "STS_SERVICE_MASK:%d \r\n",sts_service_mask);
}
void STS_YunhornSTSEventRFAC_Process(void)
@ -134,6 +138,9 @@ void STS_YunhornSTSEventRFAC_Process(void)
{
APP_LOG(TS_OFF, VLEVEL_M, "\r\n -------------------Verify RFAC Success or Not\r\n");
sts_service_mask = (sts_hmac_verify()!= 0)? STS_SERVICE_MASK_L2:STS_SERVICE_MASK_L0;
if (sts_service_mask == STS_SERVICE_MASK_L2) {
sts_ac_code[0] = 0x0;
}
}
}

499
LoRaWAN/App/lora_app.c
View File

@ -51,30 +51,67 @@ extern volatile uint32_t rfac_timer;
volatile uint8_t sts_ac_code[YUNHORN_STS_AC_CODE_SIZE]={0x0};
extern hmac_result_t hmac_result;
volatile uint8_t sts_work_mode =0;
//volatile uint32_t SamplingPeriodicity = 15000; //unit ms
//volatile uint32_t HeartBeatPeriodicity = 25000; //unit ms
//volatile uint32_t UploadingMessagePeriodicity = 30000; //unit ms
volatile uint8_t sensor_data_ready=0;
extern volatile uint8_t ToF_EventDetected;
extern volatile int sts_tof_distance_data;
volatile uint32_t SamplingPeriodicity = 1000; //unit ms
volatile uint32_t HeartBeatPeriodicity = 120000; //unit ms
volatile uint8_t STS_LoRa_WAN_Joined = 0;
volatile uint8_t mems_int1_detected = 0;
volatile uint8_t periodicity_level=0;
volatile uint8_t heart_beat_timer =0;
char outbuf[128]="";
volatile uint8_t upload_message_timer =0;
volatile sts_cfg_nvm_t sts_cfg_nvm = {
sts_mtmcode1,sts_mtmcode2, sts_version, sts_hardware_ver,
0x02,0x00,'S', //Upload message interval
0x01,0x00,'S', //Sampling sensor interval
sts_mtmcode1,
sts_mtmcode2,
sts_version,
sts_hardware_ver,
0x02,
'S', //Upload message interval
0x0A,
'S', //Sampling sensor interval
0x04, // dual mode
0x00, // service mask
0x1E, //30 bytes, below start of p[0]
{
0x00,0x00, //lenght_m [2 0]=2.0f
0x01,0x03, //threshold [1 3]=1.3f
0x00, // reserve01
0x20, //32 bytes, below start of p[0]
{ // below 28 bytes
0x08, //start_m [8]*0.1 meter =0.8
0x19, //lenght_m 0x19=[25]*0.1=2.5f meter
0x0F, //threshold 0X0F=[15]*0.1=1.5f
0x28, //receiver gain 0x28 =[40]*0.01=0.40f max 99=0x63
0x04, //profile [4]=4
0x00,0x05, //output time const [0 5]=0.5
0x0A, //rate tracking 0x0A=10= 10U
0x41, //rate presence 0x41=65= 65U
0x3F, //hwaas 0x3F=63 =63U
0x00, //nbr removed pc [0]=0
0x05, //inter frame deviation time const 0x05=[5]*0.1=0.5f
0x0A, //inter frame fast cutoff 0x0A=[10] = 10U
0x01, //inter frame slow cutoff,0x01=1[1]*0.01=0.01f
0x00, //intra frame time const [0]=0
0x00, //intra frame weight, 0x00=[0]*0.1=0.0F
0x05, //output time const 0x05=[5]*0.1=0.5
0x02, //downsampling factor [2]=2
0x03 //power saving mode [3] = 3U
},
{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0}
0x03, //power saving mode ACTIVE [3] = 3U
0x00, //reserve
0x00, //reserve
0x00, //reserve
0x00, //reserve
0x00, //reserve
0x00, //reserve
0x00, //reserve
0x00, //reserve
0x00, //reserve
0x00, //reserve
0x00, //reserve
}, // above 28 bytes
// below 4 bytes
0x01, //fall_detection_acc_threshold = *10 acceleration measure
0x03, //fall detection_depth_threshold *10cm
0x00, //reserve
0x02, //occupancy over time threshold *10 minutes
// below 20 bytes
{0x0,0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0,0x0, 0x0,0x0,0x0,0x0,0x0}
};
@ -103,7 +140,8 @@ typedef enum TxEventType_e
//#define YUNHORN_STS_SAMPLING_CHECK_TIME SamplingPeriodicity
//#define YUNHORN_STS_UPLOADING_MESSAGE_TIME UploadingMessagePeriodicity
//#define YUNHORN_STS_HEART_BEAT_CHECK_TIME HeartBeatPeriodicity
#define YUNHORN_STS_RSS_WAKEUP_CHECK_TIME SamplingPeriodicity //3000 ms
#define YUNHORN_STS_SAMPLING_CHECK_TIME SamplingPeriodicity
/* USER CODE END PTD */
/* Private define ------------------------------------------------------------*/
@ -273,36 +311,18 @@ static void OnRxTimerLedEvent(void *context);
*/
static void OnJoinTimerLedEvent(void *context);
/** REF
* @brief TX timer callback function
* @param context ptr of timer context
/**
* @brief Yunhorn STS Occupancy RSS WakeUP timer callback function
* @param context ptr of STS RSS WakeUp context
*/
//REF: static void OnTxTimerEvent(void *context);
//static void OnYunhornSTSSamplingPeriodicityChanged(uint32_t periodicity);
//static void OnYunhornSTSUploadingMessagePeriodicityChanged(uint32_t periodicity);
static void OnYunhornSTSOORSSWakeUpTimerEvent(void *context);
/**
* @brief Yunhorn STS Heart Beat Periodicity Chagne function
* @param duration of periodicty in ms (1/1000 sec)
*/
static void OnYunhornSTSHeartBeatPeriodicityChanged(uint32_t periodicity);
/**
* @brief Yunhorn STS Sampling Check timer callback function
* @param context ptr of STS Sampling Check context
*/
/*
*
* static void OnYunhornSTSSamplingCheckTimerEvent(void *context);
*
*/
/**
* @brief Yunhorn STS Uploading Message callback function
* @param context ptr of STS Sampling Check context
*/
//static void OnYunhornSTSUploadingMessageEvent(void *context);
/**
* @brief Yunhorn STS Heart Beat callback function
* @param context ptr of STS Sampling Check context
@ -416,6 +436,11 @@ static UTIL_TIMER_Object_t RxLedTimer;
*/
static UTIL_TIMER_Object_t JoinLedTimer;
/**
* @brief Timer to handle the YunHorn STS RSS WakeUP Checking
*/
static UTIL_TIMER_Object_t YunhornSTSRSSWakeUpTimer;
/**
* @brief Timer to handle the YunHorn STS Sensor Sampling Process
*/
@ -433,17 +458,13 @@ static UTIL_TIMER_Object_t YunhornSTSHeartBeatTimer;
/**
* @brief Heart-Beat Timer period
*/
static UTIL_TIMER_Time_t HeartBeatPeriodicity = 30*APP_TX_DUTYCYCLE; // 5 MIN initial
//static UTIL_TIMER_Time_t HeartBeatPeriodicity = 30*APP_TX_DUTYCYCLE; // 5 MIN initial
/* USER CODE END PV */
/* Exported functions ---------------------------------------------------------*/
/* USER CODE BEGIN EF */
extern volatile uint8_t ToF_EventDetected;
extern volatile int sts_tof_distance_data;
extern volatile uint8_t TIME_TO_SEND;
extern volatile uint8_t sensor_data_ready;
/* USER CODE END EF */
void LoRaWAN_Init(void)
@ -538,8 +559,6 @@ void LoRaWAN_Init(void)
/* USER CODE BEGIN LoRaWAN_Init_Last */
APP_LOG(TS_OFF,VLEVEL_L,"REBOOT CONFIG \r\n");
STS_REBOOT_CONFIG_Init();
@ -1143,6 +1162,22 @@ static void OnRestoreContextRequest(void *nvm, uint32_t nvm_size)
/* USER CODE END OnRestoreContextRequest_Last */
}
/**
* @brief Yunhorn STS Occupancy RSS WakeUP timer callback function, act as sampling process
* @param context ptr of STS RSS WakeUp context
*/
static void OnYunhornSTSOORSSWakeUpTimerEvent(void *context)
{
UTIL_SEQ_SetTask((1 << CFG_SEQ_Task_YunhornSTSEventP2), CFG_SEQ_Prio_0);
if (STS_LoRa_WAN_Joined != 0)
{
UTIL_SEQ_SetTask((1 << CFG_SEQ_Task_LoRaSendOnTxTimerOrButtonEvent), CFG_SEQ_Prio_0);
}
}
/**
* @brief Yunhorn STS Sensor Live Heart Beat Periodicity/interval Change callback function
* @param context ptr of STS Live Heart Beat context
@ -1211,30 +1246,38 @@ static void OnYunhornSTSHeartBeatPeriodicityChanged(uint32_t periodicity)
* @param context ptr of STS RSS WakeUp context
*/
//static void OnYunhornSTSSamplingPeriodicityChanged(uint32_t periodicity)
//{
static void OnYunhornSTSSamplingPeriodicityChanged(uint32_t periodicity)
{
/* USER CODE BEGIN OnTxPeriodicityChanged_1 */
/* USER CODE END OnTxPeriodicityChanged_1 */
//SamplingPeriodicity = periodicity;
SamplingPeriodicity = periodicity;
//if (SamplingPeriodicity == 0)
//{
if (SamplingPeriodicity == 0)
{
/* Revert to application default periodicity */
// SamplingPeriodicity = APP_TX_DUTYCYCLE;
//}
SamplingPeriodicity = APP_TX_DUTYCYCLE;
}
/* Update timer periodicity */
#if (defined(YUNHORN_STS_O6_ENABLED) || defined(YUNHORN_STS_R0_ENABLED))
UTIL_TIMER_Stop(&YunhornSTSRSSWakeUpTimer);
UTIL_TIMER_SetPeriod(&YunhornSTSRSSWakeUpTimer, SamplingPeriodicity);
UTIL_TIMER_Start(&YunhornSTSRSSWakeUpTimer);
APP_LOG(TS_OFF, VLEVEL_L,"**************** Sampling Timer Periodicity = %u (sec)\r\n", (SamplingPeriodicity/1000) );
// UTIL_TIMER_Stop(&YunhornSTSSamplingCheckTimer);
// UTIL_TIMER_SetPeriod(&YunhornSTSSamplingCheckTimer, SamplingPeriodicity);
// UTIL_TIMER_Start(&YunhornSTSSamplingCheckTimer);
#else
UTIL_TIMER_Stop(&YunhornSTSSamplingCheckTimer);
UTIL_TIMER_SetPeriod(&YunhornSTSSamplingCheckTimer, SamplingPeriodicity);
UTIL_TIMER_Start(&YunhornSTSSamplingCheckTimer);
APP_LOG(TS_OFF, VLEVEL_L,"**************** SamplingPeriodicity = %u (sec)\r\n", (SamplingPeriodicity/1000) );
#endif
/* USER CODE BEGIN OnTxPeriodicityChanged_2 */
// APP_LOG(TS_OFF, VLEVEL_M,"**************** SamplingPeriodicity = %u (ms)\r\n", SamplingPeriodicity );
/* USER CODE END OnTxPeriodicityChanged_2 */
//}
}
/*
@ -1324,7 +1367,7 @@ static void OnYunhornSTSHeartBeatTimerEvent(void *context)
void USER_APP_AUTO_RESPONDER_Parse(char *tlv_buf, size_t tlv_buf_size)
{
uint8_t i=0, mems_ver, invalid_flag=1;
char outbuf[128]="";
/*
* YUNHORN STS PRODUCT BOARD LEVEL CONTROL OR REPORT
@ -1352,18 +1395,15 @@ void USER_APP_AUTO_RESPONDER_Parse(char *tlv_buf, size_t tlv_buf_size)
* --M SERVICE LEVEL MASK
* --# 'YM0', 'YM1','YM2', 'YM3' [YM0] WU0w [YM1]WU0x [YM2]WU0y [YM3]WU0z
*
* --D UPLINK DURATION OR PERIODICITY
* --D UPLINK DURATION OR PERIODICITY Periodicity of Tx interval or Heart-Beat interval for real-time occupancy status update 2023-04-28
* --#
* --#
* --U UNIT (S, M, H) SECONDS, MINUTES, HOURS
* --S SAMPLING INTERVAL OR PERIODICITY
* --#
* --#
* --U UNIT (S, M, H) SECONDS, MINUTES, HOURS
* --L LIVE HEART BEAT DURATION OR PERIODICITY
* --S SAMPLING INTERVAL OR PERIODICITY periodicity for real-time sensing
* --#
* --#
* --U UNIT (S, M, H) SECONDS, MINUTES, HOURS
*
* --P ***** WORKMODE AND NETWORK COLOR
* --# MTM-VER 1
@ -1394,12 +1434,11 @@ void USER_APP_AUTO_RESPONDER_Parse(char *tlv_buf, size_t tlv_buf_size)
* --# MTM-VER 1
* --# STS-VER 1
* --30{#} FULL CONFIG PARAMETER
* --A ***** AC CODE (22 BYTES)
* --C
* --#
* --20{#} AC CODE 20 BYTES
*
*
*
* --A
* --C
* --AC_CODE
*/
if (((char)tlv_buf[CFG_CMD1] == 'Y') && (tlv_buf_size <=5)) // BEGIN OF *** BOARD LEVEL CONTROL OR REPORT
@ -1411,19 +1450,21 @@ void USER_APP_AUTO_RESPONDER_Parse(char *tlv_buf, size_t tlv_buf_size)
//BOARD REVIVE
STS_SENSOR_Upload_Message(LORAWAN_USER_APP_CTRL_REPLY_PORT, 20, "!YunHorn STS Revive!");
HAL_Delay(5000);
APP_LOG(TS_OFF, VLEVEL_H, "\r\n Yunhorn STS Node Revive ... \r\n");
HAL_Delay(3000);
OnSystemReset();
} else if ((char)tlv_buf[CFG_CMD3] == 'S') { // Self Function Testing "YZS"
i=0;
outbuf[i++] = (uint8_t) 'Y';
outbuf[i++] = (uint8_t) 'Z';
outbuf[i++] = (uint8_t) 'S';
//STS_SENSOR_Upload_Message(LORAWAN_USER_APP_CTRL_REPLY_PORT, i, outbuf);
i=0;
memset(outbuf,sizeof(outbuf),0x30);
STS_SENSOR_Function_Test_Process();
HAL_Delay(5000);
i=21;
STS_SENSOR_Upload_Message(LORAWAN_USER_APP_CTRL_REPLY_PORT, i, outbuf);
} else if ((char)tlv_buf[CFG_CMD3] == 'C') { // Lora-WAN Class "YZC" LORAWAN CLASS A/B/C
DeviceClass_t deviceClass = CLASS_A;
@ -1441,10 +1482,8 @@ void USER_APP_AUTO_RESPONDER_Parse(char *tlv_buf, size_t tlv_buf_size)
outbuf[i++] = (uint8_t) 'Z';
outbuf[i++] = (uint8_t) 'D';
//STS_SENSOR_Upload_Message(LORAWAN_USER_APP_CTRL_REPLY_PORT, i, outbuf);
#ifdef YUNHORN_STS_O6_ENABLED
STS_SENSOR_Distance_Test_Process();
APP_LOG(TS_OFF, VLEVEL_H, "\r\nRSS Measured Distance=[%u] mm \r\n", (int)sts_distance_rss_distance);
STS_SENSOR_Distance_Test_Process();
i=0;
memset(outbuf,sizeof(outbuf),0x30);
@ -1454,11 +1493,16 @@ void USER_APP_AUTO_RESPONDER_Parse(char *tlv_buf, size_t tlv_buf_size)
outbuf[i++] = (uint8_t)sts_version;
outbuf[i++] = (uint8_t)sts_hardware_ver;
outbuf[i++] = (uint8_t)(99*((GetBatteryLevel()/254)&0xff));
#ifdef STS_O6_ENABLED
outbuf[i++] = (uint8_t)0x04; //length of following data
outbuf[i++] = (uint8_t) ((((uint16_t)sts_distance_rss_distance)/1000)%10+0x30)&0xff;
outbuf[i++] = (uint8_t) ((((uint16_t)sts_distance_rss_distance)/100)%10+0x30)&0xff;
outbuf[i++] = (uint8_t) ((((uint16_t)sts_distance_rss_distance)/10)%10+0x30)&0xff;
outbuf[i++] = (uint8_t) (((uint16_t)sts_distance_rss_distance)%10+0x30)&0xff;
#endif
#ifdef YUNHORN_STS_R0_ENABLED
outbuf[i++] = (uint8_t) (((uint16_t)sts_tof_distance_data)/100)&0xff;
outbuf[i++] = (uint8_t) (((uint16_t)sts_tof_distance_data)%100)&0xff;
#endif
STS_SENSOR_Upload_Message(LORAWAN_USER_APP_CTRL_REPLY_PORT, i, outbuf);
@ -1475,7 +1519,7 @@ void USER_APP_AUTO_RESPONDER_Parse(char *tlv_buf, size_t tlv_buf_size)
outbuf[i++] = (uint8_t) 'M';
outbuf[i++] = (uint8_t) (sts_service_mask+0x30);
STS_SENSOR_Upload_Message(LORAWAN_USER_APP_CTRL_REPLY_PORT, i, outbuf);
//APP_LOG(TS_OFF, VLEVEL_L, ">>>>>>>>>>>>>>>>>>>>> Mask = [ %02x ] \r\n", sts_service_mask);
APP_LOG(TS_OFF, VLEVEL_L, ">>>>>>>>>>>>>>>>>>>>> Mask = [ %02x ] \r\n", sts_service_mask);
OnStoreSTSCFGContextRequest();
#ifdef YUNHORN_STS_O6_ENABLED
if (sts_service_mask != STS_SERVICE_MASK_L0) STS_Lamp_Bar_Set_Dark();
@ -1503,26 +1547,29 @@ void USER_APP_AUTO_RESPONDER_Parse(char *tlv_buf, size_t tlv_buf_size)
uint8_t cfg_in_nvm[YUNHORN_STS_MAX_NVM_CFG_SIZE]="";
OnRestoreSTSCFGContextRequest((uint8_t *)cfg_in_nvm);
i=0;
memset(outbuf,sizeof(outbuf),0x30);
outbuf[i++] = (uint8_t) 'C';
outbuf[i++] = (uint8_t) cfg_in_nvm[NVM_MTM1]; //MTM Code
outbuf[i++] = (uint8_t) cfg_in_nvm[NVM_MTM2]; //MTM Code
outbuf[i++] = (uint8_t) cfg_in_nvm[NVM_VER]; //STS Version
outbuf[i++] = (uint8_t) cfg_in_nvm[NVM_PERIODICITY_H]; //UPLINK Periodicity count high
outbuf[i++] = (uint8_t) cfg_in_nvm[NVM_PERIODICITY_L]; //UPLINK Periodicity count low
outbuf[i++] = (uint8_t) cfg_in_nvm[NVM_HWV]; //STS Version
outbuf[i++] = (uint8_t) (cfg_in_nvm[NVM_PERIODICITY]/10); //UPLINK Periodicity count high
outbuf[i++] = (uint8_t) (cfg_in_nvm[NVM_PERIODICITY]%10); //UPLINK Periodicity count low
outbuf[i++] = (uint8_t) cfg_in_nvm[NVM_UNIT]; //UPLINK Periodicity unit
outbuf[i++] = (uint8_t) cfg_in_nvm[NVM_SAMPLING_H]; //SAMPLING Periodicity count high
outbuf[i++] = (uint8_t) cfg_in_nvm[NVM_SAMPLING_L]; //SAMPLING Periodicity count low
outbuf[i++] = (uint8_t) (cfg_in_nvm[NVM_SAMPLING]/10); //SAMPLING Periodicity count high
outbuf[i++] = (uint8_t) (cfg_in_nvm[NVM_SAMPLING]%10); //SAMPLING Periodicity count low
outbuf[i++] = (uint8_t) cfg_in_nvm[NVM_S_UNIT]; //SAMPLING Periodicity unit
outbuf[i++] = (uint8_t) cfg_in_nvm[NVM_WORK_MODE]; // STS WORK MODE
outbuf[i++] = (uint8_t) cfg_in_nvm[NVM_SERVICE_MASK]; //service mask
outbuf[i++] = (uint8_t) cfg_in_nvm[NVM_LEN]; //length of following cfg value
outbuf[i++] = (uint8_t) cfg_in_nvm[NVM_SERVICE_MASK]; //service mask
outbuf[i++] = (uint8_t) cfg_in_nvm[NVM_RESERVE01]; //service mask
outbuf[i++] = (uint8_t) cfg_in_nvm[NVM_LEN]; //length of following cfg value
for (uint8_t j=1; j <= cfg_in_nvm[NVM_LEN]; j++) {
outbuf[i++] = (uint8_t) (cfg_in_nvm[NVM_LEN+j]);
for (uint8_t j=0; j < cfg_in_nvm[NVM_LEN]; j++) {
outbuf[i++] = (uint8_t) (cfg_in_nvm[NVM_CFG_START+j]);
}
STS_SENSOR_Upload_Message(LORAWAN_USER_APP_CTRL_REPLY_PORT, i, outbuf);
//APP_LOG(TS_OFF, VLEVEL_L, "###### YUNHORN Report Config in NVM [ %30X ] \r\n", outbuf);
}
break;
@ -1575,18 +1622,16 @@ void USER_APP_AUTO_RESPONDER_Parse(char *tlv_buf, size_t tlv_buf_size)
(((char)tlv_buf[CFG_CMD5] == 'M' || ((char)tlv_buf[CFG_CMD5] =='H') ||((char)tlv_buf[CFG_CMD5] =='S'))))
{
uint32_t periodicity_length = (tlv_buf[CFG_CMD3]-0x30)*10+ (tlv_buf[CFG_CMD4]-0x30);
uint8_t periodicity_unit = (char)tlv_buf[CFG_CMD5];
if ((char)tlv_buf[CFG_CMD5] == 'M') {
periodicity_length *= 60;
} else if ((char)tlv_buf[CFG_CMD5] == 'H') {
periodicity_length *= 3600;
}
TxPeriodicity = periodicity_length*1000; //translate to 1000ms=1s
HeartBeatPeriodicity = TxPeriodicity;
OnTxPeriodicityChanged(periodicity_length*1000); //translate to 1000ms=1s
OnTxPeriodicityChanged(TxPeriodicity);
i = 0;
outbuf[i++] = (uint8_t) tlv_buf[CFG_CMD1];
outbuf[i++] = (uint8_t) tlv_buf[CFG_CMD2];
@ -1600,35 +1645,32 @@ void USER_APP_AUTO_RESPONDER_Parse(char *tlv_buf, size_t tlv_buf_size)
sts_cfg_nvm.mtmcode2 = (uint8_t)sts_mtmcode2;
sts_cfg_nvm.version = (uint8_t)sts_version;
sts_cfg_nvm.hardware_ver = (uint8_t)sts_hardware_ver;
sts_cfg_nvm.periodicity_h = (uint8_t)(tlv_buf[CFG_CMD3]-0x30);
sts_cfg_nvm.periodicity_l = (uint8_t)(tlv_buf[CFG_CMD4]-0x30);
sts_cfg_nvm.unit = (uint8_t)periodicity_unit;
sts_cfg_nvm.periodicity = (uint8_t)((tlv_buf[CFG_CMD3]-0x30)*10+(tlv_buf[CFG_CMD4]-0x30));
sts_cfg_nvm.unit = (uint8_t)tlv_buf[CFG_CMD5];
sts_cfg_nvm.work_mode = (uint8_t)sts_work_mode;
sts_cfg_nvm.sts_service_mask = (uint8_t)sts_service_mask;
OnStoreSTSCFGContextRequest();
//APP_LOG(TS_OFF, VLEVEL_M, "###### YUNHORN Upload Message Periodicity Changed to [ %d ] Seconds\r\n", periodicity_length);
APP_LOG(TS_OFF, VLEVEL_M, "###### YUNHORN Periodicity Changed to [ %d ] Seconds\r\n", periodicity_length);
} else {
STS_SENSOR_Upload_Config_Invalid_Message();
}
break;
case 'L': // LIVE HEART BEAT INTERVAL OR DURATION
case 'S': // SAMPLING INTERVAL OR DURATION
if ((((char)tlv_buf[CFG_CMD3] >= '0') && ((char)tlv_buf[CFG_CMD3] <='9')
&& ((char)tlv_buf[CFG_CMD4] >='0') && ((char)tlv_buf[CFG_CMD4] <='9')) &&
(((char)tlv_buf[CFG_CMD5] == 'M' || ((char)tlv_buf[CFG_CMD5] =='H') ||((char)tlv_buf[CFG_CMD5] =='S'))))
{
uint32_t periodicity_length = (tlv_buf[CFG_CMD3]-0x30)*10+ (tlv_buf[CFG_CMD4]-0x30);
uint8_t periodicity_unit = (char)tlv_buf[CFG_CMD5];
uint32_t sampling_periodicity_length = (tlv_buf[CFG_CMD3]-0x30)*10+ (tlv_buf[CFG_CMD4]-0x30);
if ((char)tlv_buf[CFG_CMD5] == 'M') {
periodicity_length *= 60;
sampling_periodicity_length *= 60;
} else if ((char)tlv_buf[CFG_CMD5] == 'H') {
periodicity_length *= 3600;
sampling_periodicity_length *= 3600;
}
OnYunhornSTSHeartBeatPeriodicityChanged(periodicity_length*1000); //translate to 1000ms=1s
SamplingPeriodicity = sampling_periodicity_length*1000; //translate to 1000ms=1s
OnYunhornSTSSamplingPeriodicityChanged(SamplingPeriodicity);
i = 0;
outbuf[i++] = (uint8_t) tlv_buf[CFG_CMD1];
@ -1643,14 +1685,13 @@ void USER_APP_AUTO_RESPONDER_Parse(char *tlv_buf, size_t tlv_buf_size)
sts_cfg_nvm.mtmcode2 = (uint8_t)sts_mtmcode2;
sts_cfg_nvm.version = (uint8_t)sts_version;
sts_cfg_nvm.hardware_ver = (uint8_t)sts_hardware_ver;
sts_cfg_nvm.heartbeat_h = (uint8_t)(tlv_buf[CFG_CMD3]-0x30);
sts_cfg_nvm.heartbeat_l = (uint8_t)(tlv_buf[CFG_CMD4]-0x30);
sts_cfg_nvm.s_unit = (uint8_t)periodicity_unit;
sts_cfg_nvm.sampling = (uint8_t)((tlv_buf[CFG_CMD3]-0x30)*10+(tlv_buf[CFG_CMD4]-0x30));
sts_cfg_nvm.s_unit = (uint8_t)tlv_buf[CFG_CMD5];
sts_cfg_nvm.work_mode = (uint8_t)sts_work_mode;
sts_cfg_nvm.sts_service_mask = (uint8_t)sts_service_mask;
OnStoreSTSCFGContextRequest();
//APP_LOG(TS_OFF, VLEVEL_M, "###### YUNHORN Heart Beat Interval Changed to [ %d ] Seconds\r\n", periodicity_length);
APP_LOG(TS_OFF, VLEVEL_M, "###### YUNHORN Sampling Interval Changed to [ %d ] Seconds\r\n", sampling_periodicity_length);
} else {
STS_SENSOR_Upload_Config_Invalid_Message();
@ -1753,41 +1794,42 @@ void USER_APP_AUTO_RESPONDER_Parse(char *tlv_buf, size_t tlv_buf_size)
} //END OF SWITCH TVL_BUF_P_MEMS_NO
} //END OF PARAMETER CONFIG
else if (((char)tlv_buf[CFG_CMD1] == 'A') && ((char)tlv_buf[CFG_CMD2] == 'C') && (tlv_buf_size =22)) // BEGIN OF *** BOARD LEVEL AUTHORIZATION CODE
{
// 'AC'+ AC_CODE(20bytes)
for (uint8_t j=0; j< 20; j++)
else if (((char)tlv_buf[CFG_CMD1] == 'A') && ((char)tlv_buf[CFG_CMD2] == 'C') && (tlv_buf_size == (YUNHORN_STS_AC_CODE_SIZE+2))) // BEGIN OF *** BOARD LEVEL AUTHORIZATION CODE
{
sts_ac_code[j] = (uint8_t) tlv_buf[2+j];
APP_LOG(TS_OFF, VLEVEL_L," %02x ", sts_ac_code[j])
}
// 'AC'+ AC_CODE(20bytes)
STS_YUNHORN_RFAC_HANDLE_PROCESS();
if ((hmac_result.ac_pass == 1))
{
for (uint8_t j=0; j < YUNHORN_STS_AC_CODE_SIZE; j++)
for (uint8_t j=0; j< YUNHORN_STS_AC_CODE_SIZE; j++)
{
sts_cfg_nvm.ac[j] = sts_ac_code[j];
sts_ac_code[j] = (uint8_t) tlv_buf[2+j];
}
sts_service_mask = STS_SERVICE_MASK_L0;
STS_YUNHORN_RFAC_HANDLE_PROCESS();
} else {
sts_service_mask = STS_SERVICE_MASK_L2;
if ((hmac_result.ac_pass == 1U))
{
for (uint8_t j=0; j < YUNHORN_STS_AC_CODE_SIZE; j++)
{
sts_cfg_nvm.ac[j] = sts_ac_code[j];
}
sts_service_mask = STS_SERVICE_MASK_L0;
sts_cfg_nvm.sts_service_mask = sts_service_mask;
OnStoreSTSCFGContextRequest();
} else {
sts_service_mask = STS_SERVICE_MASK_L2;
}
i=0;
for (uint8_t j=0; j <(tlv_buf_size) ; j++) {
outbuf[i++] = (uint8_t) tlv_buf[j];
}
STS_SENSOR_Upload_Message(LORAWAN_USER_APP_CTRL_REPLY_PORT, i, (char*)outbuf);
}
sts_cfg_nvm.sts_service_mask = sts_service_mask;
OnStoreSTSCFGContextRequest();
i=0;
for (uint8_t j=0; j <(tlv_buf_size) ; j++) {
outbuf[i++] = (uint8_t) tlv_buf[j];
}
STS_SENSOR_Upload_Message(LORAWAN_USER_APP_CTRL_REPLY_PORT, i, (char*)outbuf);
}
} // END OF USER_APP_AUTO_RESPONDER_Parse
@ -1817,7 +1859,7 @@ void STS_SENSOR_Upload_Message(uint8_t appDataPort, uint8_t appBufferSize, char
}
AppData.Port = appDataPort;
AppData.BufferSize = (sts_service_mask >2?0:appBufferSize);
AppData.BufferSize = (sts_service_mask >1?0:appBufferSize);
if ((JoinLedTimer.IsRunning) && (LmHandlerJoinStatus() == LORAMAC_HANDLER_SET))
{
@ -1909,42 +1951,42 @@ void STS_SENSOR_Auto_Responder_Process(uint8_t tlv_ver,uint8_t tlv_type, uint8_t
void OnStoreSTSCFGContextRequest(void)
{
/* USER CODE BEGIN OnStoreContextRequest_1 */
uint8_t nvm_store_value[YUNHORN_STS_MAX_NVM_CFG_SIZE]="";
uint8_t nvm_store_size=YUNHORN_STS_MAX_NVM_CFG_SIZE;
uint8_t i=0, j=0;
uint8_t i=0, j=0, nvm_store_value[YUNHORN_STS_MAX_NVM_CFG_SIZE]="";
//#ifdef YUNHORN_STS_O6_ENABLED
sts_cfg_nvm.length = NVM_CFG_PARAMETER_SIZE;
#if (defined(YUNHORN_STS_O6_ENABLED) || defined(YUNHORN_STS_R0_ENABLED))
sts_cfg_nvm.length = STS_NVM_CFG_SIZE;
nvm_store_value[i++] = sts_cfg_nvm.mtmcode1;
nvm_store_value[i++] = sts_cfg_nvm.mtmcode2;
nvm_store_value[i++] = sts_cfg_nvm.version;
nvm_store_value[i++] = sts_cfg_nvm.hardware_ver;
nvm_store_value[i++] = sts_cfg_nvm.periodicity_h;
nvm_store_value[i++] = sts_cfg_nvm.periodicity_l;
nvm_store_value[i++] = sts_cfg_nvm.periodicity;
nvm_store_value[i++] = sts_cfg_nvm.unit;
nvm_store_value[i++] = sts_cfg_nvm.heartbeat_h;
nvm_store_value[i++] = sts_cfg_nvm.heartbeat_l;
nvm_store_value[i++] = sts_cfg_nvm.sampling;
nvm_store_value[i++] = sts_cfg_nvm.s_unit;
nvm_store_value[i++] = sts_cfg_nvm.work_mode;
nvm_store_value[i++] = sts_cfg_nvm.sts_service_mask;
nvm_store_value[i++] = sts_cfg_nvm.length;
nvm_store_value[i++] = sts_cfg_nvm.reseve01;
nvm_store_value[i++] = (uint8_t) STS_NVM_CFG_SIZE; //sts_cfg_nvm.length;
for (j = 0; j < NVM_CFG_PARAMETER_SIZE; j++) {
for (j = 0; j < STS_CFG_PCFG_SIZE; j++) {
nvm_store_value[i++] = (sts_cfg_nvm.p[j]);
}
nvm_store_value[i++] = sts_cfg_nvm.fall_detection_acc_threshold;
nvm_store_value[i++] = sts_cfg_nvm.fall_detection_depth_threshold;
nvm_store_value[i++] = sts_cfg_nvm.fall_detection_reserve;
nvm_store_value[i++] = sts_cfg_nvm.occupancy_overtime_threshold;
for (j = 0; j < YUNHORN_STS_AC_CODE_SIZE; j++) {
nvm_store_value[i++] = (sts_cfg_nvm.ac[j]);
}
//#endif
#endif
/* USER CODE END OnStoreContextRequest_1 */
/* store nvm in flash */
if (FLASH_IF_Erase(STS_CONFIG_NVM_BASE_ADDRESS, FLASH_PAGE_SIZE) == FLASH_IF_OK)
{
FLASH_IF_Write(STS_CONFIG_NVM_BASE_ADDRESS, (const void *)nvm_store_value, nvm_store_size);
FLASH_IF_Write(STS_CONFIG_NVM_BASE_ADDRESS, (const void *)nvm_store_value, YUNHORN_STS_MAX_NVM_CFG_SIZE);
}
@ -1969,13 +2011,13 @@ void OnRestoreSTSCFGContextRequest(uint8_t *cfg_in_nvm)
void STS_REBOOT_CONFIG_Init(void)
{
/* USER CODE BEGIN OnRestoreContextRequest_1 */
uint8_t nvm_stored_value[YUNHORN_STS_MAX_NVM_CFG_SIZE]="", nvm_store_size=YUNHORN_STS_MAX_NVM_CFG_SIZE;
uint8_t nvm_stored_value[YUNHORN_STS_MAX_NVM_CFG_SIZE]={0x0};
/* USER CODE END OnRestoreContextRequest_1 */
UTIL_MEM_cpy_8(nvm_stored_value, (void *)STS_CONFIG_NVM_BASE_ADDRESS, nvm_store_size);
UTIL_MEM_cpy_8(nvm_stored_value, (void *)STS_CONFIG_NVM_BASE_ADDRESS, YUNHORN_STS_MAX_NVM_CFG_SIZE);
/* USER CODE BEGIN OnRestoreContextRequest_Last */
//if ((nvm_stored_value[0] == 0xFF) || (nvm_stored_value[1] == 0xFF) ||(nvm_stored_value[2] == 0xFF))
#if (defined(YUNHORN_STS_O6_ENABLED) || defined(YUNHORN_STS_R0_ENABLED))
if ((nvm_stored_value[NVM_MTM1] != sts_mtmcode1) || (nvm_stored_value[NVM_MTM2] != sts_mtmcode2) || (nvm_stored_value[NVM_VER] != sts_version))
{
APP_LOG(TS_OFF, VLEVEL_L, "\r\nInitial Boot with Empty Config, Flash with default config....\r\n");
@ -1984,28 +2026,33 @@ void STS_REBOOT_CONFIG_Init(void)
HAL_Delay(1000);
} else
{
sts_cfg_nvm.mtmcode1 = (uint8_t)nvm_stored_value[NVM_MTM1];
sts_cfg_nvm.mtmcode2 = (uint8_t)nvm_stored_value[NVM_MTM2];
sts_cfg_nvm.version = (uint8_t)nvm_stored_value[NVM_VER];
sts_cfg_nvm.hardware_ver = (uint8_t)nvm_stored_value[NVM_HWV];
sts_cfg_nvm.periodicity_h = (uint8_t)(nvm_stored_value[NVM_PERIODICITY_H]);
sts_cfg_nvm.periodicity_l = (uint8_t)(nvm_stored_value[NVM_PERIODICITY_L]);
sts_cfg_nvm.unit = (uint8_t)(nvm_stored_value[NVM_UNIT]);
sts_cfg_nvm.heartbeat_h = (uint8_t)(nvm_stored_value[NVM_SAMPLING_H]);
sts_cfg_nvm.heartbeat_l = (uint8_t)(nvm_stored_value[NVM_SAMPLING_L]);
sts_cfg_nvm.s_unit = (uint8_t)(nvm_stored_value[NVM_S_UNIT]);
sts_cfg_nvm.work_mode = (uint8_t)(nvm_stored_value[NVM_WORK_MODE]);
sts_cfg_nvm.sts_service_mask = (uint8_t)(nvm_stored_value[NVM_SERVICE_MASK]);
sts_cfg_nvm.length = (uint8_t)(nvm_stored_value[NVM_LEN]&0x3F); //MAX 32 bytes
for (uint8_t j=0; j< sts_cfg_nvm.length; j++) {
sts_cfg_nvm.p[j] = (uint8_t)nvm_stored_value[NVM_CFG_START+j];
}
for (uint8_t j=0; j< YUNHORN_STS_AC_CODE_SIZE; j++) {
sts_cfg_nvm.ac[j] = (uint8_t)nvm_stored_value[NVM_CFG_START+sts_cfg_nvm.length + j];
}
sts_cfg_nvm.mtmcode1 = (uint8_t)nvm_stored_value[NVM_MTM1];
sts_cfg_nvm.mtmcode2 = (uint8_t)nvm_stored_value[NVM_MTM2];
sts_cfg_nvm.version = (uint8_t)nvm_stored_value[NVM_VER];
sts_cfg_nvm.hardware_ver = (uint8_t)nvm_stored_value[NVM_HWV];
sts_cfg_nvm.periodicity = (uint8_t)(nvm_stored_value[NVM_PERIODICITY]);
sts_cfg_nvm.unit = (uint8_t)(nvm_stored_value[NVM_UNIT]);
sts_cfg_nvm.sampling = (uint8_t)(nvm_stored_value[NVM_SAMPLING]);
sts_cfg_nvm.s_unit = (uint8_t)(nvm_stored_value[NVM_S_UNIT]);
sts_cfg_nvm.work_mode = (uint8_t)(nvm_stored_value[NVM_WORK_MODE]);
sts_cfg_nvm.sts_service_mask = (uint8_t)(nvm_stored_value[NVM_SERVICE_MASK]);
sts_cfg_nvm.reseve01 = (uint8_t)(nvm_stored_value[NVM_RESERVE01]);
sts_cfg_nvm.length = (uint8_t)(nvm_stored_value[NVM_LEN]&0x3F); //MAX 32 bytes
for (uint8_t j=0; j< sts_cfg_nvm.length; j++) {
sts_cfg_nvm.p[j] = (uint8_t)nvm_stored_value[NVM_CFG_START+j];
}
sts_cfg_nvm.fall_detection_acc_threshold = (uint8_t)nvm_stored_value[NVM_FALL_DETECTION_ACC_THRESHOLD];
sts_cfg_nvm.fall_detection_depth_threshold = (uint8_t)nvm_stored_value[NVM_FALL_DETECTION_DEPTH_THRESHOLD];
sts_cfg_nvm.fall_detection_reserve = (uint8_t)nvm_stored_value[NVM_FALL_DETECTION_RESERVE];
sts_cfg_nvm.occupancy_overtime_threshold = (uint8_t)nvm_stored_value[NVM_OCCUPANCY_OVERTIME_THRESHOLD];
for (uint8_t j=0; j< YUNHORN_STS_AC_CODE_SIZE; j++) {
sts_cfg_nvm.ac[j] = (uint8_t)nvm_stored_value[NVM_AC_CODE_START +j];
}
}
#endif
OnRestoreSTSCFGContextProcess();
@ -2014,7 +2061,7 @@ void STS_REBOOT_CONFIG_Init(void)
void OnRestoreSTSCFGContextProcess(void)
{
uint32_t periodicity = (sts_cfg_nvm.periodicity_h)*10+(sts_cfg_nvm.periodicity_l);
uint32_t periodicity = (sts_cfg_nvm.periodicity);
if ((char)sts_cfg_nvm.unit =='M') {
periodicity *= 60;
} else if ((char) sts_cfg_nvm.unit =='H') {
@ -2022,11 +2069,11 @@ void OnRestoreSTSCFGContextProcess(void)
} else if ((char) sts_cfg_nvm.unit =='S') {
periodicity *= 1;
}
periodicity = (periodicity > 10)? periodicity : 10;
TxPeriodicity= periodicity*1000; // to ms
OnTxPeriodicityChanged(TxPeriodicity);
/*
uint32_t samplingperiodicity = (sts_cfg_nvm.sampling_h)*10+(sts_cfg_nvm.sampling_l);
periodicity = (periodicity > 10)? periodicity : 10; // in seconds unit
TxPeriodicity= periodicity*1000; // to ms
OnTxPeriodicityChanged(TxPeriodicity); // in msec unit
uint32_t samplingperiodicity = (sts_cfg_nvm.sampling);
if ((char)sts_cfg_nvm.s_unit =='M') {
samplingperiodicity *= 60;
} else if ((char) sts_cfg_nvm.s_unit =='H') {
@ -2034,49 +2081,35 @@ void OnRestoreSTSCFGContextProcess(void)
} else if ((char) sts_cfg_nvm.s_unit =='S') {
samplingperiodicity *= 1;
}
samplingperiodicity = (samplingperiodicity > 30)? samplingperiodicity : 30;
//Global
SamplingPeriodicity =samplingperiodicity*1000; // to ms
OnYunhornSTSSamplingPeriodicityChanged(SamplingPeriodicity);
*/
uint32_t heartbeatperiodicity = (sts_cfg_nvm.heartbeat_h)*10+(sts_cfg_nvm.heartbeat_l);
if ((char)sts_cfg_nvm.s_unit =='M') {
heartbeatperiodicity *= 60;
} else if ((char) sts_cfg_nvm.s_unit =='H') {
heartbeatperiodicity *= 3600;
} else if ((char) sts_cfg_nvm.s_unit =='S') {
heartbeatperiodicity *= 1;
}
heartbeatperiodicity = (heartbeatperiodicity > 30)? heartbeatperiodicity : 30;
HeartBeatPeriodicity = heartbeatperiodicity*1000;
OnYunhornSTSHeartBeatPeriodicityChanged(HeartBeatPeriodicity);
samplingperiodicity = (samplingperiodicity > 0)? samplingperiodicity : 1; // in seconds unit
OnYunhornSTSSamplingPeriodicityChanged(samplingperiodicity*1000); // in m-sec unit
sts_work_mode = sts_cfg_nvm.work_mode;
sts_service_mask = sts_cfg_nvm.sts_service_mask;
#ifdef YUNHORN_STS_O6_ENABLED
sts_lamp_bar_color = STS_GREEN;
if ((sts_version == sts_cfg_nvm.version)&& (NVM_CFG_PARAMETER_SIZE == sts_cfg_nvm.length))
{
STS_PRESENCE_SENSOR_Init();
}
sts_fall_detection_acc_threshold = (uint8_t)sts_cfg_nvm.fall_detection_acc_threshold*10;
sts_fall_detection_depth_threshold = (uint8_t)sts_cfg_nvm.fall_detection_depth_threshold*10; //in cm
// **** = sts_cfg_nvm.fall_detection_reserve;
sts_occupancy_overtime_threshold = (uint8_t)sts_cfg_nvm.occupancy_overtime_threshold*10; // minutes
#endif
sts_service_mask = sts_cfg_nvm.sts_service_mask;
for (uint8_t j=0; j< YUNHORN_STS_AC_CODE_SIZE; j++)
{
sts_ac_code[j] = sts_cfg_nvm.ac[j];
}
#ifdef YUNHORN_STS_O6_ENABLED
if ((sts_version == sts_cfg_nvm.version)&& (NVM_CFG_PARAMETER_SIZE == sts_cfg_nvm.length))
{
STS_PRESENCE_SENSOR_Init();
STS_PRESENCE_SENSOR_RSS_Init();
}
#endif
}
void STS_SENSOR_Distance_Test_Process(void)
@ -2094,49 +2127,51 @@ void STS_SENSOR_Distance_Test_Process(void)
void STS_SENSOR_Function_Test_Process(void)
{
char outbuf[128] =""; uint8_t i=0;
char tstbuf[128] =""; uint8_t i=0;
//uint8_t count = 1;
uint8_t mems_Dev_ID[2] = "";
outbuf[i++] = (uint8_t) 'S';
outbuf[i++] = (uint8_t) sts_mtmcode1;
outbuf[i++] = (uint8_t) sts_mtmcode2;
outbuf[i++] = (uint8_t) sts_version;
outbuf[i++] = (uint8_t) sts_hardware_ver;
outbuf[i++] = (uint8_t) (99*((GetBatteryLevel()/254)&0xff));
tstbuf[i++] = (uint8_t) 'S';
tstbuf[i++] = (uint8_t) sts_mtmcode1;
tstbuf[i++] = (uint8_t) sts_mtmcode2;
tstbuf[i++] = (uint8_t) sts_version;
tstbuf[i++] = (uint8_t) sts_hardware_ver;
tstbuf[i++] = (uint8_t) (99*((GetBatteryLevel()/254)&0xff));
STS_SENSOR_MEMS_Get_ID(mems_Dev_ID);
if ((mems_Dev_ID[0]==0X0) && (mems_Dev_ID[1]==0x0)) {
outbuf[i++] = (uint8_t) 'X'; // Slave MEMS Not Avaliable
tstbuf[i++] = (uint8_t) 'X'; // Slave MEMS Not Avaliable
}
else
{
#ifdef YUNHORN_STS_O6_ENABLED
outbuf[i++] = (uint8_t)20; //length of following data
#ifdef YUNHORN_STS_O6_ENABLED
tstbuf[i++] = (uint8_t)20; //length of following data
uint8_t self_test_result[10]={0,0,0,0,0, 0,0,0,0,0};
STS_PRESENCE_SENSOR_Function_Test_Process(&self_test_result[0], count);
for (uint8_t j=0; j < 10; j++)
outbuf[i++] = (uint8_t) (self_test_result[j])&0xff;
tstbuf[i++] = (uint8_t) (self_test_result[j])&0xff;
STS_PRESENCE_SENSOR_Distance_Measure_Process();
outbuf[i++] = (uint8_t) ((((uint16_t)sts_distance_rss_distance)/1000)%10+0x30)&0xff;
outbuf[i++] = (uint8_t) ((((uint16_t)sts_distance_rss_distance)/100)%10+0x30)&0xff;
outbuf[i++] = (uint8_t) ((((uint16_t)sts_distance_rss_distance)/10)%10+0x30)&0xff;
outbuf[i++] = (uint8_t) (((uint16_t)sts_distance_rss_distance)%10+0x30)&0xff;
tstbuf[i++] = (uint8_t) ((((uint16_t)sts_distance_rss_distance)/1000)%10+0x30)&0xff;
tstbuf[i++] = (uint8_t) ((((uint16_t)sts_distance_rss_distance)/100)%10+0x30)&0xff;
tstbuf[i++] = (uint8_t) ((((uint16_t)sts_distance_rss_distance)/10)%10+0x30)&0xff;
tstbuf[i++] = (uint8_t) (((uint16_t)sts_distance_rss_distance)%10+0x30)&0xff;
#endif
#ifdef YUNHORN_STS_R0_ENABLED
outbuf[i++] = (uint8_t)2; //length of following data
tstbuf[i++] = (uint8_t)2; //length of following data
MX_TOF_Process();
outbuf[i++] = (uint8_t) ((sts_tof_distance_data >>8 ) &0xff);
outbuf[i++] = (uint8_t) (sts_tof_distance_data &0xff);
tstbuf[i++] = (uint8_t) ((sts_tof_distance_data >>8 ) &0xff);
tstbuf[i++] = (uint8_t) (sts_tof_distance_data &0xff);
#endif
}
memset((void*)outbuf,sizeof(outbuf),0x30);
memcpy((void*)outbuf, tstbuf, i);
STS_SENSOR_Upload_Message(LORAWAN_USER_APP_CTRL_REPLY_PORT, i, outbuf);
//STS_SENSOR_Upload_Message(LORAWAN_USER_APP_CTRL_REPLY_PORT, i, outbuf);
}

4
STM32CubeIDE/.settings/language.settings.xml
View File

@ -5,7 +5,7 @@
<provider copy-of="extension" id="org.eclipse.cdt.ui.UserLanguageSettingsProvider"/>
<provider-reference id="org.eclipse.cdt.core.ReferencedProjectsLanguageSettingsProvider" ref="shared-provider"/>
<provider-reference id="org.eclipse.cdt.managedbuilder.core.MBSLanguageSettingsProvider" ref="shared-provider"/>
<provider class="com.st.stm32cube.ide.mcu.toolchain.armnone.setup.CrossBuiltinSpecsDetector" console="false" env-hash="900329934260214400" id="com.st.stm32cube.ide.mcu.toolchain.armnone.setup.CrossBuiltinSpecsDetector" keep-relative-paths="false" name="MCU ARM GCC Built-in Compiler Settings" parameter="${COMMAND} ${FLAGS} -E -P -v -dD &quot;${INPUTS}&quot;" prefer-non-shared="true">
<provider class="com.st.stm32cube.ide.mcu.toolchain.armnone.setup.CrossBuiltinSpecsDetector" console="false" env-hash="856846852047785661" id="com.st.stm32cube.ide.mcu.toolchain.armnone.setup.CrossBuiltinSpecsDetector" keep-relative-paths="false" name="MCU ARM GCC Built-in Compiler Settings" parameter="${COMMAND} ${FLAGS} -E -P -v -dD &quot;${INPUTS}&quot;" prefer-non-shared="true">
<language-scope id="org.eclipse.cdt.core.gcc"/>
<language-scope id="org.eclipse.cdt.core.g++"/>
</provider>
@ -16,7 +16,7 @@
<provider copy-of="extension" id="org.eclipse.cdt.ui.UserLanguageSettingsProvider"/>
<provider-reference id="org.eclipse.cdt.core.ReferencedProjectsLanguageSettingsProvider" ref="shared-provider"/>
<provider-reference id="org.eclipse.cdt.managedbuilder.core.MBSLanguageSettingsProvider" ref="shared-provider"/>
<provider class="com.st.stm32cube.ide.mcu.toolchain.armnone.setup.CrossBuiltinSpecsDetector" console="false" env-hash="900329934260214400" id="com.st.stm32cube.ide.mcu.toolchain.armnone.setup.CrossBuiltinSpecsDetector" keep-relative-paths="false" name="MCU ARM GCC Built-in Compiler Settings" parameter="${COMMAND} ${FLAGS} -E -P -v -dD &quot;${INPUTS}&quot;" prefer-non-shared="true">
<provider class="com.st.stm32cube.ide.mcu.toolchain.armnone.setup.CrossBuiltinSpecsDetector" console="false" env-hash="856846852047785661" id="com.st.stm32cube.ide.mcu.toolchain.armnone.setup.CrossBuiltinSpecsDetector" keep-relative-paths="false" name="MCU ARM GCC Built-in Compiler Settings" parameter="${COMMAND} ${FLAGS} -E -P -v -dD &quot;${INPUTS}&quot;" prefer-non-shared="true">
<language-scope id="org.eclipse.cdt.core.gcc"/>
<language-scope id="org.eclipse.cdt.core.g++"/>
</provider>

2
TOF/App/app_tof_vl53l0x_range.c
View File

@ -80,7 +80,7 @@ int LeakyFactorFix8 = (int)( 0.6 *256);
int nDevPresent=0;
volatile int sts_tof_distance_data;
volatile uint8_t sensor_data_ready=0;
extern volatile uint8_t sensor_data_ready;
VL53L0X_Dev_t VL53L0XDevs={
.I2cHandle=&X_WL55_WLE5_53L0X_hi2c,