QXZ_QXZL/low3/applications/main.c

/*
 * Copyright (c) 2006-2021, RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2021-09-11     RT-Thread    first version
 */
#define RTC_Alarm_RETRY RTC_BKP_DR2
#define RTC_Lora_Cfg RTC_BKP_DR4
#include <rtthread.h>
#include "main.h"
#define DBG_LVL DBG_LOG
#include <rtdbg.h>
#include <stdlib.h>
#include <usart.h>
#include <easyflash.h>
#include "Host.h"
#include "driver_adc.h"
#include "bsp_rtc.h"
#include "rtc.h"
#include "modbus_host.h"
#include "loar.h"
#include "wwdg.h"
#include "gprs.h"
#include "driver_spiflash.h"
#include "iap.h"

static void test_env(void);
static void Trans_protect(void);

extern UART_HandleTypeDef huart1;
extern UART_HandleTypeDef huart2;
extern UART_HandleTypeDef huart3;
extern ADC_HandleTypeDef hadcx;
extern RTC_DateTypeDef GetData; // 获取日期结构体
extern RTC_TimeTypeDef GetTime; // 获取时间结构体
extern RTC_HandleTypeDef hrtc;
extern int Config_GPRS_State;
extern uint8_t Tigger_RTC_Check;
extern void All_standby(uint16_t stime, uint8_t level);
extern void loat_cfg_mode(void);
extern char GPRSReadFlag;          // 这是串口3接收中断标记位
extern uint8_t Get_loarID(void);   // 获取模块ID
extern LOAR_Parameter loar_par;    // 这里面存放loar的参数和ID
extern uint8_t GPRS_ReadBuff[];    // 串口3接收到的数据
extern uint8_t Host_Service(void); // 主机服务程序
extern uint8_t Lora_cfg_RTC;       // RTC中的lora配置标记位
extern uint8_t Valve_Mode;         // 阀控模式
extern uint8_t RTC_Shotdown;       // 即刻休眠标记位

SYS_INFO sys_info = {0}; /*其他系统信息结构体*/
DateTime nowdate;
uint8_t at_config(void);
uint16_t VBAT_FORMAT_CONVERT(uint8_t type);
uint8_t LedPlay(uint16_t Ledperiod, uint16_t LedOn_Cnt, uint16_t *pTimerCnt);
uint8_t run_status = 0; // 0：开机未联网，1：正在联网，2：联网成功
uint16_t TimerCnt;
uint16_t LedOn_Rate;
uint16_t Polar;
uint16_t LedOn_Cnt;
uint8_t easyflash_configured = 0;
uint8_t Read_Para_ok = 0; // 标记开机读取参数完成  1:读取完成
uint8_t Freq = 0;         // 记录拨码开关读到的值
uint16_t MCU_Temp = 0;
uint8_t EXTI0_1_GPIO_PIN0 = 0;
uint8_t Init_ok = 0;                 // 记录成功读取变送器数据的次数
uint8_t All_finsh = Zero;            // 事件处理完成标志
uint8_t imei_fill = Zero;            // 记录Imei是否已填充
uint16_t Now_date = 0;               // 写入IAP固件信息时记录时间
uint16_t Now_Version = 0;            // 传递给bl的版本号
uint16_t VBAT = 0;                   // 采集的电压值
BL_Para bl_par = {0};                // 存放BL传递相关参数
Revise_par rev_par = {0};            // 从机交互相关参数
volatile uint8_t RTC_Check = 0;      // 记录开机时间点是否正确
volatile uint8_t Start_LTE = Zero;   // 开始LTE服务标志
volatile uint8_t wwdg_state = Zero;  // 标记看门后状态 初始化后置One 开始喂狗
Record e_code[MAX_e_code_NUM] = {0}; // 错误码保存

///
///
/// ver_d 版本号的16进制 整数
/// 如最大值65535 代表版本号V65.535
///
///
#define ver_d 3018
/*
 * 2002 : 每次都开启定位
 * 2003 : 02 修改下发FTP 地址相关 （大数据平台）  修改 lte_app1.bin
 *  20031 : 测试FTP专用
 * 2004 : 关闭每次都开启定位，打印在那进入得休眠模式
 * 2005 : RC_IN 主动接受  长按主动上报
 * 2006 : 每次都开启定位，修改GSP定位相关问题
 * 2007 : GPS倍数问题修改 定时时间60s  3s等待时间改为6s  led指示灯每33*30ms一反转  第二次测试使用
 * 2008 : GPS倍数问题修改，包含询问状态信息里的,修改4G透传模式 唐第一版测试
 * 2009 : 调整读取传感器数据位置，强制延时120s
 * 2010 : GPS读取7次去中间三次的平均值,每次都开启GPS(已经关闭)
 * 2011 : 修改参数修正的异常现象，传感器强制延时10s   添加要素模型-10w,修改读取传感器列表上报不全问题
 *---------
 * 2001 : 修改升级固件，不上报update √ +版本号问题
 * 2002 : 修改固件远程升级文件名，lte_appl.bin
 * 2003 : 13个要素不上传数据问题修改上传指令 修改  最大16个要素模型，mqtt下发最大长度不超过1990，1960内为准
 * 2004 : 默认温湿度传感器 + 默认前十次开启定位（远程控制清空）
 * --------
 * 2005 : 1.默认前二十次开启定位（远程控制清空），修改-1 未 =99
 *        2.修改上报数据抬头（删除版本号）json_head
 *        3.状态信息中添加上报时间间隔 interval
 *        4.调整默认传感器参数
 * 2006 : 传感器强制延时5s
 * 2007 : 增加跳过前20次GPS定位指令  写1000
 * 2008 : 增加读不到传感器进入休眠模式，删除无用程序，LED灯触发上报闪灯
 */

 /**
  * @brief 250815 接手代码
  *
  * 3001 : 恢复了按键指示
  * 3002 : 新增startUp_time 在开机log中展示
  * 3003 ：新增定位成功后闪烁
  * 3004 : 去除无论如何都上报定位信息的问题
  * 3005 : 新增触发必定位，以加快验证定位功能
  * 3006 : 测试定位功能
  * 3007 : 修改升级url为 lte_appL.bin
  * 3008 : 修改：回传升级成功信息时不再定位
  * 3009 ：修改为测试服务器+分支topic
  * 3010 : 继续修改topic
  * 3011 : 修改服务器为大数据平台
  * 3012 : 修改默认要素为温湿压
  * 3013 : 修改大数据平台为域名
  * 3014 : 修正没有状态上传的问题
  * 3015 : 测试没有状态上传的问题
  * 3016 : 升级到户外验证设备进行测试
  *   * 3017/8 : 临时增强了rt_thread_idle_excute 防崩溃
  * 3019 : 定制了一个mqtt直传客户平台
  */


char Version[22] = "Version "; // 版本号记录
char task_id[9] = "";          // 任务单ID(若有)
//默认的两个要素
Sensor Def_Sensor[3] = {
        {"e1",1,0,1,0,-10,1,.eName = "Etemp",.eNum = "101",.cfged = 1},
        {"e2",1,1,1,0,-10,1,.eName = "Ehumi",.eNum = "102",.cfged = 1},
        {"e3",1,2,1,0,-10,1,.eName = "Airpress",.eNum = "103",.cfged = 1}
};

int main(void)
{
    Show_Version();
    MX_RTC_Init();
    Enadble_module(1);
    Excute_ADC();
    EfErrCode easyinit = easyflash_init();
    if (easyinit == EF_NO_ERR)
    {
        easyflash_configured = 1;
        test_env();
        Trans_protect();
        Read_Para();
    }
    Check_Free();
    Host_Service();
    while (All_finsh == Zero)
    {
        rt_thread_mdelay(100);
    }
    All_standby(sys_info.interval, 3);
    return RT_EOK;
}

extern LOAR_Tx loar_t;
extern uint8_t Get_loarID(void);
extern Loar_Device Slave_list[];

extern Bak_info bak_info;
extern uint8_t Active_detection;
extern uint8_t occupy_LTE;

extern Sensor sensor[MAX_SENSOR_NUM];
extern uint8_t printf_sensor_list(uint8_t Type);
uint8_t bl_par_chg = 0;

// 开机读取参数
void Read_Para(void)
{
    uint8_t sys_info_chg = 0; // 是否需要更新sys_info
    uint8_t loar_par_chg = 0; // 是否需要更新loar_par

    char strbuf[30];
    rt_memset(strbuf, 0, 30);
    Read_Para_ok = 0;

    /**************        参数1 的RAID1        ***************/

    if (ef_get_env_blob("sys_info", &sys_info, sizeof(sys_info), NULL) > 0)//有 sys_info 值
    {
        upgrade_bak_para(101);// 不是第一次进入  直接更新
    }
    else if (restore_bak_para(1) == One)//没有 "sys_info" 但是 200 地址有
    {
        ef_set_env_blob("sys_info", &sys_info, sizeof(sys_info)); //保存到  sys_info
        Recode_e_code(27, 1);
    }

    /**************        参数1 的RAID1        ***************/

    /**************        参数2 的RAID1        ***************/

    if (ef_get_env_blob("sensor", &sensor, sizeof(Sensor) * MAX_SENSOR_NUM, NULL) > 0)
    {
        upgrade_bak_para(102);
#if Node_Type == LTE

        for (uint8_t a = 0; a < MAX_SENSOR_NUM; a++)
        {
            if(sensor[a].en_corr == 1 && a > (sys_info.Sensor_num - 1))//if 有修正要素  or 大于要素模型个数
            {
                sensor[a].en_corr = 0;
            }
            //rt_kprintf("s%d en   %d >  %d\n" , a , sensor[a].en_corr , sys_info.Sensor_num);
        }

#endif
    }
    else if (restore_bak_para(2) == One)
    {
        ef_set_env_blob("sensor", &sensor, sizeof(Sensor) * MAX_SENSOR_NUM);
        Recode_e_code(27, 2);
    }

    /**
     * @brief 250917 新增默认要素分配
     * 
     */
    if(sensor[0].cfged == 0 && sensor[1].cfged == 0)
    {
        memset(sensor , 0 , sizeof(sensor));
        memcpy(sensor , Def_Sensor , sizeof(Def_Sensor));
        sys_info.Sensor_num = 0;
        for(uint8_t a = 0 ; a < MAX_SENSOR_NUM ; a++)
        {
            if(sensor[a].cfged == 1)
            {
                sys_info.Sensor_num++;
            }
        }
        rt_kprintf("empty init sensor %d\n",sys_info.Sensor_num);

        ef_set_env_blob("sensor", &sensor, sizeof(Sensor) * MAX_SENSOR_NUM);
        ef_set_env_blob("sys_info", &sys_info, sizeof(sys_info));
    }
    ef_get_env_blob("sensor", &sensor, sizeof(Sensor) * MAX_SENSOR_NUM, NULL);
    ef_get_env_blob("bl_par", &bl_par, sizeof(BL_Para), NULL);

    // 运行模式
    if (sys_info.run_mode != One && sys_info.run_mode != Zero) // 校验标记位合法性
    {
        sys_info.run_mode = Zero;
        sys_info_chg = 1;
    }


    LOG_I("    Node_Type       LTE");

    // 读取上报时间间隔的参数
    if (sys_info.interval <= 0 || sys_info.interval > 120) // 校验标记位合法性
    {
        sys_info.interval = 15;  //默认上报时间为15分钟
        sys_info_chg = 1;
        LOG_W("INR def");
    }
    LOG_I("    Report interval   %d", sys_info.interval);



    LOG_I("    Device IMEI:      %s", sys_info.imei);
    if (sys_info.imei[0] != '\0')
    {
        imei_fill = One;
        sys_info.imei[15] = '\0';
    }
    LOG_I("    Device ICCID:     %s", sys_info.iccid);

    if (sys_info.platform == Zero)
    {
        LOG_I("    Platform          120.27");
    }
    else if (sys_info.platform == One)
    {
        LOG_I("    Platform          8.136");
    }
    else
    {
        // LOG_W("plat reset");
        sys_info.platform = One;//默认大数据
        sys_info_chg = 1;
    }



    //更新固件是否正常
    if (sys_info.update_url[0] == '\0' || strstr(sys_info.update_url, ".bin") == NULL)//异常进入
    {
        if (Node_Type == LTE)
        {
            rt_sprintf(sys_info.update_url, "lte_appL.bin");
            sys_info_chg = 1;
        }
    }
    else
    {
        LOG_I("    Update url        %s", sys_info.update_url);
    }




    // 读取485所接入的传感器数量
    if ((sys_info.Sensor_num < 0) || (sys_info.Sensor_num > MAX_SENSOR_NUM)) // 校验标记位合法性
    {
        //  LOG_W("S_num reset %d", sys_info.Sensor_num);
        sys_info.Sensor_num = 0;//默认为 0 个
        sys_info_chg = 1;
    }
    LOG_I("    Sensor_num        %d", sys_info.Sensor_num);

    int startUp_time = 0;
    ef_get_env_blob("startUp_time", &startUp_time, sizeof(startUp_time) , NULL);

    LOG_I("    startUp_time      %d", startUp_time);




    if (Valve_Mode == 1)//不满足
    {
        if (sys_info.V1_Sta != One && sys_info.V1_Sta != Zero)
        {
            LOG_W("V1_Sta reset");
            sys_info.V1_Sta = Zero;
            sys_info_chg = 1;
        }
        LOG_I("    V1_Sta       %d", sys_info.V1_Sta);
        if (sys_info.V2_Sta != One && sys_info.V2_Sta != Zero)
        {
            LOG_W("V2_Sta reset");
            sys_info.V2_Sta = Zero;
            sys_info_chg = 1;
        }
        LOG_I("    V2_Sta       %d", sys_info.V2_Sta);
    }

    if (loar_par_chg == 1) //loar相关
    {
        loar_par_chg = 0;
        Para_upgrade(1);
    }

    printf_sensor_list(1);

    if (sys_info_chg == 1)
    {
        sys_info_chg = 0;
        Para_upgrade(2);
    }

    // 对启动状态参数自增 表明app正常启动
    LOG_I("BL ^");

    uint8_t IAP_success = 0;

    ///
    ///
    /// boot_state 是为了向BL传递当前启动状态的标记位
    ///
    ///

    if (bl_par.boot_state < One)
    {
        bl_par.boot_state += 20;
    }
    bl_par_chg = 1;

    ///
    ///
    ///  Now_date Now_Version这两个参数向BL传递当前的时间和固件版本信息 用于保留备份时的信息
    ///
    ///  upgrade_flag 是app与bl间交互的重要指令
    ///

    ///
    ///
    /// 此处校验向BL传递的版本号和日期与当前状态对比是否有更改 有改动则更新flash中的两项
    ///
    ///

    if (bl_par.Now_Version != Now_Version)
    {
        bl_par_chg = 1;
        bl_par.Now_Version = Now_Version;
        //    LOG_I("update Now_Version %d %d", bl_par.Now_Version, Now_Version);
    }

    ///
    ///
    /// 校验 upgrade_flag 若为150说明刚 还原过固件，若是IAP升级 写入版本号信息
    /// 150 由BL写入 App 清除    当在BL中读取到150 说明App未能成功启动 会触发还原
    ///
    ///
    if (bl_par.upgrade_flag == 150)
    {
        bl_par.iap_boot_state &= 0xFF00;//清空低八位
        bl_par.iap_boot_state = bl_par.iap_boot_state >> 8;
        if (bl_par.iap_boot_state == One)//iap
        {
            /// 读出bak_info
            ef_get_env_blob("bak_info", &bak_info, sizeof(bak_info), NULL);
            LOG_I("app upgrade √");
            bak_info.Bak_sta[0] = One;//有固件
            bak_info.FW_Version[0] = Now_Version;
            bak_info.FW_Ver_tim[0] = Now_date;
            /// 更新bak_info
            ef_set_env_blob("bak_info", &bak_info, sizeof(Bak_info));
            IAP_success = One;
            ef_set_env_blob("IAP_success", &IAP_success, sizeof(IAP_success));
            Recode_e_code(2, ver_d % 200);
            /// 立即上报一次数据 同时上报成功信息
            if (Valve_Mode == 0 && RTC_Check != One)
            {
                bl_par.iap_boot_state = 0;
                bl_par.upgrade_flag = Zero;
                Para_upgrade(3);//保存bl_par
                Trigger_report(5);//复位mcu 备份寄存器2写入0x6400
            }
        }
        else//bakx块
        {
            LOG_I("bak%d->app", bl_par.iap_boot_state);
            /// 分情况记录参数
            if (bl_par.iap_boot_state == 110)
            {
                Recode_e_code(3, 1);
            }
            else if (bl_par.iap_boot_state == 120)
            {
                Recode_e_code(3, 2);
            }
            else
            {
                Recode_e_code(3, 0);
            }
        }
        bl_par.iap_boot_state = 0;
        bl_par.upgrade_flag = Zero;
        bl_par_chg = 1;
    }



    /// 限制revise_time 上限
    if (abs(rev_par.revise_time) > 100)
    {
        rev_par.revise_time = rev_par.revise_time / 5;
    }
    if (abs(rev_par.revise_time) > 30)
    {
        rev_par.revise_time = rev_par.revise_time / 2;
    }
    //   LOG_I("revise_t %d", rev_par.revise_time);
    Read_Para_ok = 1;
    LOG_I("BL $");

    if (MCU_Temp > 600)
    {
        Recode_e_code(1, MCU_Temp / 10);
    }
}

void Enadble_module(uint8_t en)
{
    if (en)
    {
        // HAL_GPIO_WritePin(CONTROL_12V_GPIO_Port, CONTROL_12V_Pin, 1); //开启12V  这个开启操作挪到ADC里面 了

        HAL_GPIO_WritePin(CONTROL_5V_GPIO_Port, CONTROL_5V_Pin, 0); // 开启 5V

        HAL_GPIO_WritePin(Flash_CTL_Port, Flash_CTL_Pin, GPIO_PIN_RESET); // 开启Flash供电

        HAL_GPIO_WritePin(RUN_STATUS_GPIO_Port, RUN_STATUS_Pin, GPIO_PIN_RESET); // 开启led

        //     LOG_I("Enable each");
    }
    else
    {
        HAL_GPIO_WritePin(CONTROL_12V_GPIO_Port, CONTROL_12V_Pin, GPIO_PIN_RESET); // 关闭12V

        HAL_GPIO_WritePin(CONTROL_5V_GPIO_Port, CONTROL_5V_Pin, GPIO_PIN_SET); // 关闭 5V

        if (Valve_Mode != 1)
        {
            HAL_GPIO_WritePin(MODULE_CTL_GPIO_Port, MODULE_CTL_Pin, GPIO_PIN_SET); // 4G去使能  4G断电
            HAL_GPIO_DeInit(MODULE_CTL_GPIO_Port, MODULE_CTL_Pin);
        }
        HAL_GPIO_WritePin(Flash_CTL_Port, Flash_CTL_Pin, GPIO_PIN_SET); // 关闭Flash供电       给不给高电平不要紧 已经是兆欧级别的对地阻值了

        HAL_GPIO_WritePin(GPIOA, EXT_KEY_Pin, GPIO_PIN_RESET);

        HAL_GPIO_WritePin(RUN_STATUS_GPIO_Port, RUN_STATUS_Pin, GPIO_PIN_RESET); // 关闭led

        //     LOG_I("Disable each");
    }
}
//向备份寄存器2中写入 0x6400
void Trigger_report(uint8_t type)
{

    Recode_e_code(11, type);

    rt_kprintf("---------  RTC Reset  ----------\r\n");
    __HAL_RCC_PWR_CLK_ENABLE(); // 使能电源时钟PWR
    HAL_PWR_EnableBkUpAccess(); // 取消备份区域写保护
    HAL_RTCEx_BKUPWrite(&hrtc, RTC_Alarm_RETRY, 0x6400);
    HAL_PWR_DisableBkUpAccess(); // 开启备份区域写保护
    RESET_MCU();
}

/***************************
 *  初始化PC7
 * 此函数硬件复位MCU
 * 物理复位  最为致命
 *
 *************************/
void RESET_MCU(void)
{
    rt_kprintf("----------   RESET_MCU   ----------\r\n");
    GPIO_InitTypeDef GPIO_InitStruct = {0};
    /*Configure GPIO pins : Reset_Pin */
    GPIO_InitStruct.Pin = MCU_RESET_Pin;
    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    GPIO_InitStruct.Pull = GPIO_PULLDOWN;
    HAL_GPIO_Init(MCU_RESET_Port, &GPIO_InitStruct);
}

Boot boot = {0};





static void test_env(void)
{
    ef_get_env_blob("boot", &boot, sizeof(boot), NULL);
    boot.boot_times += 1;
    if (RTC_Check == One)
    {
        boot.timed_start += 1;
    }
    rt_kprintf("The system now boot %lu/%lu times\n\n", boot.timed_start, boot.boot_times);
    ef_set_env_blob("boot", &boot, sizeof(boot));
}

/**
 * @brief 用于运输模式保护
 *
 *  1. 当所有要素NA10次进入运输保护
 *  2. 保护后,两小时开机上报一次数据
 *  3. 保护后,开机上报数据或者开机检查传感器的时候,能读到要素>0就退出保护
 *
 *
 */
extern int16_t READ_MODBUS_DATA_1(uint8_t times);
Trans_para Trans_p = {0}; // 存放保护模式相关参数   main 初始化easyflash完成后调用
//确保数据无误
static void Trans_protect(void)
{
    if (Node_Type == LTE)
    {
        ef_get_env_blob("Trans_p", &Trans_p, sizeof(Trans_p), NULL);
        ef_get_env_blob("bl_par", &bl_par, sizeof(BL_Para), NULL);
        bl_par.iap_boot_state &= 0xFF00;//清空第八位
        bl_par.iap_boot_state = bl_par.iap_boot_state >> 8;//读取高八位，实际拿到是那个固件升级
        if (RTC_Check != One)//RTC校验失败
        {
            if (bl_par.upgrade_flag == 150 && bl_par.iap_boot_state == One)//if跟IAP块有关
            {
                return;
            }
            //LOG_W("not in RTC_Check");
            if(Trans_p.en == One && Tigger_RTC_Check != One)
            {

                LOG_I("wait 3s  120min");
                rt_thread_mdelay(4500);
                All_standby(120, 3);//相关
            }
            return;
        }
        if (Trans_p.en != One)
        {
            //LOG_W("not in Trans_p.en");
            return;
        }
    }

}

uint8_t Get_lora_Freq(void)
{
    uint8_t Freq = 0;
    if (HAL_GPIO_ReadPin(GPIOD, GPIO_PIN_3) == GPIO_PIN_SET)
    {
        Freq += 1;
    }
    if (HAL_GPIO_ReadPin(GPIOD, GPIO_PIN_2) == GPIO_PIN_SET)
    {
        Freq += 2;
    }
    if (HAL_GPIO_ReadPin(GPIOD, GPIO_PIN_1) == GPIO_PIN_SET)
    {
        Freq += 3;
    }
    if (HAL_GPIO_ReadPin(GPIOD, GPIO_PIN_0) == GPIO_PIN_SET)
    {
        Freq += 4;
    }
    LOG_I("Freq %d", Freq);
    if (Freq > 9)
    {
        Freq = 9;
    }

    return Freq;
}
extern uint8_t sys_info_upgrade_flag;

void Para_upgrade(uint8_t type)
{
    if (type == 1)
    {
        LOG_W("loar_par SET %d", ef_set_env_blob("loar_par", &loar_par, sizeof(loar_par)));
    }
    if (type == 2)
    {
        sys_info_upgrade_flag = 0;
        LOG_W("sys_info SET %d", ef_set_env_blob("sys_info", &sys_info, sizeof(sys_info)));
        upgrade_bak_para(1); // 更新备份参数区
    }
    if (type == 3)
    {
        bl_par_chg = 0;
        LOG_I("bl_par SET %d", ef_set_env_blob("bl_par", &bl_par, sizeof(bl_par)));
    }
}

uint8_t Double_INR = 0;
#define Protect_vol 3.5 // 电池欠压保护电压

void Check_VBAT(void)
{
    VBAT = VBAT_FORMAT_CONVERT(1);
    /// //判断电池电压区间
    ///
    /// 电压 >= 3.5              正常工作
    /// 电压 < 3.5               持续60分钟休眠
    ///
    ///
    LOG_I("VBAT %d.%d%d", VBAT / 100, (VBAT / 10) % 10, VBAT % 10);
    if (VBAT >= Protect_vol * 100 && VBAT < 450)  //不在 350 - 450 区间 返回
    {
        return;
    }
    else  // 在 350 - 450 区间
    {
        //        Reflash_BL_Sta_Check(); // 修改bl的状态码，使其不初始化ef
        //        rt_thread_mdelay(2000);
        // RTC_Shotdown = One;
        LOG_W("INR=60");
        sys_info.run_mode = Zero;
        // Recode_e_code(4, VBAT / 10);  //此时ef并没有初始化 没法进行记录
        if (Valve_Mode == 1)
        {
            inter_standby(60);
        }
        else
        {
            All_standby(60, 1);
            All_standby(60, 3);
        }
    }
}

extern void Usart4_SendString(char *str);
//打印版本号
void Show_Version(void)
{
    sys_info.run_mode = Zero;
    Now_Version = ver_d;
    rt_sprintf((Version + 8), "%d.%03d %s", ver_d / 1000, ver_d % 1000, task_id);
    //    rt_kprintf("\nWelcome to use Yunfei low-power acquisition Host/LTE node.%s\n", Version);
    rt_kprintf("\n%s\n", Version);

    //  LOG_W("CRC32 : %08X",CRC_32((uint8_t *)Version , 13));
}

//打印e_code
void Check_Free(void)
{
    if (Tigger_RTC_Check == One)
    {
        RTC_DateTypeDef date = {0};
        RTC_TimeTypeDef time = {0};
        ef_get_env_blob("e_code", &e_code, sizeof(Record) * (MAX_e_code_NUM), NULL);

        if (e_code[0].Time_Stampe > MAX_e_code_NUM)
        {
            e_code[0].code = MAX_e_code_NUM;
        }
        else
        {
            e_code[0].code = e_code[0].Time_Stampe;
        }
        LOG_I("e_code cnt %d", e_code[0].Time_Stampe);


        for (uint8_t a = 1; a <= e_code[0].code; a++)
        {
            Prase_Time_Stampe(&date, &time, e_code[a].Time_Stampe);
            LOG_I("%d c %03d p %03d %02d/%02d/%02d %02d:%02d:%02d",
                  a,
                  e_code[a].code, e_code[a].para,
                  date.Year, date.Month, date.Date,
                  time.Hours, time.Minutes, time.Seconds);
            if (a == MAX_e_code_NUM - 1)
            {
                a++;
            }
        }
    }
}


//  开启ADC检查
void Excute_ADC(void)
{
    uint16_t value = 0;

    MX_ADCx_Init(1);// PB0
    Check_VBAT();//读取电池电压
    MX_ADCx_Init(2);//MCU内部温度初始化
    value = VBAT_FORMAT_CONVERT(2);
    MCU_Temp = value;
    //  LOG_I("temp %d.%d\n", value / 10, value % 10);
    HAL_GPIO_WritePin(CONTROL_12V_GPIO_Port, CONTROL_12V_Pin, 1); // 开启12V
}

extern uint8_t ReFlash_RTC(void);
extern uint32_t Get_Time_Stampe(void);

///
///
///     记录异常状态码 同时记录时间戳 和一个参数
///
///
/// @param code 异常码  para随码参数
void Recode_e_code(uint8_t code, uint8_t para)
{
    if (easyflash_configured == 1)
    {
        ef_get_env_blob("e_code", &e_code, sizeof(Record) * (MAX_e_code_NUM), NULL); // 读出flash中的错误码列表

        e_code[0].Time_Stampe++;                         // 累计码位置指向偏移
        if (e_code[0].Time_Stampe % MAX_e_code_NUM == 0) // 避过0位置
        {
            e_code[0].Time_Stampe++;// 60循环 从1开始
        }
        e_code[e_code[0].Time_Stampe % MAX_e_code_NUM].code = code;                     // 放入错误码
        e_code[e_code[0].Time_Stampe % MAX_e_code_NUM].para = para;                     // 放入附带参数
        ReFlash_RTC();                                                                  // 刷新时间
        e_code[e_code[0].Time_Stampe % MAX_e_code_NUM].Time_Stampe = Get_Time_Stampe(); // 放入时间戳

        LOG_W("e_code SET %d c %d p %d", ef_set_env_blob("e_code", &e_code, sizeof(Record) * (MAX_e_code_NUM)), code, para);
    }
}

void Reflash_BL_Sta_Check(void)
{
    __HAL_RCC_PWR_CLK_ENABLE(); // 使能电源时钟PWR
    HAL_PWR_EnableBkUpAccess(); // 取消备份区域写保护
    HAL_RTCEx_BKUPWrite(&hrtc, RTC_BKP_DR3, 0x699D);
    HAL_PWR_DisableBkUpAccess(); // 开启备份区域写保护
    // rt_kprintf("B  %04X \r\n", HAL_RTCEx_BKUPRead(&hrtc, RTC_BKP_DR3));
}

/**
 * @brief 更新写在flash固定位置中得重要参数备份
 *
 * @param type 1-3     对应参数号 直接进行更新
 *
 *        type 101-103 对应参数号 检查是否已经存在进行按需备份
 *
 */
void upgrade_bak_para(uint8_t type)
{
    uint8_t flag = One;
    uint8_t bak_sta = 0;

    if ((type >= 1 && type <= 3) || (type >= 101 && type <= 103))
    {
        switch (type)
        {
        case 1:

            SPI_FLASH_SectorErase(bak_flg_SYS_INFO);
            SPI_FLASH_BufferWrite((uint8_t *)&flag, bak_flg_SYS_INFO, sizeof(flag));
            SPI_FLASH_SectorErase(bak_addr_SYS_INFO);
            SPI_FLASH_BufferWrite((uint8_t *)&sys_info, bak_addr_SYS_INFO, sizeof(sys_info));

            // rt_kprintf("UP A");
            break;
        case 2:

            SPI_FLASH_SectorErase(bak_flg_Sensor);
            SPI_FLASH_BufferWrite((uint8_t *)&flag, bak_flg_Sensor, sizeof(flag));
            SPI_FLASH_SectorErase(bak_addr_Sensor);
            SPI_FLASH_BufferWrite((uint8_t *)&sensor, bak_addr_Sensor, sizeof(Sensor) * MAX_SENSOR_NUM);

            // rt_kprintf("UP B");
            break;
        case 3:

            SPI_FLASH_SectorErase(bak_flg_Loar_Device);
            SPI_FLASH_BufferWrite((uint8_t *)&flag, bak_flg_Loar_Device, sizeof(flag));
            SPI_FLASH_SectorErase(bak_addr_Loar_Device);
            SPI_FLASH_BufferWrite((uint8_t *)&Slave_list, bak_addr_Loar_Device, sizeof(Loar_Device) * (MAX_Slave_NUM + 1));

            // rt_kprintf("UP C");
            break;

        case 101:

            SPI_FLASH_BufferRead(&bak_sta, bak_flg_Sensor, 1);
            if (bak_sta != One)
            {
                SPI_FLASH_SectorErase(bak_flg_SYS_INFO);
                SPI_FLASH_BufferWrite((uint8_t *)&flag, bak_flg_SYS_INFO, sizeof(flag));
                SPI_FLASH_SectorErase(bak_addr_SYS_INFO);
                SPI_FLASH_BufferWrite((uint8_t *)&sys_info, bak_addr_SYS_INFO, sizeof(sys_info));
            }

            break;
        case 102:

            SPI_FLASH_BufferRead(&bak_sta, bak_flg_Sensor, 1);
            if (bak_sta != One)
            {
                SPI_FLASH_SectorErase(bak_flg_Sensor);
                SPI_FLASH_BufferWrite((uint8_t *)&flag, bak_flg_Sensor, sizeof(flag));
                SPI_FLASH_SectorErase(bak_addr_Sensor);
                SPI_FLASH_BufferWrite((uint8_t *)&sensor, bak_addr_Sensor, sizeof(Sensor) * MAX_SENSOR_NUM);
            }

            break;
        case 103:

            SPI_FLASH_BufferRead(&bak_sta, bak_flg_Loar_Device, 1);
            if (bak_sta != One)
            {
                SPI_FLASH_SectorErase(bak_flg_Loar_Device);
                SPI_FLASH_BufferWrite((uint8_t *)&flag, bak_flg_Loar_Device, sizeof(flag));
                SPI_FLASH_SectorErase(bak_addr_Loar_Device);
                SPI_FLASH_BufferWrite((uint8_t *)&Slave_list, bak_addr_Loar_Device, sizeof(Loar_Device) * (MAX_Slave_NUM + 1));
            }

            break;

        default:
            break;
        }
    }
}

/**
 * @brief 将flash中固定地址区的参数还原出来
 *
 *  调用可以一键还原所有备份参数 美滋滋
 *
 * @param type 1-3 对应参数号 0x9D对应全体
 */
uint8_t restore_bak_para(uint8_t type)
{
    uint8_t bak_flg = 0;
    uint8_t result = 0;

    if (type < 1 || (type > 3 && type != 0x9D))
    {
        return result;
    }

    // SYS_INFO
    if (type == 1 || type == 0x9D)
    {
        SPI_FLASH_BufferRead(&bak_flg, bak_flg_SYS_INFO, 1);
        if (bak_flg == One)
        {
            SPI_FLASH_BufferRead((uint8_t *)&sys_info, bak_addr_SYS_INFO, sizeof(SYS_INFO));
            result = One;
            // rt_kprintf("RES A");
        }
        bak_flg = 0;
    }
    // Sensor
    if (type == 2 || type == 0x9D)
    {
        SPI_FLASH_BufferRead(&bak_flg, bak_flg_Sensor, 1);
        if (bak_flg == One)
        {
            SPI_FLASH_BufferRead((uint8_t *)&sensor, bak_addr_Sensor, sizeof(Sensor) * MAX_SENSOR_NUM);
            result = One;
            // rt_kprintf("RES B");
        }
        bak_flg = 0;
    }
    // Loar_Device
    if (type == 3 || type == 0x9D)
    {
        SPI_FLASH_BufferRead(&bak_flg, bak_flg_Loar_Device, 1);
        if (bak_flg == One)
        {
            SPI_FLASH_BufferRead((uint8_t *)&Slave_list, bak_addr_Loar_Device, sizeof(Loar_Device) * (MAX_Slave_NUM + 1));
            result = One;
            // rt_kprintf("RES C");
        }
        bak_flg = 0;
    }

    return result;


}