QXZ_QXZL/low3/applications/Host/Host.c

/*
 * Copyright (c) 2006-2021, RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2021-12-01     19813       the first version
 */

#define DBG_TAG "Host"
#define DBG_LVL DBG_LOG
#include <rtdbg.h>

#include "Host.h"
#include <rtthread.h>
#include "modbus_host.h"
#include "main.h"
#include "stdlib.h"

extern void LOAR_SEND_DATA(uint8_t address, uint8_t Inclued_Sensor);
extern uint16_t LTEReadCnt;                              // 串口4接收到的数据个数
extern uint8_t LTEReadFlag;                              // 串口4接收数据完成标记位
extern uint8_t LTE_ReadBuff[LTE_CMD_BUFSIZE];            // 串口4接收数据缓存
extern uint16_t GPRSReadCnt;                             // 串口3接收到的数据个数
extern uint8_t GPRSReadFlag;                             // 串口3接收数据完成标记位
extern uint8_t GPRS_ReadBuff[];                          // 串口3接收数据缓存
extern uint8_t Start_LTE;                                // 用于通知LTE 可以开始了
extern LOAR_Parameter loar_par;                          // 这里面存放loar的参数和ID
extern void Loar_Send_CMD(uint8_t Address, uint8_t Cmd); // 用于唤醒从机
extern LOAR_Tx loar_t;                                   // Loar预发送buffer
extern uint8_t RTC_Check;                                // 记录是否计划时刻唤醒                        *** 关键参数 ***
extern uint8_t Valve_Mode;                               // 阀控使能标记位
extern uint8_t occupy_lora;                              // 独占Lora标记位
extern uint8_t Freq;                                     // 频段标记位
extern uint8_t Tigger_RTC_Check;                         // 记录本次是主动触发的上报任务
extern RTC_TimeTypeDef GetTime;                          // 时间记录结构体
extern RTC_DateTypeDef GetData;                          // 日期记录结构体
extern BL_Para bl_par;                                   // 闹钟定时的修正参数
extern uint8_t bl_par_chg;                               // 需要写入bl par的标记位
extern Revise_par rev_par;                               // 备用时间修正参数
extern uint8_t ReFlash_RTC(void);                        // 刷新RTC时间
extern uint8_t start_monitor;                            // 开启监听器
extern void Recode_e_code(uint8_t code, uint8_t para);   // 记录异常码
extern uint8_t Lora_Get_CSQ(uint8_t addr);               // 获取lora的CSQ
extern uint8_t slave_fw;                                 // 从机固件状态
extern uint8_t Expand_Guard_T;                           // 扩容警戒线程时间
uint8_t Monitoring_button = One;                         // 用于开启或关闭监听按键功能
//uint8_t Matching_running = Zero;                         // 标明配对模式是否运行中
volatile uint8_t Recv_count = 0;                         // 校验无误的已配对从机上报的数据量            *** 关键参数 ***
uint8_t Recv_cnt = 0;                                    // Recv_count 的复制版 仅用于上报状态

#if (Node_Type == Host)

Loar_Device Slave_list[MAX_Slave_NUM + 1] = {0};     // 用于存放从机信息
Loar_Device_Data Data_list[MAX_Slave_NUM + 1] = {0}; // 存放从机上报的数据

#else

Loar_Device Slave_list[1] = {0};     // 用于存放从机信息
Loar_Device_Data Data_list[1] = {0}; // 存放从机上报的数据

#endif
uint16_t slave_sta = 0;   // 本次从机上报的情况
uint8_t up_slave_flg = 0; // 升级从机标记位
uint8_t slave_online = 0; // 从机在线状态的熵增抑制参数

uint8_t Host_Service(void)
{

    if (RTC_Check == One)//RCT 准备好了
    {
        Start_LTE = One;
    }


    if (RTC_Check == Zero && Valve_Mode == 0 /*&& Node_Type != Monitor*/)  // RTC 没准备好
    {
        LOG_I("wait 3s");
        rt_thread_mdelay(6000);
        All_standby(sys_info.interval, 3);
    }
    return 0;
}
extern RTC_TimeTypeDef GetTime;
uint8_t slave_check(uint16_t time_point)
{
    uint8_t i = 0;
    ReFlash_RTC();
    for (i = 0; i <= sys_info.slaves_Number - 1; i++)
    {
        if ((GPRS_ReadBuff[2] == Slave_list[i].Address) &&
            (GPRS_ReadBuff[3] == Slave_list[i].ID[0]) &&
            (GPRS_ReadBuff[4] == Slave_list[i].ID[1]) &&
            (GPRS_ReadBuff[5] == Slave_list[i].ID[2]) &&
            (GPRS_ReadBuff[6] == Slave_list[i].ID[3]))
        {
            //            LOG_I("\nSaved device found .address：%d ID : %02X %02X %02X %02X\n", Slave_list[i].Address,
            //                  Slave_list[i].ID[0], Slave_list[i].ID[1], Slave_list[i].ID[2], Slave_list[i].ID[3]);

            if (GPRS_ReadBuff[9] != sys_info.interval) // 对数据进行处理 同时校准时间间隔
            {
                LOG_W("INR ×");
                LOAR_SEND_DATA(Slave_list[i].Address, Zero);
                return 1;
                format_uartbuf(3);
            }
            else // 对数据进行处理
            {

                if (Data_list[Slave_list[i].Address].saved == 1) // 已处理过 不再进行对时操作
                {
                    LOG_I("time √");
                    Time_fine_tuning(Zero, 0, Slave_list[i].Address);
                    return 1;
                }

                ///
                /// 校验时间点
                /// 从机上报的时间点
                /// 在（address * 10 -1） - （address * 10 + 2 ）之间
                /// 超出则进行微调
                ///

                if (((GetTime.Hours == 15) && (GetTime.Minutes <= 30)) || (GPRS_ReadBuff[0] == 0x5B))
                {
                    RTC_time_synchronization(Slave_list[i].Address);
                    return 1;
                }
                else if (time_point < ((sys_info.slaves_Number * 10 + 10) - (Slave_list[i].Address * 10) - 1)) // 时间提前
                {
                    //                    if (((sys_info.slaves_Number * 10 + 10) - (Slave_list[i].Address * 10) - time_point) <= 15)
                    //                    {
                    //                        Time_fine_tuning(One, ((sys_info.slaves_Number * 10 + 10) - (Slave_list[i].Address * 10)) - time_point, Slave_list[i].Address);
                    //                    }
                    //                    else
                    //                    {
                    //                        Time_fine_tuning(One, 15, Slave_list[i].Address);
                    //                    }

                    Time_fine_tuning(Zero, ((sys_info.slaves_Number * 10 + 10) - (Slave_list[i].Address * 10)) - time_point, Slave_list[i].Address);

                    LOG_I("time ->");
                    return 1;
                }
                else if (time_point > ((sys_info.slaves_Number * 10 + 10) - (Slave_list[i].Address * 10) + 2)) // 时间延后
                {
                    //                    if ((time_point - (sys_info.slaves_Number * 10 + 10) - (Slave_list[i].Address * 10)) <= 3)
                    //                    {
                    //                        Time_fine_tuning(Zero, time_point - ((sys_info.slaves_Number * 10 + 10) - (Slave_list[i].Address * 10)), Slave_list[i].Address);
                    //                    }
                    //                    else
                    //                    {
                    //                        Time_fine_tuning(Zero, 2, Slave_list[i].Address);
                    //                    }

                    Time_fine_tuning(One, time_point - ((sys_info.slaves_Number * 10 + 10) - (Slave_list[i].Address * 10)), Slave_list[i].Address);

                    LOG_I("time <-");
                    return 1;
                }
                else
                {
                    LOG_I("time √");
                    Time_fine_tuning(Zero, 0, Slave_list[i].Address);
                    return 1;
                }
                ///
                /// 校验时间点
                /// 从机上报的时间点
                /// 在（address * 10 -1） - （address * 10 + 2 ）之间
                /// 超出则进行微调
                ///
            }
        }
    }
    format_uartbuf(3);
    return 0;
}
extern uint8_t Freq;
extern uint8_t loar_data_process(uint8_t cfg_address, uint8_t type);
extern uint8_t Read_Para_ok;
extern uint8_t Set_lora_SF(uint8_t SF);
uint8_t Matching_service(void)
{
    return 1;

}

uint8_t Pairing_response(void)
{
    //  LOG_I("Pairing_response");
    uint8_t i = 0;
    char strbuf[30];
    rt_memset(strbuf, 0, 30);
    rt_kprintf("%d ", GPRSReadCnt);
    for (uint8_t j = 0; j < GPRSReadCnt; j++)
    {
        rt_kprintf("%02X ", GPRS_ReadBuff[j]);
    }
    if (GPRS_ReadBuff[0] == 0x5A && GPRS_ReadBuff[1] == 0x05 && GPRS_ReadBuff[2] < 20 && GPRSReadCnt == 9) // 校验是否为配对的广播包
    {
        if (sys_info.slaves_Number == 0) // 当从机数量为0时 直接分配地址 1
        {
            LOG_I("First device");
            Slave_list[0].Address = 1;
            Slave_list[0].ID[0] = GPRS_ReadBuff[3];
            Slave_list[0].ID[1] = GPRS_ReadBuff[4];
            Slave_list[0].ID[2] = GPRS_ReadBuff[5];
            Slave_list[0].ID[3] = GPRS_ReadBuff[6];

            sys_info.slaves_Number++;

            ef_set_env_blob("Slave_list", &Slave_list, sizeof(Loar_Device) * sys_info.slaves_Number);
            ef_set_env_blob("sys_info", &sys_info, sizeof(sys_info));
            upgrade_bak_para(3); // 更新备份参数区
            upgrade_bak_para(1); // 更新备份参数区

            //            LOG_W("\nFirst device added. address：%d ID : %02X %02X %02X %02X\n", Slave_list[0].Address,
            //                  Slave_list[0].ID[0], Slave_list[0].ID[1], Slave_list[0].ID[2], Slave_list[0].ID[3]);
            log_w_slave(0);

            LOAR_SEND_DATA(1, One);

            Recode_e_code(8, Slave_list[0].Address);

            return 1;
        }
        else
        {
            for (i = 0; i <= sys_info.slaves_Number - 1; i++)
            {
                if ((GPRS_ReadBuff[3] == Slave_list[i].ID[0]) &&
                    (GPRS_ReadBuff[4] == Slave_list[i].ID[1]) &&
                    (GPRS_ReadBuff[5] == Slave_list[i].ID[2]) &&
                    (GPRS_ReadBuff[6] == Slave_list[i].ID[3]))
                {
                    if (Slave_list[i].Address != 0)
                    {
                        LOAR_SEND_DATA(Slave_list[i].Address, One);

                        LOG_W("Saved found");

                        log_w_slave(i);

                        //                        LOG_W("\nSaved device found .address：%d ID : %02X %02X %02X %02X\n", Slave_list[i].Address,
                        //                              Slave_list[i].ID[0], Slave_list[i].ID[1], Slave_list[i].ID[2], Slave_list[i].ID[3]);

                        Recode_e_code(8, Slave_list[i].Address);
                        return 1;
                    }
                }
            }
        }
        if (GPRS_ReadBuff[2] >= 0 && GPRS_ReadBuff[2] <= MAX_Slave_NUM && sys_info.slaves_Number <= MAX_Slave_NUM) // 当新设备加入时
        {
            LOG_W("New device");
            Slave_list[sys_info.slaves_Number].Address = sys_info.slaves_Number + 1;
            Slave_list[sys_info.slaves_Number].ID[0] = GPRS_ReadBuff[3];
            Slave_list[sys_info.slaves_Number].ID[1] = GPRS_ReadBuff[4];
            Slave_list[sys_info.slaves_Number].ID[2] = GPRS_ReadBuff[5];
            Slave_list[sys_info.slaves_Number].ID[3] = GPRS_ReadBuff[6];

            rt_sprintf(strbuf, "Slave_list[%d]", sys_info.slaves_Number);
            rt_memset(strbuf, 0, 30);
            sys_info.slaves_Number++;

            ef_set_env_blob("Slave_list", &Slave_list, sizeof(Loar_Device) * sys_info.slaves_Number);
            ef_set_env_blob("sys_info", &sys_info, sizeof(sys_info));
            upgrade_bak_para(3); // 更新备份参数区
            upgrade_bak_para(1); // 更新备份参数区

            LOAR_SEND_DATA(sys_info.slaves_Number, One);

            log_w_slave(sys_info.slaves_Number - 1);

            //            LOG_W("\nNew device addr %d ID %02X %02X %02X %02X\n", Slave_list[sys_info.slaves_Number - 1].Address,
            //                  Slave_list[sys_info.slaves_Number - 1].ID[0], Slave_list[sys_info.slaves_Number - 1].ID[1],
            //                  Slave_list[sys_info.slaves_Number - 1].ID[2], Slave_list[sys_info.slaves_Number - 1].ID[3]);

            Recode_e_code(8, Slave_list[sys_info.slaves_Number - 1].Address);

            return 1;
        }
    }
    else
    {
        LOG_W("Invalid data");
    }

    return 0;
}
//LED闪烁(PB7)
void LED_buling(uint16_t speed, uint8_t excute_time)
{
    /*************     给led闪烁         ***************/

    for (uint8_t a = 0; a < 6 * excute_time; a++)
    {
        HAL_GPIO_TogglePin(RUN_STATUS_GPIO_Port, RUN_STATUS_Pin);
        rt_thread_mdelay(speed);
    }

    /*************     给led闪烁         ***************/
}

/**        微调时间       */
extern void LOAR_SendAckWithCRC(void);
void Time_fine_tuning(uint8_t type, uint8_t value, uint8_t address)
{
    //    if (value >= 3) 有在线维护机制兜底 不必限制修正参数
    //        value = 2;
    if (value > 5)
        value = 5;
    memset(loar_t.TxBuf, 0, 8);
    loar_t.TxCount = 0;                       // 给txcount清零
    loar_t.TxBuf[loar_t.TxCount++] = 0x5A;    // 放入帧头
    loar_t.TxBuf[loar_t.TxCount++] = 0x04;    // 放入数据长度
    loar_t.TxBuf[loar_t.TxCount++] = 0xFE;    // 放入指令码
    loar_t.TxBuf[loar_t.TxCount++] = address; // 放入从机地址
    loar_t.TxBuf[loar_t.TxCount++] = type;    // 放入修正类型
    loar_t.TxBuf[loar_t.TxCount++] = value;   // 放入修正值
    if (address == up_slave_flg)
    {
        loar_t.TxBuf[loar_t.TxCount++] = One;
    }
    else
    {
        loar_t.TxBuf[loar_t.TxCount++] = Zero;
    }
    LOAR_SendAckWithCRC(); // 添加CRC并发送
}

/**         RTC对时    */

/**
 * @brief 为从机进行对时
 *
 * @param address 从机addr
 */
void RTC_time_synchronization(uint8_t address)
{
    ReFlash_RTC();
    memset(loar_t.TxBuf, 0, 9);
    loar_t.TxCount = 0;                             // 给txcount赋值
    loar_t.TxBuf[loar_t.TxCount++] = 0x5A;          // 放入帧头
    loar_t.TxBuf[loar_t.TxCount++] = 0x05;          // 放入数据长度
    loar_t.TxBuf[loar_t.TxCount++] = 0xFF;          // 放入指令码
    loar_t.TxBuf[loar_t.TxCount++] = address;       // 放入从机地址
    loar_t.TxBuf[loar_t.TxCount++] = GetTime.Hours; // 放入时间
    loar_t.TxBuf[loar_t.TxCount++] = GetTime.Minutes;
    loar_t.TxBuf[loar_t.TxCount++] = GetTime.Seconds;
    if (address == up_slave_flg)
    {
        loar_t.TxBuf[loar_t.TxCount++] = One;
    }
    else
    {
        loar_t.TxBuf[loar_t.TxCount++] = Zero;
    }

    //    LOG_I("Send RTC_time packet");
    LOAR_SendAckWithCRC(); // 添加CRC并发送
}

extern Sensor sensor[MAX_SENSOR_NUM];
extern void GenerateValue(int val, int factor, char *eval);

uint8_t Data_fill(void)
{
    uint8_t address = GPRS_ReadBuff[2], i = 0;
    int16_t vbat, value = 0;

    if (Data_list[address].saved == 1)
    {
        //   LOG_W("Filter duplicate data");
        return 0;
    }
    if (address > MAX_Slave_NUM)
    {
        return 0;
    }
    char imei8[8];
    memset(imei8, 0, 8);
    Data_list[address].Address = address; // 首先塞入从机地址 同时在数组中索引角标也是从机地址
                                          //   LOG_I("Data_fill addr:%d", GPRS_ReadBuff[2]);

    /// 塞入从机IMEI
    /// 从机IMEI由主机IMEI后六位+从机ID拼接出来
    ///
    rt_sprintf(imei8, "%02X%02X%02X%02X",
               Slave_list[address - 1].ID[0],
               Slave_list[address - 1].ID[1],
               Slave_list[address - 1].ID[2],
               Slave_list[address - 1].ID[3]);
    rt_sprintf(Data_list[address].imei, "%06s%08s", (char *)(sys_info.imei + 9), imei8);
    // LOG_I("S%d.imei %s ", address, Data_list[address].imei);

    /// 塞入本次上报中的电池电压
    vbat = GPRS_ReadBuff[7] * 256 + GPRS_ReadBuff[8];

    rt_sprintf(Data_list[address].volt, "%d.%02d", vbat / 100, vbat % 100);
    LOG_I("volt :%s", Data_list[address].volt);

    rt_sprintf(Data_list[address].Version, "%d", GPRS_ReadBuff[10]);
    Data_list[address].ver = GPRS_ReadBuff[10];
    LOG_I("v %s", Data_list[address].Version);

    /// 塞入本次接收到的数据
    for (i = 0; i < GPRSReadCnt - 13; i++)
    {
        if (i % 2 == 0)
        {
            value = GPRS_ReadBuff[i + 11] * 256 + GPRS_ReadBuff[i + 1 + 11];
            if (value == 32767) //  此处添加数据校验
            {
                rt_sprintf(Data_list[address].eValue[i / 2], "-99.99");
            }
            else
            {
                GenerateValue((int16_t)value, sensor[i / 2].factor, (char *)(&Data_list[address].eValue[i / 2]));
            }
            LOG_I("S%d v%d :%s ", address, i / 2, Data_list[address].eValue[i / 2]);
            value = 0;
        }
    }
    rt_kprintf("\n");

    if (Lora_Get_CSQ(address) >= 15 && address == up_slave_flg && slave_fw == One)
    {
        send_s_fw(address);
    }
    else if (address == up_slave_flg)
    {
        up_slave_flg = 200 + up_slave_flg;
        ef_set_env_blob("up_slave_flg", &up_slave_flg, sizeof(up_slave_flg));
    }

    Data_list[address].saved = 1;

    return 1;
}

extern uint8_t json_head[]; // 上报数据头
extern char json_fram[];    // 数据格式模板
extern Sensor sensor[];     // 要素模型
extern char sys_info_volt[5];
extern char json_time[20];
uint16_t slave_json_format(char *buff, uint8_t address)
{
    uint16_t i = 0;
    uint16_t total = 0; /* 记录当前数据长度 */
    char ekey[4] = {0};
    if (Data_list[address].saved != 1)
    {
        LOG_W("No Addr %d", address);
        return 0;
    }
    else
    {
        Recv_count--;
    }
    fill_json_time(); /*      塞入时间    */
    rt_memset(buff, 0, json_buf_len);
    total = rt_sprintf((char *)buff, (const char *)json_head, Data_list[address].imei, Data_list[address].SNR, Data_list[address].volt, json_time);
    //total = rt_sprintf((char *)buff, (const char *)json_head, Data_list[address].imei, Data_list[address].SNR, Data_list[address].volt, json_time, Data_list[address].Version);
    ///
    ///
    /// 根据传感器数量塞入数据/*传感器eName不能为空*/
    ///
    ///
    for (i = 0; i < MAX_SENSOR_NUM; i++)
    {
        if (rt_strcmp(sensor[i].eName, "\0") != 0 && sensor[i].cfged == 1)
        {
            total += rt_sprintf((char *)buff + total, json_fram, Data_list[address].eValue[i], sensor[i].eKey, sensor[i].eName, sensor[i].eNum);
        }
    }

    rt_sprintf(ekey, "e%d", sys_info.Sensor_num + 1);
    total += rt_sprintf((char *)buff + total, json_fram, Data_list[address].volt, ekey, "VOLT", "124");

    memset(ekey, 0, 4);
    rt_sprintf(ekey, "e%d", sys_info.Sensor_num + 2);                                                  /* ekey  */
    total += rt_sprintf((char *)buff + total, json_fram, Data_list[address].CSQ, ekey, "RSSI", "224"); /* 填充电量值  */

    memset(ekey, 0, 4);

    buff[total - 1] = ']';
    buff[total] = '}';
    buff[++total] = '}';
    buff[++total] = '\0';
    return total; /* 返回前数据长度 */
}

///
///
/// 是否使用配对模式下的配置呢
///
///  One  使用
///  Zero 不使用
///
/// @param Type
void use_match_cfg(uint8_t Type)
{
    if (Type == One)
    {
        if (Set_TXRX_Frequency_Band(10, 10) != 0)
        {
            LOG_I("Set_Band √");
        }
    }
    if (Type == Zero)
    {
        if (Set_TXRX_Frequency_Band(Freq, Freq) != 0)
        {
            LOG_I("Set Freq %d √", Freq);
        }
    }
}

/// 输入在slave_list中的位置
void log_w_slave(uint8_t addr)
{
    LOG_W("addr %d ID %02X %02X %02X %02X\n", Slave_list[addr].Address,
          Slave_list[addr].ID[0], Slave_list[addr].ID[1], Slave_list[addr].ID[2], Slave_list[addr].ID[3]);
}

/// 为从机发送固件

extern uint8_t Expand_Guard_T;
extern void SPI_FLASH_BufferRead(uint8_t *pBuffer, uint32_t ReadAddr, uint16_t NumByteToRead);
uint8_t *s_fw_buf;
uint8_t send_s_fw(uint8_t addr)
{
    uint8_t result = 0;
    uint8_t time_out = 0;
    static uint8_t percent = 0;
    static uint8_t part = 0;
    static uint8_t retry = 3;
    const uint16_t buf_size = 1024;
    const uint8_t fw_size = 96;
    const uint32_t slave_addr = 0x1C0000;
    static uint8_t pack_num = 6;
    addr--;

    if (s_fw_buf == RT_NULL)
    {
        s_fw_buf = rt_malloc(buf_size); // 申请内存
    }
    if (s_fw_buf == RT_NULL)
    {
        return 0;
    }
    memset(s_fw_buf, 0, buf_size);

    Expand_Guard_T = One; // 扩容时间

    memset(loar_t.TxBuf, 0, 9);
    loar_t.TxCount = 0;
    loar_t.TxBuf[loar_t.TxCount++] = 0x6A;
    loar_t.TxBuf[loar_t.TxCount++] = Slave_list[addr].Address;
    loar_t.TxBuf[loar_t.TxCount++] = Slave_list[addr].ID[0];
    loar_t.TxBuf[loar_t.TxCount++] = Slave_list[addr].ID[1];
    loar_t.TxBuf[loar_t.TxCount++] = Slave_list[addr].ID[2];
    loar_t.TxBuf[loar_t.TxCount++] = Slave_list[addr].ID[3];
    loar_t.TxBuf[loar_t.TxCount++] = 0x6A;
    LOAR_SendAckWithCRC();

    Set_TXRX_Frequency_Band(11, 11); // 设置频段
                                     //  Set_lora_SF(7);

    while (percent < fw_size && retry > 0) // 主任务
    {
        rt_thread_mdelay(100);
        if (send_s_fw_process() == 1)
        {
            if (GPRS_ReadBuff[1] <= fw_size && GPRS_ReadBuff[2] <= pack_num && GPRS_ReadBuff[3] == 0x6A)
            {
                time_out = 0;
                percent = GPRS_ReadBuff[1];
                part = GPRS_ReadBuff[2];
                LOG_W("ask %d->%d", percent, part);
                format_uartbuf(3);
                if (part == 1)
                {
                    SPI_FLASH_BufferRead(s_fw_buf, ((percent * 1024) + slave_addr), 1024);
                    retry = 3;
                }
                reply_fw(percent, part);
            }
            else
            {
                format_uartbuf(3);
            }
        }
        time_out++;
        if (time_out >= 100)
        {
            time_out = 0;
            retry--;
        }
    }

    if (retry > 0 && percent == fw_size)
    {
        result = 1;
        up_slave_flg = One + up_slave_flg;
    }
    else
    {
        up_slave_flg = Zero + up_slave_flg;
    }

    Recode_e_code(22, up_slave_flg); // 记录操作
    ef_set_env_blob("up_slave_flg", &up_slave_flg, sizeof(up_slave_flg));

    Set_TXRX_Frequency_Band(Freq, Freq); // 设置频段

    return result;
}

/// 用于解析收到的从机数据请求包
uint8_t send_s_fw_process(void)
{
    uint8_t result = 0;

    if (GPRS_ReadBuff[0] == 0x6A && GPRSReadFlag == 1) /// 若解析到有效数据
    {
        if (pairing_data_process(0, 1) == 1)
        {
            result = 1;
        }
    }

    return result;
}

void reply_fw(uint8_t packet, uint8_t part)
{
    if (part > 6)
    {
        return;
    }
    uint8_t count = 0;
    uint8_t fill_num = 0;

    memset(loar_t.TxBuf, 0, 205);
    loar_t.TxCount = 0;
    loar_t.TxBuf[loar_t.TxCount++] = 0x6A;
    loar_t.TxBuf[loar_t.TxCount++] = packet;
    loar_t.TxBuf[loar_t.TxCount++] = part;

    if (part == 6) // 决定填充数量
    {
        fill_num = 24;
    }
    else
    {
        fill_num = 200;
    }
    // 0xFF 判断
    if ((*(s_fw_buf + (part - 1) * 200) == 0xFF) && *(s_fw_buf + (part - 1) * 200 + fill_num - 1) == 0xFF)
    {
        for (uint8_t a = 0; a < fill_num; a++)
        {
            if (s_fw_buf[(part - 1) * 200 + a] == 0xFF)
            {
                count++;
            }
        }
    }

    if (count == fill_num) // 填充数据
    {
        loar_t.TxBuf[loar_t.TxCount++] = 0xFF;
    }
    else
    {
        loar_t.TxCount += fill_num;
        memcpy((uint8_t *)(loar_t.TxBuf + 3), (uint8_t *)(s_fw_buf + (part - 1) * 200), fill_num);
    }
    LOAR_SendAckWithCRC();
}

#define THREAD_PRIORITY 12
#define THREAD_STACK_SIZE 2048
#define THREAD_TIMESLICE 5

extern uint8_t EXTI0_1_GPIO_PIN0;
/*
// 这个线程专门用来监听配置按键是否按下 以实现长按进入配置模式
static void Matching_service_task(void *param)
{
    uint8_t i, press_time = 2; // presstime  长按响应时间（秒）
                               // 进入PA0的上升沿中断之后 该标志位被置1
    if (Node_Type != Host)
    {
        LOG_I("jump Match");
        return;
    }
    while (Monitoring_button == One && Node_Type == Host)
    {
        ///
        ///
        /// 2022/05/13修改 更换新版硬件之后，不能一按到底进入配置模式，故而放弃中断的方式，尝试直接监听高电平
        ///
        ///
        while (EXTI0_1_GPIO_PIN0 == 1 || HAL_GPIO_ReadPin(EXT_KEY_GPIO_Port, EXT_KEY_Pin) == GPIO_PIN_SET)
        {
            // 判断检验周期内按键是否都是按下的状态
            // 若持续按下不足3s 则本次不响应
            for (i = 0; i <= press_time * 10; i++)
            {
                if (HAL_GPIO_ReadPin(EXT_KEY_GPIO_Port, EXT_KEY_Pin) == GPIO_PIN_SET)
                {
                    rt_thread_mdelay(100); // 100ms检测一次按键状态
                }
                else
                {
                    // 中途松手 本次按下无效 等待下一次按下进中断
                    EXTI0_1_GPIO_PIN0 = 0;
                    break;
                }
                LOG_I("press_time  %d/%d", i, press_time * 10);
                if (i == press_time * 10)
                {
                    Matching_service();
                }
            }
        }
        rt_thread_mdelay(30); // 加入延时 让出cpu
    }
}

// 这个线程时为了监听按键是否按下了 超过1S  是的话 进入配对从机模式
int Matching_service_thread(void)
{
    rt_thread_t tid1 = RT_NULL;
    tid1 = rt_thread_create("Matching_service_task",
                            Matching_service_task, RT_NULL,
                            2048,
                            6, THREAD_TIMESLICE);
    // 如果获得线程控制块，启动这个线程
    if (tid1 != RT_NULL)
    {
        rt_thread_startup(tid1);
    }
    else
        LOG_I("Match ×");

    return 0;
}
*/
//INIT_APP_EXPORT(Matching_service_thread); // 监听配置的按键有没有按下