From c6e4f04963a5cd79d8bdd3119673a74a8e4898a3 Mon Sep 17 00:00:00 2001 From: YunHorn Technology Date: Sun, 8 Oct 2023 19:59:19 +0800 Subject: [PATCH] revised without arm-math ...bad --- Core/Inc/utilities_def.h | 3 +- LoRaWAN/App/lora_app.c | 619 ++++++++++++++++++++++++++++++++++++++- LoRaWAN/App/lora_app.h | 5 +- 3 files changed, 613 insertions(+), 14 deletions(-) diff --git a/Core/Inc/utilities_def.h b/Core/Inc/utilities_def.h index bcf7700..d64df5a 100644 --- a/Core/Inc/utilities_def.h +++ b/Core/Inc/utilities_def.h @@ -80,7 +80,8 @@ typedef enum CFG_SEQ_Task_LoRaStoreContextEvent, CFG_SEQ_Task_LoRaStopJoinEvent, /* USER CODE BEGIN CFG_SEQ_Task_Id_t */ - + CFG_SEQ_Task_YunhornSTSEventP1, + CFG_SEQ_Task_YunhornSTSEventP2, /* USER CODE END CFG_SEQ_Task_Id_t */ CFG_SEQ_Task_NBR } CFG_SEQ_Task_Id_t; diff --git a/LoRaWAN/App/lora_app.c b/LoRaWAN/App/lora_app.c index 7f3dffb..ca22ccb 100644 --- a/LoRaWAN/App/lora_app.c +++ b/LoRaWAN/App/lora_app.c @@ -36,7 +36,18 @@ #include "flash_if.h" /* USER CODE BEGIN Includes */ - +#include "yunhorn_sts_sensors.h" +#include "yunhorn_sts_motion_sensor.h" +volatile uint32_t periodicity_length=0; +volatile uint8_t heart_beat_timer=0, sts_lorawan_joined=0; +volatile sts_cfg_nvm_t sts_cfg_nvm = + { sts_mtmcode1,sts_mtmcode2, sts_version, sts_hardware_ver, + 0x00,0x05,'M',0x03,{0x08,0x04,0x02}}; +#ifdef YUNHORN_STS_M7_ENABLED +extern volatile uint8_t sensor_data_ready; +extern volatile STS_M7_SensorDataTypeDef sts_m7_sensorData; +extern volatile uint8_t act_threshold, inact_threshold, inact_duration; +#endif /* USER CODE END Includes */ /* External variables ---------------------------------------------------------*/ @@ -352,7 +363,8 @@ void LoRaWAN_Init(void) /* USER CODE END LoRaWAN_Init_LV */ /* USER CODE BEGIN LoRaWAN_Init_1 */ - + APP_LOG(TS_OFF, VLEVEL_M, "\r\n\n\n##### YUNHORN_STS_FW:%d SWV%d HWV:%d MTM:%d.%d R:%d.%d.%d####\r\n\n\n", + FirmwareVersion, sts_version, sts_hardware_ver, sts_mtmcode1,sts_mtmcode2, MajorVer, MinorVer, SubMinorVer); /* Get LoRaWAN APP version*/ APP_LOG(TS_OFF, VLEVEL_M, "APPLICATION_VERSION: V%X.%X.%X\r\n", (uint8_t)(APP_VERSION_MAIN), @@ -434,7 +446,10 @@ void LoRaWAN_Init(void) } /* USER CODE BEGIN LoRaWAN_Init_Last */ + UTIL_SEQ_RegTask((1 << CFG_SEQ_Task_YunhornSTSEventP1), UTIL_SEQ_RFU, STS_MOTION_SENSOR_WakeUp_Process); + UTIL_SEQ_RegTask((1 << CFG_SEQ_Task_YunhornSTSEventP2), UTIL_SEQ_RFU, STS_SENSOR_Function_Test_Process); + STS_REBOOT_CONFIG_Init(); /* USER CODE END LoRaWAN_Init_Last */ } @@ -444,19 +459,39 @@ void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin) { switch (GPIO_Pin) { - case BUT1_Pin: +#if defined(USE_STM32WL55) + HAL_Delay(150); //for de-bouncing eliminate + mems_int1_detected=1; /* Note: when "EventType == TX_ON_TIMER" this GPIO is not initialized */ if (EventType == TX_ON_EVENT) { - UTIL_SEQ_SetTask((1 << CFG_SEQ_Task_LoRaSendOnTxTimerOrButtonEvent), CFG_SEQ_Prio_0); - } - break; - case BUT2_Pin: - UTIL_SEQ_SetTask((1 << CFG_SEQ_Task_LoRaStopJoinEvent), CFG_SEQ_Prio_0); + UTIL_SEQ_SetTask((1 << CFG_SEQ_Task_YunhornSTSEventP2), CFG_SEQ_Prio_0); + UTIL_SEQ_SetTask((1 << CFG_SEQ_Task_LoRaSendOnTxTimerOrButtonEvent), CFG_SEQ_Prio_0); + APP_LOG(TS_OFF, VLEVEL_M, "\r\n(1) Vibration Sensor EXTI Event BUT1 1 \r\n"); //YUNHORN_STS_TODO + mems_int1_detected=0; + } + break; + case BUT3_Pin: - UTIL_SEQ_SetTask((1 << CFG_SEQ_Task_LoRaStoreContextEvent), CFG_SEQ_Prio_0); + UTIL_SEQ_SetTask((1 << CFG_SEQ_Task_LoRaStopJoinEvent), CFG_SEQ_Prio_0); + //mems_int1_detected=1; +// UTIL_SEQ_SetTask((1 << CFG_SEQ_Task_LoRaSendOnTxTimerOrButtonEvent), CFG_SEQ_Prio_0); + //APP_LOG(TS_OFF, VLEVEL_M, "\r\n(1) Vibration Sensor EXTI Event BUT2 2 2 \r\n"); //YUNHORN_STS_TODO + break; +#endif +#if defined(USE_STM32WLE5) + case MEMS_EXTI2_Pin: + break; + case MEMS_EXTI1_Pin: + //APP_LOG(TS_OFF, VLEVEL_L, "\r\n(3) Vibration Sensor EXTI Event BUT3 3 3 3 \r\n"); //YUNHORN_STS_TODO + mems_int1_detected=1; + UTIL_SEQ_SetTask((1 << CFG_SEQ_Task_YunhornSTSEventP1), CFG_SEQ_Prio_0); + + UTIL_SEQ_SetTask((1 << CFG_SEQ_Task_LoRaSendOnTxTimerOrButtonEvent), CFG_SEQ_Prio_0); + break; +#endif default: break; } @@ -531,7 +566,15 @@ static void OnRxData(LmHandlerAppData_t *appData, LmHandlerRxParams_t *params) } } break; + case LORAWAN_USER_APP_CTRL_PORT: + if (appData->BufferSize != 1) + { + if (appData->BufferSize < 128) { + USER_APP_AUTO_RESPONDER_Parse((char*)appData->Buffer, appData->BufferSize); + } + } + break; default: break; @@ -549,12 +592,360 @@ static void OnRxData(LmHandlerAppData_t *appData, LmHandlerRxParams_t *params) /* USER CODE END OnRxData_1 */ } + +void USER_APP_AUTO_RESPONDER_Parse(char *tlv_buf, size_t tlv_buf_size) +{ + uint8_t i=0; + char outbuf[64]=""; + + /* + * YUNHORN STS PRODUCT BOARD LEVEL CONTROL OR REPORT + */ + + if (((char)tlv_buf[CFG_CMD1] == 'Y') && (tlv_buf_size <=5)) // BEGIN OF *** BOARD LEVEL CONTROL OR REPORT + { + switch ((char)tlv_buf[CFG_CMD2]) { + case 'Z': //"YZ" + if ((char)tlv_buf[CFG_CMD3] == 'H') { //BOARD SOFT RESET, REVIVE "YZH" + //BOARD REVIVE + STS_SENSOR_Upload_Message(LORAWAN_USER_APP_CTRL_REPLY_PORT, 20, "!YunHorn STS Revive!"); + HAL_Delay(5000); + + OnSystemReset(); + } else if ((char)tlv_buf[CFG_CMD3] == 'S') { // Self Function Testing "YZS" + + STS_SENSOR_Function_Test_Process(); + + } else if ((char)tlv_buf[CFG_CMD3] == 'C') { // Self Function Testing "YZC" LORAWAN CLASS A/B/C + + DeviceClass_t deviceClass = CLASS_A; + LmHandlerGetCurrentClass( &deviceClass ); + i=0; + outbuf[i++] = (uint8_t) 'L'; + outbuf[i++] = (uint8_t) sts_mtmcode1; + outbuf[i++] = (uint8_t) sts_mtmcode2; + outbuf[i++] = (uint8_t) sts_version; + outbuf[i++] = (uint8_t) (0x41+ deviceClass); //translate to 'A','B','C' + STS_SENSOR_Upload_Message(LORAWAN_USER_APP_CTRL_REPLY_PORT, i, outbuf); + } + break; + + case 'V': //"YV" + if ((char)tlv_buf[CFG_CMD3] == 'H') { // "YVH" REPORT FIRMWARE VERSION "YVH" + // FIRMWARE VERSION REPORT + outbuf[i++] = (uint8_t) 'V'; + outbuf[i++] = (uint8_t) sts_mtmcode1; + outbuf[i++] = (uint8_t) sts_mtmcode2; + outbuf[i++] = (uint8_t) sts_version; + outbuf[i++] = (uint8_t) FirmwareVersion; + outbuf[i++] = (uint8_t) MajorVer; + outbuf[i++] = (uint8_t) MinorVer; + outbuf[i++] = (uint8_t) SubMinorVer; + STS_SENSOR_Upload_Message(LORAWAN_USER_APP_CTRL_REPLY_PORT, i, outbuf); + APP_LOG(TS_OFF, VLEVEL_L, "###### YUNHORN Report Version [ %10x ] \r\n", outbuf); + } + else + if ((char)tlv_buf[CFG_CMD3] == 'C') { // "YVC" REPORT NVM STORED CONFIG PARAMETERS "YVC" + + uint8_t cfg_in_nvm[YUNHORN_STS_MAX_NVM_CFG_SIZE]=""; + OnRestoreSTSCFGContextRequest((uint8_t *)cfg_in_nvm); + + 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]; //Periodicity count high + outbuf[i++] = (uint8_t) cfg_in_nvm[NVM_PERIODICITY_L]; //Periodicity count low + outbuf[i++] = (uint8_t) cfg_in_nvm[NVM_UNIT]; //Periodicity unit + 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]); + } + STS_SENSOR_Upload_Message(LORAWAN_USER_APP_CTRL_REPLY_PORT, i, outbuf); + APP_LOG(TS_OFF, VLEVEL_L, "###### YUNHORN Report Config in NVM [ %10x ] \r\n", outbuf); + + } + break; + // "YO#","YF#","YH#","YD##L" ##={0,9} L={S,M,H} + case 'O': + // TODO # of modules + if (((uint8_t)(tlv_buf[CFG_CMD3]-0x30) >= 0) && ((uint8_t)tlv_buf[CFG_CMD3]-0x30) <=9) { + STS_SENSOR_Power_ON((uint8_t)(tlv_buf[CFG_CMD3]-0x30)); + i=0; + outbuf[i++] = (uint8_t) tlv_buf[CFG_CMD1]; + outbuf[i++] = (uint8_t) tlv_buf[CFG_CMD2]; + outbuf[i++] = (uint8_t) tlv_buf[CFG_CMD3]; + STS_SENSOR_Upload_Message(LORAWAN_USER_APP_CTRL_REPLY_PORT, i, outbuf); + } else { + STS_SENSOR_Upload_Config_Invalid_Message(); + } + break; + case 'F': + // TODO # of modules + if (((uint8_t)(tlv_buf[CFG_CMD3]-0x30) >= 0) && ((uint8_t)tlv_buf[CFG_CMD3]-0x30) <=9) { + STS_SENSOR_Power_OFF((tlv_buf[CFG_CMD3]-0x30)); + i=0; + outbuf[i++] = (uint8_t) tlv_buf[CFG_CMD1]; + outbuf[i++] = (uint8_t) tlv_buf[CFG_CMD2]; + outbuf[i++] = (uint8_t) tlv_buf[CFG_CMD3]; + STS_SENSOR_Upload_Message(LORAWAN_USER_APP_CTRL_REPLY_PORT, i, outbuf); + } else { + STS_SENSOR_Upload_Config_Invalid_Message(); + } + break; + case 'H': + // TODO # of modules + if (((uint8_t)(tlv_buf[CFG_CMD3]-0x30) >= 0) && ((uint8_t)tlv_buf[CFG_CMD3]-0x30) <=9) { + STS_SENSOR_MEMS_Reset((tlv_buf[CFG_CMD3]-0x30)); + i=0; + outbuf[i++] = (uint8_t) tlv_buf[CFG_CMD1]; + outbuf[i++] = (uint8_t) tlv_buf[CFG_CMD2]; + outbuf[i++] = (uint8_t) tlv_buf[CFG_CMD3]; + STS_SENSOR_Upload_Message(LORAWAN_USER_APP_CTRL_REPLY_PORT, i, outbuf); + } else { + STS_SENSOR_Upload_Config_Invalid_Message(); + } + break; + + case 'D': + 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')))) + { + 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; + } else if ((char)tlv_buf[CFG_CMD5] == 'S') { + + if (periodicity_length < 10) periodicity_length = 10; + + } + + OnTxPeriodicityChanged(periodicity_length*1000); //translate to 1000ms=1s + i = 0; + outbuf[i++] = (uint8_t) tlv_buf[CFG_CMD1]; + outbuf[i++] = (uint8_t) tlv_buf[CFG_CMD2]; + outbuf[i++] = (uint8_t) tlv_buf[CFG_CMD3]; + outbuf[i++] = (uint8_t) tlv_buf[CFG_CMD4]; + outbuf[i++] = (uint8_t) tlv_buf[CFG_CMD5]; + + STS_SENSOR_Upload_Message(LORAWAN_USER_APP_CTRL_REPLY_PORT, i, outbuf); + // Save config to NVM + sts_cfg_nvm.mtmcode1 = sts_mtmcode1; + sts_cfg_nvm.mtmcode2 = sts_mtmcode2; + sts_cfg_nvm.version = sts_version; + sts_cfg_nvm.hardware_ver = sts_hardware_ver; + sts_cfg_nvm.periodicity_h = (tlv_buf[CFG_CMD3]-0x30); + sts_cfg_nvm.periodicity_l = (tlv_buf[CFG_CMD4]-0x30); + if (((char)tlv_buf[CFG_CMD5] == 'S') && (periodicity_length == 10)) + { + sts_cfg_nvm.periodicity_h = 0X01; + sts_cfg_nvm.periodicity_l = 0X00; + } + sts_cfg_nvm.unit = periodicity_unit; + + OnStoreSTSCFGContextRequest(); + APP_LOG(TS_OFF, VLEVEL_L, "###### YUNHORN Periodicity Changed to [ %d ] Seconds\r\n", periodicity_length); + + } else { + STS_SENSOR_Upload_Config_Invalid_Message(); + } + break; + + default: + STS_SENSOR_Upload_Config_Invalid_Message(); + break; + } + } // END OF *** BOARD LEVEL CONTROL OR REPORT + else if (((char)tlv_buf[CFG_CMD1] == 'P') && (tlv_buf_size >= 4)) // BEGIN OF PARAMETER CONFIG + { + /* + * YUNHORN STS PRODUCT SUBMODULE, MEMS OR SENSOR HEAD LEVEL PARAMETER TUNING SECTION + */ + + uint8_t tlv_h2_cnt = 0x00, mems_ver=0x00; + i = P_MEM_CFG; //start of parameter + + switch (tlv_buf[P_MEMS_NO]-0x30) { //#1 No. of MEMS components + //default first sensor head or MEMS component, default 1 sensor heads + case 0: //default sensor head or MEMS component + case 1: //first sensor head or MEMS component +#ifdef YUNHORN_STS_M7_ENABLED + mems_ver = (tlv_buf[P_MTM_VER]-0x30); // #2 MTM-ver + if (mems_ver == sts_version) { // Firmware version or Variation of MEMS/component + if (tlv_buf_size == CFG_CMD_PARAMETER_SIZE) { //Validation check + act_threshold = (uint8_t) (tlv_buf[i++]-0x30)*10; // "P 1 0 0 8" -> 0*10 + act_threshold += (tlv_buf[i++]-0x30); // "P 1 0 0 8" -> 0*10 + 8 + inact_threshold = (uint8_t) (tlv_buf[i++]-0x30)*10; // "P 1 0 0 8 0 4" -> 0*10 + inact_threshold += (tlv_buf[i++]-0x30); // "P 1 0 0 8 0 4" -> 0*10 + 4 + inact_duration = (uint8_t) (tlv_buf[i++]-0x30)*10; // "P 1 0 0 8 0 4 0 3" -> 0*10 + inact_duration += (uint8_t) (tlv_buf[i++]-0x30); // "P 1 0 0 8 0 4 0 3" -> 0*10+3 + + if (act_threshold <= inact_threshold) + act_threshold += 2; + } + + STS_MOTION_SENSOR_ACT_INACT_DURATION_Init(); + + i=0; // Step 1: Prepare status update message + outbuf[i++] = (char) 'P'; + outbuf[i++] = sts_mtmcode1; + outbuf[i++] = sts_mtmcode2; + outbuf[i++] = sts_version; + outbuf[i++] = sts_hardware_ver; + outbuf[i++] = (uint8_t) act_threshold; + outbuf[i++] = (uint8_t) inact_threshold; + outbuf[i++] = (uint8_t) inact_duration; + + // Step 2: Save valid config to NVM + sts_cfg_nvm.mtmcode1 = sts_mtmcode1; + sts_cfg_nvm.mtmcode2 = sts_mtmcode2; + sts_cfg_nvm.version = sts_version; + sts_cfg_nvm.hardware_ver = sts_hardware_ver; + sts_cfg_nvm.length = NVM_CFG_PARAMETER_SIZE; + + sts_cfg_nvm.p[0] = (uint8_t) act_threshold; + sts_cfg_nvm.p[1] = (uint8_t) inact_threshold; + sts_cfg_nvm.p[2] = (uint8_t) inact_duration; + + OnStoreSTSCFGContextRequest(); + + } else { // Invalid parameters + // Step 1/2: Prepare status update message + + STS_SENSOR_Upload_Config_Invalid_Message(); + APP_LOG(TS_OFF, VLEVEL_L, "###### MTM VER Invalid or Mismatch\r\n"); + } +#endif + // Step 3: Upload status update message + STS_SENSOR_Upload_Message(LORAWAN_USER_APP_CTRL_REPLY_PORT, i, outbuf); + +#if defined(YUNHORN_STS_R1_ENABLED) || defined(YUNHORN_STS_R2_ENABLED)|| defined(YUNHORN_STS_R3_ENABLED) || defined(YUNHORN_STS_R5_ENABLED) +#endif +#ifdef YUNHORN_STS_O1_ENABLED +#endif + + break; + +// for multipul sensor heads or MEMS components, TODO 2022-10-21 PARK HERE + + case 2: +#ifdef YUNHORN_STS_O2_ENABLED + // for 2nd sensor heads such as 2x Presence radar, 2 reedswitch or hall elements +#endif + break; + + default: + // for multipul sensor heads or MEMS components, TODO 2022-10-21 PARK HERE + STS_SENSOR_Upload_Config_Invalid_Message(); + break; + } + } else { + STS_SENSOR_Upload_Config_Invalid_Message(); + } + +} // END OF USER_APP_AUTO_RESPONDER_Parse + +void STS_SENSOR_Upload_Config_Invalid_Message(void) +{ + STS_SENSOR_Upload_Message(LORAWAN_USER_APP_CTRL_REPLY_PORT, 5, "PVXXX"); +} + +void STS_SENSOR_Upload_Message(uint8_t appDataPort, uint8_t appBufferSize, char *appDataBuffer) +{ + LmHandlerErrorStatus_t status = LORAMAC_HANDLER_ERROR; + UTIL_TIMER_Time_t nextTxIn = 0; + + for (uint8_t i=0;i 0) + { + APP_LOG(TS_ON, VLEVEL_L, "Next Tx in : ~%d second(s)\r\n", (nextTxIn / 1000)); + } + } + +} + + +void STS_SENSOR_Auto_Responder_Process(uint8_t tlv_ver,uint8_t tlv_type, uint8_t tlv_length, uint8_t *tlv_content) +{ + uint8_t sensor_mems_type=(tlv_content[0]-0x30); //sensor_mems_type defined in sts_sensors.h + +#ifdef YUNHORN_STS_M7_ENABLED + uint8_t fm_version = FirmwareVersion; //MajorVer+MinorVer+SubMinorVer; + +#endif + + switch (sensor_mems_type) + { +#ifdef YUNHORN_STS_M7_ENABLED + case sts_mtmcode2: + //TODO + break; +#endif +#ifdef YUNHORN_STS_R0_ENABLED + case STS_CTRL_CMD_MEMS_TUNE_TOF_VL53L0X: + + break; +#endif +#ifdef YUNHORN_STS_P1_ENABLED + case STS_CTRL_CMD_MEMS_TUNE_FMCW_TI68X: + + break; +#endif +#ifdef YUNHORN_STS_OO_ENABLED + case STS_CTRL_CMD_MEMS_TUNE_PCR_A12X: + + break; + + case STS_CTRL_CMD_PRESENCE_SETTING: + + break; +#endif +#ifdef YUNHORN_STS_M3_ENABLED + case STS_CTRL_CMD_MEMS_TUNE_DIGITAL_RELAY: + + break; +#endif +#ifdef YUNHORN_STS_M5_ENABLED + case STS_CTRL_CMD_MEMS_TUNE_FAN_CONTROL: + + break; +#endif + default: + + break; + + } +} + + + static void SendTxData(void) { /* USER CODE BEGIN SendTxData_1 */ LmHandlerErrorStatus_t status = LORAMAC_HANDLER_ERROR; uint8_t batteryLevel = GetBatteryLevel(); - sensor_t sensor_data; + sensor_t sensor_data; + STS_M7_SensorDataTypeDef m7_data; UTIL_TIMER_Time_t nextTxIn = 0; if (LmHandlerIsBusy() == false) @@ -572,9 +963,14 @@ static void SendTxData(void) #endif /* CAYENNE_LPP */ EnvSensors_Read(&sensor_data); + STS_MOTION_SENSOR_Read(&m7_data); + + AppData.Port = LORAWAN_USER_APP_PORT; + AppData.Buffer[i++] = AppLedStateOn; //#0 + APP_LOG(TS_ON, VLEVEL_M, "VDDA: %d\r\n", batteryLevel); - APP_LOG(TS_ON, VLEVEL_M, "temp: %d\r\n", (int16_t)(sensor_data.temperature)); + //APP_LOG(TS_ON, VLEVEL_M, "temp: %d\r\n", (int16_t)(sensor_data.temperature)); AppData.Port = LORAWAN_USER_APP_PORT; @@ -992,3 +1388,204 @@ static void OnRestoreContextRequest(void *nvm, uint32_t nvm_size) /* USER CODE END OnRestoreContextRequest_Last */ } + +void OnStoreSTSCFGContextRequest(void) +{ + /* USER CODE BEGIN OnStoreContextRequest_1 */ + uint8_t i=0, nvm_store_value[YUNHORN_STS_MAX_NVM_CFG_SIZE]={0x0}; + +#ifdef YUNHORN_STS_M7_ENABLED + sts_cfg_nvm.length = (uint8_t) NVM_CFG_PARAMETER_SIZE; + nvm_store_value[i++] = (uint8_t) sts_mtmcode1; + nvm_store_value[i++] = (uint8_t) sts_mtmcode2; + nvm_store_value[i++] = (uint8_t) sts_cfg_nvm.version; + nvm_store_value[i++] = (uint8_t) sts_hardware_ver; + nvm_store_value[i++] = (uint8_t) sts_cfg_nvm.periodicity_h; + nvm_store_value[i++] = (uint8_t) sts_cfg_nvm.periodicity_l; + nvm_store_value[i++] = (uint8_t) sts_cfg_nvm.unit; + nvm_store_value[i++] = (uint8_t) sts_cfg_nvm.length; + for (uint8_t j=0;j< NVM_CFG_PARAMETER_SIZE; j++) { + nvm_store_value[i+j] = (uint8_t) (sts_cfg_nvm.p[j]); + } +#endif + +#ifdef YUNHORN_STS_O0_ENABLED + +#endif + +#ifdef YUNHORN_STS_R0_ENABLED + +#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, YUNHORN_STS_MAX_NVM_CFG_SIZE); + } + /* USER CODE BEGIN OnStoreContextRequest_Last */ + +#ifdef YUNHORN_STS_M7_ENABLED + + + +#endif + /* USER CODE END OnStoreContextRequest_Last */ +} + +void OnRestoreSTSCFGContextRequest(uint8_t *cfg_in_nvm) +{ + /* USER CODE BEGIN OnRestoreSTSCFGContextRequest_1 */ + uint8_t i=0, nvm_store_value[YUNHORN_STS_MAX_NVM_CFG_SIZE]={0x0}; + + /* USER CODE END OnRestoreSTSCFGContextRequest_1 */ + + FLASH_IF_Read(nvm_store_value, STS_CONFIG_NVM_BASE_ADDRESS, YUNHORN_STS_MAX_NVM_CFG_SIZE); + /* USER CODE BEGIN OnRestoreSTSCFGContextRequest_Last */ + + //memcpy(cfg_in_nvm, nvm_store_value, YUNHORN_STS_MAX_NVM_CFG_SIZE); +/* + APP_LOG(TS_OFF, VLEVEL_M, "CFG IN NVM =%02x %02x %02x %02x \r\n", + cfg_in_nvm[0],cfg_in_nvm[1],cfg_in_nvm[2],cfg_in_nvm[3]); +*/ + /* USER CODE END OnRestoreSTSCFGContextRequest_Last */ +} + + +void STS_REBOOT_CONFIG_Init(void) +{ + /* USER CODE BEGIN OnRestoreContextRequest_1 */ + uint8_t i=0, nvm_stored_value[YUNHORN_STS_MAX_NVM_CFG_SIZE]="", nvm_store_size=YUNHORN_STS_MAX_NVM_CFG_SIZE; + + /* USER CODE END OnRestoreContextRequest_1 */ + UTIL_MEM_cpy_8(nvm_stored_value, (void *)STS_CONFIG_NVM_BASE_ADDRESS, nvm_store_size); + /* USER CODE BEGIN OnRestoreContextRequest_Last */ +#ifdef YUNHORN_STS_M7_ENABLED + + if ((nvm_stored_value[0] == 0xFF) || (nvm_stored_value[1] == 0xFF) ||(nvm_stored_value[2] == 0xFF)) + { + APP_LOG(TS_OFF, VLEVEL_L, "Initial Boot with Empty Config, Flash with default config....\r\n"); + OnStoreSTSCFGContextRequest(); + } 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.length = (uint8_t)(nvm_stored_value[NVM_LEN]&0x1F); //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_LEN+1+j]; + } + } +#endif + +#ifdef YUNHORN_STS_O0_ENABLED + +#endif + +#ifdef YUNHORN_STS_R0_ENABLED + +#endif + + OnRestoreSTSCFGContextProcess(); + + /* USER CODE END OnRestoreContextRequest_Last */ +} + +void OnRestoreSTSCFGContextProcess(void) +{ + periodicity_length = (sts_cfg_nvm.periodicity_h)*10+(sts_cfg_nvm.periodicity_l); + if ((char)sts_cfg_nvm.unit =='M') { + periodicity_length *= 60; + } else if ((char) sts_cfg_nvm.unit =='H') { + periodicity_length *= 3600; + } else if ((char) sts_cfg_nvm.unit =='S') { + periodicity_length *= 1; + } + + periodicity_length = (periodicity_length>10)? periodicity_length : 10; + if (sts_lorawan_joined) + { + OnTxPeriodicityChanged(periodicity_length*1000); + } else + { + OnTxPeriodicityChanged(TxPeriodicity); + } + + +#ifdef YUNHORN_STS_M7_ENABLED + if ((sts_version == sts_cfg_nvm.version)&& (NVM_CFG_PARAMETER_SIZE == sts_cfg_nvm.length)) { + + act_threshold = sts_cfg_nvm.p[0]; + inact_threshold = sts_cfg_nvm.p[1]; + inact_duration = sts_cfg_nvm.p[2]; + + STS_MOTION_SENSOR_ACT_INACT_DURATION_Init(); + } + +#endif + + +} + +void STS_SENSOR_Function_Test_Process(void) +{ + char outbuf[32] =""; uint8_t i=0, count=10; + uint8_t i2c_Slave_Dev_ID = 0x00; + + 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)); + + + if (STS_SENSOR_MEMS_Get_ID(&i2c_Slave_Dev_ID) == 0x00) { + outbuf[i++] = (uint8_t) 0X01; //SIZE OF FOLLOWING DATA + outbuf[i++] = (uint8_t) 'X'; // Slave MEMS Not Avaliable + } else + { +#ifdef YUNHORN_STS_M7_ENABLED + int16_t self_test_result[9]={0,0,0,0, 0,0,0, 0,0}; + + STS_MOTION_SENSOR_Function_Test_Process(&self_test_result[0], count); + + outbuf[i++] = (uint8_t) 0X12; //SIZE OF FOLLOWING DATA + + outbuf[i++] = (uint8_t) (self_test_result[0]>>8)&0xff; + outbuf[i++] = (uint8_t) (self_test_result[0])&0xff; + + outbuf[i++] = (uint8_t) (self_test_result[1]>>8)&0xff; + outbuf[i++] = (uint8_t) (self_test_result[1])&0xff; + + outbuf[i++] = (uint8_t) (self_test_result[2]>>8)&0xff; + outbuf[i++] = (uint8_t) (self_test_result[2])&0xff; + + outbuf[i++] = (uint8_t) (self_test_result[3]>>8)&0xff; + outbuf[i++] = (uint8_t) (self_test_result[3])&0xff; + + outbuf[i++] = (uint8_t) (self_test_result[4]>>8)&0xff; + outbuf[i++] = (uint8_t) (self_test_result[4])&0xff; + + outbuf[i++] = (uint8_t) (self_test_result[5]>>8)&0xff; + outbuf[i++] = (uint8_t) (self_test_result[5])&0xff; + + outbuf[i++] = (uint8_t) (self_test_result[6]>>8)&0xff; + outbuf[i++] = (uint8_t) (self_test_result[6])&0xff; + + outbuf[i++] = (uint8_t) (self_test_result[7]>>8)&0xff; + outbuf[i++] = (uint8_t) (self_test_result[7])&0xff; + + outbuf[i++] = (uint8_t) (self_test_result[8]>>8)&0xff; + outbuf[i++] = (uint8_t) (self_test_result[8])&0xff; +#endif + + } + + STS_SENSOR_Upload_Message(LORAWAN_USER_APP_CTRL_REPLY_PORT, i, outbuf); + +} diff --git a/LoRaWAN/App/lora_app.h b/LoRaWAN/App/lora_app.h index 30fb5b4..e68d1b0 100644 --- a/LoRaWAN/App/lora_app.h +++ b/LoRaWAN/App/lora_app.h @@ -57,8 +57,9 @@ extern "C" { * LoRaWAN User application port * @note do not use 224. It is reserved for certification */ -#define LORAWAN_USER_APP_PORT 2 - +#define LORAWAN_USER_APP_PORT sts_senddataport +#define LORAWAN_USER_APP_CTRL_PORT sts_appctrlport +#define LORAWAN_USER_APP_CTRL_REPLY_PORT sts_appctrl_reply_port /*! * LoRaWAN Switch class application port * @note do not use 224. It is reserved for certification