CBD_XCT/Application_XCT/applications/rs485.c

/*
 * Copyright (c) 2006-2021, RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2024-09-10     RuoFeng       the first version
 */
/*********************↓           define           ↓************************/

#define DBG_ENABLE
#define DBG_COLOR
#define DBG_TAG "rs"
#define DBG_LEVEL DBG_LOG
#include <rtdbg.h>

#define LOG_INR 10 // 默认的log打印间隔（作用域在本文件）

/*********************↑           define           ↑************************/
/**
 *
 *
 *
 *
 * */
/*********************↓           include           ↓************************/

#include "rs485.h"
#include "string.h"
#include "control.h"
#include "Work_XCT.h"
#include <easyflash.h>

/*********************↑           include           ↑************************/
/**
 *
 *
 *
 *
 * */
/*********************↓           extern           ↓************************/

extern void HMI_WRITE(char *fmt, ...);
extern uint8_t ef_cfged;
extern Limit limit;
extern Device_Status_typedef device_status;
extern Sunwork swork;
extern SYSCFG syscfg;
extern void Get_SunTime(void);
extern void CollFanSetPWM(uint8_t percent);

/*********************↑           extern           ↑************************/
/**
 *
 *
 *
 *
 * */
/********************↓           declaration          ↓***********************/

/********************↑           declaration          ↑***********************/
/**
 *
 *
 *
 *
 * */
/*********************↓        global variables      ↓************************/
UART_HandleTypeDef huart5;

uint8_t aRxBuffer[6] = {0};
uint8_t rs_buf_cnt = 0;
uint8_t rs_buf_fis = 0;
uint8_t rs_buf[rs_buf_max] = {0};

Sensor sensor[MAX_SENSOR_NUM] = {0};
uint16_t Read_data[MAX_SENSOR_NUM * 2] = {0};

volatile uint8_t sex_enread = 0;

uint8_t up_time = 0;
uint8_t up_limit = 0;

/*********************↑        global variables      ↑************************/
/**
 *
 *
 *
 *
 * */

/**
 * @brief 清缓存
 *
 */
void clear_rsbuf(void)
{
    rs_buf_fis = 0;
    rs_buf_cnt = 0;
    memset(rs_buf, 0, sizeof(rs_buf));
}

/**
 * @brief 纯手工crc16算法 冰冰凉 嘎嘎好使
 *
 * @param data 数据位
 * @param len 长度
 * @return unsigned int CRC
 */
unsigned int ModBusCRC16(unsigned char *data, unsigned int len)
{
    unsigned int i, j, tmp, CRC16;

    CRC16 = 0xFFFF; // CRC寄存器初始值
    for (i = 0; i < len; i++)
    {
        CRC16 ^= data[i];
        for (j = 0; j < 8; j++)
        {
            tmp = (unsigned int)(CRC16 & 0x0001);
            CRC16 >>= 1;
            if (tmp == 1)
            {
                CRC16 ^= 0xA001; // 异或多项式
            }
        }
    }

    i = (CRC16 & 0x00FF) << 8; // 反向
    CRC16 = (CRC16 & 0xFF00) >> 8;
    CRC16 |= i;

    return CRC16;
}

/*
*********************************************************************************************************
*   函 数 名: BEBufToUint16
*   功能说明: 将2字节数组(大端Big Endian次序，高字节在前)转换为16位整数
*   形    参: _pBuf : 数组
*   返 回 值: 16位整数值
*
*   大端(Big Endian)与小端(Little Endian)
*********************************************************************************************************
*/
uint16_t BEBufToUint16(uint8_t *_pBuf)
{
    return (((uint16_t)_pBuf[0] << 8) | _pBuf[1]);
}

/**
 * @brief 读03寄存器
 *
 * @param slaveAddr 地址
 * @param _reg 起始
 * @param _num 长度
 * @param sort 页码
 * @return Res_def 结果
 */
Res_def MODH_ReadParam_03H(uint8_t slaveAddr, uint16_t _reg, uint16_t _num, uint8_t sort)
{

    uint8_t buf[8] = {0};

    if (slaveAddr == 0 || slaveAddr > 255)
    {
        return res_Error;
    }

    buf[0] = slaveAddr;
    buf[1] = 0x03;
    buf[2] = (uint8_t)(_reg >> 8);
    buf[3] = (uint8_t)(_reg & 0xFF);
    buf[4] = (uint8_t)(_num >> 8);
    buf[5] = (uint8_t)(_num & 0xFF);

    buf[6] = (uint8_t)(ModBusCRC16(buf, 6) >> 8);
    buf[7] = (uint8_t)(ModBusCRC16(buf, 6) & 0xFF);

    RS485_SEND(buf, 8);
    rt_thread_mdelay(390);
    if (rs_buf_fis != 1 || rs_buf_cnt < 6)
    {
        clear_rsbuf();
        return res_Timeout;
    }

    uint16_t CRC16 = ModBusCRC16(rs_buf, rs_buf_cnt - 2);

    if (CRC16 != (uint16_t)(rs_buf[rs_buf_cnt - 2] << 8 | rs_buf[rs_buf_cnt - 1]))
    {
        clear_rsbuf();
        rt_kprintf("CRC Check faild > %04X %02X%02X", CRC16, rs_buf[rs_buf_cnt - 2], rs_buf[rs_buf_cnt - 1]);
        return res_Verifi;
    }
    if (rs_buf[0] != sensor[sort].sensor_addr)
    {
        clear_rsbuf();
        rt_kprintf("SAddr check failed > %d - %d\n", rs_buf[0], sensor[sort].sensor_addr);
        return res_Verifi;
    }

    uint8_t *p;
    p = &rs_buf[3];
    if (rs_buf[2] == sensor[sort].count * 2)
    {
        for (uint8_t a = 1; a <= rs_buf[2]; a++)
        {
            if (a % 2 == 0)
            {
                Read_data[(a / 2) - 1] = BEBufToUint16(p);
                p += 2;
            }
        }
    }
    else
    {
        rt_kprintf("Return cnt check fail > %d \n", rs_buf[2]);
        return res_Verifi;
    }

    clear_rsbuf();
    return res_OK;
}

/**
 * @brief 获取数值的位数
 *
 * @param val 数值
 * @return uint8_t 返回位数
 */
uint8_t GetValueLen(int32_t val)
{
    uint8_t cnt = 1;
    int32_t m = val;
    while (m > 9)
    {
        m /= 10;
        cnt++;
    }
    // rt_kprintf("%d is %d len\n",val , cnt);
    return cnt;
}
/**
 * @brief 给定val和factor 生成eval
 *
 * @param val 原始数据
 * @param factor 因数
 * @param eval eval的指针
 */
void GenerateValue(int16_t val, int factor, char *eval)
{

    // rt_kprintf("val %d \n", val);

    if (val == 0x7FFF)
    {
        rt_sprintf(eval, "-99.99");
        return;
    }

    if (factor > 0)
    {
        rt_sprintf((char *)eval, "%d", val * factor);
    }
    else if (factor < 0)
    {
        switch (GetValueLen(abs(factor)))
        {
        // 当负的单位数 不做处理
        case 1:
        {
        }
        break;
        // 当负的两位数 例如-10
        case 2:
        {
            if (val >= 0)
            {
                rt_sprintf((char *)eval, "%d.%01d", val / abs(factor), val % abs(factor));
            }
            else
            {
                rt_sprintf((char *)eval, "-%d.%01d", abs(val) / abs(factor), abs(val) % abs(factor));
            }
        }
        break;
        // 当负的三位数 例如-100
        case 3:
        {
            if (val >= 0)
            {
                rt_sprintf((char *)eval, "%d.%02d", val / abs(factor), val % abs(factor));
            }
            else
            {
                rt_sprintf((char *)eval, "-%d.%02d", abs(val) / abs(factor), abs(val) % abs(factor));
            }
        }
        break;
        // 当负的四位数 例如-1000      //flash不够了 4位小数先不考虑
        case 4:
        {
            if (val >= 0)
            {
                rt_sprintf((char *)eval, "%d.%03d", val / abs(factor), val % abs(factor));
            }
            else
            {
                rt_sprintf((char *)eval, "-%d.%03d", abs(val) / abs(factor), abs(val) % abs(factor));
            }
        }
        break;
        default:
            break;
        }
    }
    // 不对factor == 0的情况做处理

    // rt_kprintf("Gen %s\n",eval);
}

/**
 * @brief 给定val和factor 生成eval
 *
 * @param val 原始数据
 * @param factor 因数
 * @param eval eval的指针
 */
void GenerateValue_32(int32_t val, int factor, char *eval)
{

    // rt_kprintf("val %d \n", val);

    if (val == 0x7FFF)
    {
        rt_sprintf(eval, "-99.99");
        return;
    }

    if (factor > 0)
    {
        rt_sprintf((char *)eval, "%d", val * factor);
    }
    else if (factor < 0)
    {
        switch (GetValueLen(abs(factor)))
        {
        // 当负的单位数 不做处理
        case 1:
        {
        }
        break;
        // 当负的两位数 例如-10
        case 2:
        {
            if (val >= 0)
            {
                rt_sprintf((char *)eval, "%d.%01d", val / abs(factor), val % abs(factor));
            }
            else
            {
                rt_sprintf((char *)eval, "-%d.%01d", abs(val) / abs(factor), abs(val) % abs(factor));
            }
        }
        break;
        // 当负的三位数 例如-100
        case 3:
        {
            if (val >= 0)
            {
                rt_sprintf((char *)eval, "%d.%02d", val / abs(factor), val % abs(factor));
            }
            else
            {
                rt_sprintf((char *)eval, "-%d.%02d", abs(val) / abs(factor), abs(val) % abs(factor));
            }
        }
        break;
        // 当负的四位数 例如-1000      //flash不够了 4位小数先不考虑
        case 4:
        {
            if (val >= 0)
            {
                rt_sprintf((char *)eval, "%d.%03d", val / abs(factor), val % abs(factor));
            }
            else
            {
                rt_sprintf((char *)eval, "-%d.%03d", abs(val) / abs(factor), abs(val) % abs(factor));
            }
        }
        break;
        default:
            break;
        }
    }
    // 不对factor == 0的情况做处理

    // rt_kprintf("Gen %s\n",eval);
}

/**
 *
 *
 *          READ_MODBUS_DATA_1()
 *          该函数可根据sensor中存放的传感器参数 自动进行解析和运算
 *          并将结果组包为字符串 存于sensor[a].eValue
 *          若读取失败 evalue使用 -99.99填充 平台显示N/A
 *
 *
 */

int8_t READ_MODBUS_DATA_1(Sensor_Read_Type srt)
{
    uint16_t log_en_inr = LOG_INR; // 打印log的速度 数值越小 打印越频繁
    static int16_t log_en_cnt = -1;

    if (srt >= s_TypeMAX)
    {
        return -1;
    }
    int8_t res = 0;
    uint8_t en_log = 0;

    if (chk_log_time)
    {
        en_log = 1;
    }

    if (srt == s_ALL)
    {
        for (uint8_t a = 0; a < MAX_SENSOR_NUM; a++)
        {
            if (sensor[a].cfged == 1)
            {
                sensor[a].value = 0;
                // rt_kprintf("start Read %s\n" , sensor[a].eName);
                if (sensor[a].online == 0)
                {
                    rt_sprintf(sensor[a].eValue, "-99.99");
                }

                if (MODH_ReadParam_03H(sensor[a].sensor_addr, sensor[a].start_reg, sensor[a].count, a) == res_OK)
                {
                    // rt_kprintf("res %X \n", Read_data[0]);
                    for (uint8_t b = 0; b < sensor[a].d_length; b++)
                    {
                        sensor[a].value += Read_data[sensor[a].d_pos + b] << ((sensor[a].d_length - 1 - b) * 16);
                    }

                    memset(sensor[a].eValue, 0, sizeof(sensor[a].eValue));

                    // 使用新算法对eval进行生成
                    if (sensor[a].d_length == 1)
                    {
                        GenerateValue(sensor[a].value, sensor[a].factor, (char *)sensor[a].eValue); // 16位整型
                    }
                    else
                    {
                        GenerateValue_32(sensor[a].value, sensor[a].factor, (char *)sensor[a].eValue); // 32位整型
                    }

                    if (en_log || 1)
                        rt_kprintf("%s %s  / ", sensor[a].eName, sensor[a].eValue);
                    sensor[a].online = 2;
                    res++;
                }
                else
                {
                    if (en_log || 1)
                        rt_kprintf("s%d %s × ", a, sensor[a].eName);
                    if (sensor[a].online > 0)
                    {
                        sensor[a].online--;
                        rt_kprintf("%s -- \n", sensor[a].eName);
                    }
                }
            }
            // rt_thread_mdelay(500); // 每个要素结束的间隔
            memset(Read_data, 0, sizeof(Read_data));
            rt_thread_mdelay(1000);
        }
    }
    else
    {
        if (sensor[srt].cfged == 1)
        {
            sensor[srt].value = 0;

            rt_sprintf(sensor[srt].eValue, "-99.99");

            if (MODH_ReadParam_03H(sensor[srt].sensor_addr, sensor[srt].start_reg, sensor[srt].count, srt) == res_OK)
            {
                for (uint8_t b = 0; b < sensor[srt].d_length; b++)
                {
                    sensor[srt].value += Read_data[sensor[srt].d_pos + b] << ((sensor[srt].d_length - 1 - b) * 16);
                }

                memset(sensor[srt].eValue, 0, sizeof(sensor[srt].eValue));

                // 使用新算法对eval进行生成
                if (sensor[srt].d_length == 1)
                {
                    GenerateValue(sensor[srt].value, sensor[srt].factor, (char *)sensor[srt].eValue); // 16位整型
                }
                else
                {
                    GenerateValue_32(sensor[srt].value, sensor[srt].factor, (char *)sensor[srt].eValue); // 32位整型
                }

                rt_kprintf("s%d %s %s ", srt, sensor[srt].eName, sensor[srt].eValue);
                sensor[srt].online = 1;
            }
            else
            {
                rt_kprintf("s%d %s × ", srt, sensor[srt].eName);
                sensor[srt].online = 0;
                res = 0;
            }
        }
        rt_thread_mdelay(1000); // 每个要素结束的间隔
        memset(Read_data, 0, sizeof(Read_data));
    }

    rt_kprintf("\n");
    return res;
}

void RS485_SEND(uint8_t *buf, uint16_t size)
{
    HAL_UART_Transmit(&huart5, buf, size, 1000);
}

/* UART5 init function */
void MX_UART5_Init(void)
{
    /**UART5 GPIO Configuration
    PC12     ------> UART5_TX
    PD2     ------> UART5_RX
    */
    /* USER CODE BEGIN UART5_Init 0 */
    __HAL_RCC_GPIOC_CLK_ENABLE();
    __HAL_RCC_GPIOD_CLK_ENABLE();
    /* USER CODE END UART5_Init 0 */

    /* USER CODE BEGIN UART5_Init 1 */

    /* USER CODE END UART5_Init 1 */
    huart5.Instance = UART5;
    huart5.Init.BaudRate = 9600;
    huart5.Init.WordLength = UART_WORDLENGTH_8B;
    huart5.Init.StopBits = UART_STOPBITS_1;
    huart5.Init.Parity = UART_PARITY_NONE;
    huart5.Init.Mode = UART_MODE_TX_RX;
    huart5.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    huart5.Init.OverSampling = UART_OVERSAMPLING_16;

    if (HAL_UART_Init(&huart5) != HAL_OK)
    {
        rt_kprintf("HAL_UART_Init(&huart5) failed\n");
        Error_Handler();
    }
    /* USER CODE BEGIN UART5_Init 2 */
    //rt_kprintf("MX_UART5_Init\n");
    /* USER CODE END UART5_Init 2 */
}

void HAL_UART_MspInit(UART_HandleTypeDef *uartHandle)
{

    GPIO_InitTypeDef GPIO_InitStruct = {0};
    if (uartHandle->Instance == UART5)
    {
        /* USER CODE BEGIN UART5_MspInit 0 */

        /* USER CODE END UART5_MspInit 0 */
        /* UART5 clock enable */
        __HAL_RCC_UART5_CLK_ENABLE();

        __HAL_RCC_GPIOC_CLK_ENABLE();
        __HAL_RCC_GPIOD_CLK_ENABLE();
        /**UART5 GPIO Configuration
        PC12     ------> UART5_TX
        PD2     ------> UART5_RX
        */
        GPIO_InitStruct.Pin = GPIO_PIN_12;
        GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
        GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
        HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);

        GPIO_InitStruct.Pin = GPIO_PIN_2;
        GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
        GPIO_InitStruct.Pull = GPIO_NOPULL;
        HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);

        /* UART5 interrupt Init */

        HAL_NVIC_SetPriority(UART5_IRQn, 0, 0);
        HAL_NVIC_EnableIRQ(UART5_IRQn);
        __HAL_UART_ENABLE_IT(&huart5, UART_IT_IDLE);
        __HAL_UART_ENABLE(&huart5);
        HAL_UART_Receive_IT(&huart5, &aRxBuffer[3], 1);
        /* USER CODE END UART5_MspInit 1 */
        //rt_kprintf("HAL_UART_MspInit\n");
    }
}

void HAL_UART_MspDeInit(UART_HandleTypeDef *uartHandle)
{

    if (uartHandle->Instance == UART5)
    {
        /* USER CODE BEGIN UART5_MspDeInit 0 */

        /* USER CODE END UART5_MspDeInit 0 */
        /* Peripheral clock disable */
        __HAL_RCC_UART5_CLK_DISABLE();

        /**UART5 GPIO Configuration
        PC12     ------> UART5_TX
        PD2     ------> UART5_RX
        */
        HAL_GPIO_DeInit(GPIOC, GPIO_PIN_12);

        HAL_GPIO_DeInit(GPIOD, GPIO_PIN_2);

        /* UART5 interrupt Deinit */
        HAL_NVIC_DisableIRQ(UART5_IRQn);
        /* USER CODE BEGIN UART5_MspDeInit 1 */

        /* USER CODE END UART5_MspDeInit 1 */
    }
}

/**
 * @brief This function handles UART5 global interrupt.
 */
void UART5_IRQHandler(void)
{
    if ((__HAL_UART_GET_FLAG(&huart5, UART_FLAG_ORE) != RESET))
    {
        __HAL_UART_CLEAR_OREFLAG(&huart5); // 清除标志位
        HAL_UART_Receive_IT(&huart5, &aRxBuffer[3], 1);
    }
    __HAL_UART_DISABLE_IT(&huart5, UART_IT_IDLE);
    if ((__HAL_UART_GET_FLAG(&huart5, UART_FLAG_IDLE) != RESET)) // idle标志被置位
    {
        rs_buf_fis = 1;                     // 接收1帧
        __HAL_UART_CLEAR_IDLEFLAG(&huart5); // 清除标志位
    }
    __HAL_UART_ENABLE_IT(&huart5, UART_IT_IDLE);
    HAL_UART_IRQHandler(&huart5);
}

/**
 * @brief Get the sensor num object
 *
 * @param cmd
 * @return Sensor_Read_Type
 */
Sensor_Read_Type get_sensor_num(char *cmd)
{

    if (strstr(cmd, stemp) != NULL)
    {
        return s_Temp;
    }
    if (strstr(cmd, humi) != NULL)
    {
        return s_Humi;
    }
    if (strstr(cmd, airpre) != NULL)
    {
        return s_Airpre;
    }
    if (strstr(cmd, lux) != NULL)
    {
        return s_Lux;
    }
    if (strstr(cmd, rain) != NULL)
    {
        return s_Rain;
    }

    return s_ALL;
}

/**
 * @brief 读取传感器参数
 *
 */
void sensor_setdef(void)
{
    uint8_t mark_up = 0;

    while (ef_cfged != 1)
    {
        rt_thread_mdelay(1000);
    }

    ef_get_env_blob("sensor", &sensor, sizeof(sensor), NULL);

    if (sensor[s_Temp].cfged != 1)
    {
        sensor[s_Temp].cfged = 1;
        sensor[s_Temp].sensor_addr = 1;
        sensor[s_Temp].start_reg = 2;
        sensor[s_Temp].count = 1;
        sensor[s_Temp].d_length = 1;
        sensor[s_Temp].d_pos = 0;
        sprintf(sensor[s_Temp].eName, stemp);
        sensor[s_Temp].factor = -10;
        mark_up = 1;
        LOG_W("s_Temp set def");
    }
    if (sensor[s_Humi].cfged != 1)
    {
        sensor[s_Humi].cfged = 1;
        sensor[s_Humi].sensor_addr = 1;
        sensor[s_Humi].start_reg = 3;
        sensor[s_Humi].count = 1;
        sensor[s_Humi].d_length = 1;
        sensor[s_Humi].d_pos = 0;
        sprintf(sensor[s_Humi].eName, humi);
        sensor[s_Humi].factor = -10;
        mark_up = 1;
        LOG_W("s_Humi set def");
    }
    if (sensor[s_Airpre].cfged != 1)
    {
        sensor[s_Airpre].cfged = 1;
        sensor[s_Airpre].sensor_addr = 1;
        sensor[s_Airpre].start_reg = 4;
        sensor[s_Airpre].count = 1;
        sensor[s_Airpre].d_length = 1;
        sensor[s_Airpre].d_pos = 0;
        sprintf(sensor[s_Airpre].eName, airpre);
        sensor[s_Airpre].factor = -10;
        mark_up = 1;
        LOG_W("s_Airpre set def");
    }
    if (sensor[s_Lux].cfged != 1)
    {
        sensor[s_Lux].cfged = 1;
        sensor[s_Lux].sensor_addr = 1;
        sensor[s_Lux].start_reg = 5;
        sensor[s_Lux].count = 1;
        sensor[s_Lux].d_length = 1;
        sensor[s_Lux].d_pos = 0;
        sprintf(sensor[s_Lux].eName, lux);
        sensor[s_Lux].factor = 10;
        mark_up = 1;
        LOG_W("s_Lux set def");
    }
    //    if (sensor[s_Rain].cfged != 1)
    //    {
    //        sensor[s_Rain].cfged = 1;
    //        sensor[s_Rain].sensor_addr = 1;
    //        sensor[s_Rain].start_reg = 6;
    //        sensor[s_Rain].count = 1;
    //        sensor[s_Rain].d_length = 1;
    //        sensor[s_Rain].d_pos = 0;
    //        sprintf(sensor[s_Rain].eName, rain);
    //        sensor[s_Rain].factor = -10;
    //        mark_up = 1;
    //        LOG_W("s_Rain set def");
    //    }

    if (mark_up == 1)
    {
        LOG_W("sensor SET %d", ef_set_env_blob("sensor", &sensor, sizeof(sensor)));
    }

    ef_get_env_blob("collecting_sh1", &device_status.collecting_sh1, sizeof(device_status.collecting_sh1), NULL);
    ef_get_env_blob("collecting_eh1", &device_status.collecting_eh1, sizeof(device_status.collecting_eh1), NULL);

    if (ef_get_env_blob("limit", &limit, sizeof(Limit), NULL) == 0)
    {
        limit.temp_up = tempup_def;
        limit.temp_dw = tempdw_def;
        limit.LuxEN = OFF;  // 250616 修改为默认时控
        limit.LuxTime = gktime_def;
        limit.temhumEN == ON;   // 250616 修改默认温控为开
        LOG_W("limit SET %d", ef_set_env_blob("limit", &limit, sizeof(Limit)));
    }
    else
    {
        if (limit.temhumEN == ON)
        {
            LOG_W("温控已开启：%d ~ %d \n", limit.temp_dw, limit.temp_up);
        }
        if (limit.RainEN == ON)
        {
            LOG_W("雨控已开启\n");
        }
        if (limit.LuxEN == ON)
        {
            if (limit.LuxTime == 0)
            {
                limit.LuxTime = gktime_def;
                LOG_W("limit SET %d", ef_set_env_blob("limit", &limit, sizeof(Limit)));
            }
        }
    }

    /**
     * @brief 准备工作
     *
     */
    if (swork.Read != 1) // swork默认
    {
        if (ef_get_env_blob((const char *)"swork", (void *)&swork, sizeof(swork), NULL) == 0)
        {
            swork.Read = 1;
            swork.EN = OFF;
            swork.slux_set = Luxlimit_def;
            ef_set_env_blob((const char *)"swork", (void *)&swork, sizeof(swork));
            rt_kprintf("swork SET Def\n");
        }
    }
    if (swork.slux_set == 0)
    {
        swork.slux_set = Luxlimit_def;
        ef_set_env_blob((const char *)"swork", (void *)&swork, sizeof(swork));
    }
    if (swork.lseek == 0)
    {
        swork.lseek = 20;
        ef_set_env_blob((const char *)"swork", (void *)&swork, sizeof(swork));
    }
    if (swork.sunup_time.Hours == 0 || swork.sundown_time.Hours == 0)
    {
        swork.sunup_time.Hours = 7;
        swork.sunup_time.Minutes = 30;
        swork.sundown_time.Hours = 17;
        swork.sundown_time.Minutes = 20;

        ef_set_env_blob((const char *)"swork", (void *)&swork, sizeof(swork));
    }

    // 测试用 用来测试时间
//    swork.sunup_time.Hours = 7;
//    swork.sunup_time.Minutes = 30;
//    swork.sundown_time.Hours = 11;
//    swork.sundown_time.Minutes = 20;

    // 计算工作开始时间
    swork.start_time.Hours = (swork.sundown_time.Hours * 60 + swork.sundown_time.Minutes - swork.lseek) / 60;
    swork.start_time.Minutes = (swork.sundown_time.Hours * 60 + swork.sundown_time.Minutes - swork.lseek) % 60;
    swork.start_time.Seconds = swork.sundown_time.Seconds;

    // 计算工作结束时间
    swork.end_time.Hours = (swork.sunup_time.Hours * 60 + swork.sunup_time.Minutes + swork.lseek) / 60;
    swork.end_time.Minutes = (swork.sunup_time.Hours * 60 + swork.sunup_time.Minutes + swork.lseek) % 60;
    swork.end_time.Seconds = swork.sunup_time.Seconds;

    uint8_t save_syscfg = 0;
    if(ef_get_env_blob("syscfg", &syscfg, sizeof(syscfg), NULL) == 0)
    {
        syscfg.fan_speed = 50;
        save_syscfg = 1;
    }
    else
    {
        if(syscfg.fan_speed < 10 || syscfg.fan_speed > 100)
        {
            syscfg.fan_speed = 50;      // 默认值
            save_syscfg = 1;
        }
        CollFanSetPWM(syscfg.fan_speed);
    }

    if(syscfg.Demo_mode != 0 && syscfg.Demo_mode != 1)
    {
        syscfg.Demo_mode = 0;
        save_syscfg = 1;
    }

    if(save_syscfg)
    {
        ef_set_env_blob("syscfg", &syscfg, sizeof(syscfg));
    }
}


// void delswork(void)
//{
//
//     ef_del_env("swork");
//
// }

// MSH_CMD_EXPORT(delswork , delswork);

/**
 * @brief 线程
 *
 * @param param
 */
static void rs485_thread_entry(void *param)
{
    uint16_t timeout = 10 * 60, cnt = 0, update_wait = 0;

    rt_thread_mdelay(6000);
    MX_UART5_Init();
    rt_thread_mdelay(6000);

    while (ef_cfged == 0)
    {
        rt_thread_mdelay(1000);
        if (update_wait++ > 180)
        {
            break;
        }
    }

    rt_kprintf("rs485_thread_entry\n");

    sensor_setdef();

    HMI_WRITE("result.txt=\"要素采集已开始\"");

    static uint8_t luxreadcnt = 0;

    while (1)
    {
        while (sex_enread)
        {
            // rt_kprintf("sex_enread \n");
            rt_thread_mdelay(1000);
            if (cnt++ >= timeout)
            {
                cnt = 0;
                sex_enread = 0;
                rt_kprintf("sex_enread timeout\n");
                HMI_WRITE("ReadSenor.result.txt=\"测试时长超时 已退出\"");
                break;
            }
        }
        READ_MODBUS_DATA_1(s_ALL);

        if (++luxreadcnt >= 5 && swork.EN == ON)
        {
            luxreadcnt = 0;
            Get_SunTime();
        }
        rt_thread_mdelay(6000);
    }
}

int rs485_thread(void)
{
    rt_thread_t tid1 = RT_NULL;
    tid1 = rt_thread_create("rs485_thread",
                            rs485_thread_entry, RT_NULL,
                            1024 + 256,
                            10, 5);

    /* 如果获得线程控制块，启动这个线程 */
    if (tid1 != RT_NULL)
    {
        rt_thread_startup(tid1);
    }
    else
        LOG_E("rs485_thread start fail\n");

    return 0;
}

INIT_APP_EXPORT(rs485_thread); // 监听命令及响应

void dis_elem(void)
{
    for (uint8_t a = 0; a < MAX_SENSOR_NUM; a++)
    {
        if (sensor[a].cfged == 1)
        {
            rt_kprintf("s%6s  s-%d reg-%d val-%d/%s on-%d\n",
                       sensor[a].eName,
                       sensor[a].sensor_addr,
                       sensor[a].start_reg,
                       sensor[a].value,
                       sensor[a].eValue,
                       sensor[a].online);
        }
    }
    rt_kprintf("\n\n");
}

MSH_CMD_EXPORT(dis_elem, dis_elem);

void dislimlt(void)
{
    rt_kprintf("tup %d tdw %d hup %d hdw %d  temp%d lux%d rain%d \n\n",
               limit.temp_up,
               limit.temp_dw,
               limit.humi_up,
               limit.humi_dw,
               limit.temhumEN,
               limit.LuxEN,
               limit.RainEN);
}

MSH_CMD_EXPORT(dislimlt, dislimlt);