QXZ_QXZ/qxz_app/applications/dotled_y.c

#define LOG_TAG "dotled"    // 该模块对应的标签。不定义时，默认：NO_TAG
#define LOG_LVL LOG_LVL_DBG // LOG_LVL_DBG   // 该模块对应的日志输出级别。不

#include <ulog.h> // 必须在 LOG_TAG 与 LOG_LVL 下面

#include "dotled.h"
#include <easyflash.h>

#include "sys_config.h"

extern uint32_t month;
extern uint32_t day;
extern uint32_t year;
extern uint32_t hour;
extern uint32_t min;
extern uint32_t sec;
extern uint8_t week;

extern led_t *SENSORLED;
extern led_t *COMMLED;
extern led_t *DOTLED;

extern char *Display_Data_wind_direction360(uint16_t direction);

#define RS485_DOTLED_EN GET_PIN(D, 1)
#define DOTLED_UART_NAME "uart3" /* 串口设备名称 */

/* 串口设备句柄 */
static rt_device_t dotled;

#define timed_events_TITLE (1 << 0) //标题刷新计时
#define timed_events_MAIN (1 << 1)  //内容刷新计时
#define timed_events_RTC (1 << 2)   //时间显示刷新计时 

/* 定时事件控制块 */
static struct rt_event timed_events;
/* 定时器的控制块 */
static rt_timer_t dotled_timed_task;

#define dis_buff_len 40 * qxz.Param.Num_sensors

/*1米*0.5米屏幕点阵为 96*48  */
/*1米*  1米屏幕点阵为 96*96  */
/*2米*  1米屏幕点阵为192*96  */

static char dotledtitle[60];       // LED显示屏抬头，最大显示30个汉字
static char dotledtitle_down[60];  // LED显示屏下发抬头内容，最大显示30个汉字
static uint32_t title_timeout = 0; // 下发后抬头显示超时失效时间。

static uint16_t main_keeptime = 16; //主显示区单页面显示时长，0.5s步进
/*屏幕显示行数 1 * 0.5米为96*48点阵，显示3行
*屏幕显示行数  1 * 1米为96*96点阵，	 显示6行
*屏幕显示行数  2 * 1米为192*96点阵， 显示5行
*/
static uint16_t screen_line = 12;

//点阵屏尺寸规格区分标志位
//static uint8_t dotled_size = 0;SoilTemperature

static char *green = "\\C2";
static char *red = "\\C2";
// static char *red = "";
//char *font = "\\F0021"; //字体

/*发送显示数据使用缓存指针*/
static uint8_t *Dis_Comm = RT_NULL;
//static uint8_t *dis_buff = RT_NULL;

//转义字符，输入：待转义字符指针，长度
extern uint16_t Escape_character(uint8_t *buff, uint16_t len);
extern void Time2BCD(char *bcd_buf);

static uint8_t frame[8] = {0xA5, 0xA5, 0xA5, 0xA5, 0xA5, 0xA5, 0xA5, 0xA5};                           //包头
static uint8_t header[12] = {0x01, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x02}; //帧头，5K1,5K2屏幕区分

//十进制转ASCII码
#define KB2ASC(x) (u8)(0x30 + x)

//ASCII码转十进制
#define ASC2KB(x) (u8)(x % (0x30))

#define PLOY 0xa001 //0x8005 反转
//static uint8_t crc16(uint8_t *data, uint8_t size);

//获取字符串长度
extern uint8_t sizeof_s(char *str);

//把str1的内容copy到str2
//*str1:字符串1指针
//*str2:字符串2指针
extern void strcopy(char *str1, char *str2);

/* 定时器超时函数 */
static void dotled_timed(void *parameter)
{
    static rt_uint32_t cnt = 0;
    cnt++;
    rt_uint8_t temp;

    if (cnt % ((rt_uint32_t)parameter * main_keeptime * ((qxz.Param.Num_sensors / screen_line) + 3)) == 0)
    {
        rt_event_send(&timed_events, timed_events_TITLE); //定时时间到，发送事件
    }
    if (qxz.Param.Num_sensors % screen_line != 0)
    {
        temp = qxz.Param.Num_sensors / screen_line + 1;
    }
    else
        temp = qxz.Param.Num_sensors / screen_line;

    if (cnt % ((rt_uint32_t)parameter * (uint16_t)(main_keeptime / 2) * temp) == 0) //
    {
        rt_event_send(&timed_events, timed_events_MAIN); //定时时间到，发送事件
    }

    if (cnt % 3600 == 0) //1小时刷新1次
    {
        rt_event_send(&timed_events, timed_events_RTC); //定时时间到，发送事件
    }
}

//参数结构变量赋初值
static bx_5k_area_header bx_5k = {
    .Frame = frame,   //帧头 8 bytes (A5)
    .Header = header, //包头 12 bytes (01 00 00 80 00 00 00 00 00 00 FE 02)

    .Len = {0, 0}, //整个发送数据除去帧头，包头，CRC校验后的长度 2 bytes

    .Cmd_dis = {0xa3, 0x06},   //发送实时显示信息命令 A3 06
    .Reply_f = 0x01,           //控制器回复标志 01
    .Reserved0 = {0x00, 0x00}, //2D 00→保留字节（此值未使用）
    .Areadealnum = 0,          //00→要删除的区域个数
    .AreaNum = 0x01,           //区域个数，默认为 0x01,1 bytes

    .AreaLen = {0, 0}, //动态区域0数据长度，2 bytes

    .AreaType = 0x00, //设置区域类型，默认为 0x00 1 bytes

    .AreaX = {0x00, 0}, //设置 X 坐标 2 bytes
    .AreaY = {0x00, 0}, //设置 Y 坐标 2 bytes

    .AreaWidth = {0x80, 0},  //设置屏宽度  2 bytes
    .AreaHeight = {0x34, 0}, //设置屏高度  2 bytes

    .DynamicAreaLoc = 1, //设置动态区编号 1 bytes

    .Lines_sizes = 0, //行间距

    .RunMode = 0, //动态区数据循环模式  1 bytes

    .Timeout = {0x05, 0x00}, //设置超时时间 2 bytes

    .Reserved1 = {0, 0, 0}, //保留 3 bytes

    .SingleLine = 0x02, //设置是否单行显示 1 bytes

    .NewLine = 0x02,     //设置是否自动换行 1 bytes
    .DisplayMode = 0x02, //设置显示方式 1 bytes 01静止显示
    .ExitMode = 0x00,    //设置退出方式	1 bytes
    .Speed = 0x02,       //设置运行速度 1 bytes
    .StayTime = 0x05,    //设置停留时间 1 bytes

    .DataLen = {0, 0, 0, 0}, //要显示内容的个数  4 bytes

    .dis_buff = 0, //显示内容

    .crc_data = {0, 0}, //CRC
};

// /*刷新风向传感器数据*/
// char *Display_Data_wind_direction360(uint16_t direction)
// {
//     uint8_t temp;
// #ifdef saitong_sensor
//     temp = (uint8_t)(direction / 10 / 22.5);
// #else
//     temp = (uint8_t)(direction / 22.5);
// #endif
//     static char direction_op[10];

//     switch (temp)
//     {
//     case 0:
//         rt_memset(direction_op, '\0', 10);
//         sprintf(direction_op, "%s", "北风  ");
//         break;
//     case 1:
//         rt_memset(direction_op, '\0', 10);
//         sprintf(direction_op, "%s", "东北风");
//         break;
//     case 2:
//         rt_memset(direction_op, '\0', 10);
//         sprintf(direction_op, "%s", "东北风");
//         break;
//     case 3:
//         rt_memset(direction_op, '\0', 10);
//         sprintf(direction_op, "%s", "东风  ");
//         break;
//     case 4:
//         rt_memset(direction_op, '\0', 10);
//         sprintf(direction_op, "%s", "东风  ");
//         break;
//     case 5:
//         rt_memset(direction_op, '\0', 10);
//         sprintf(direction_op, "%s", "东南风");
//         break;
//     case 6:
//         rt_memset(direction_op, '\0', 10);
//         sprintf(direction_op, "%s", "东南风");
//         break;
//     case 7:
//         rt_memset(direction_op, '\0', 10);
//         sprintf(direction_op, "%s", "南风  ");
//         break;
//     case 8:
//         rt_memset(direction_op, '\0', 10);
//         sprintf(direction_op, "%s", "南风  ");
//         break;
//     case 9:
//         rt_memset(direction_op, '\0', 10);
//         sprintf(direction_op, "%s", "西南风");
//         break;
//     case 10:
//         rt_memset(direction_op, '\0', 10);
//         sprintf(direction_op, "%s", "西南风");
//         break;
//     case 11:
//         rt_memset(direction_op, '\0', 10);
//         sprintf(direction_op, "%s", "西风  ");
//         break;
//     case 12:
//         rt_memset(direction_op, '\0', 10);
//         sprintf(direction_op, "%s", "西风  ");
//         break;
//     case 13:
//         rt_memset(direction_op, '\0', 10);
//         sprintf(direction_op, "%s", "西北风");
//         break;
//     case 14:
//         rt_memset(direction_op, '\0', 10);
//         sprintf(direction_op, "%s", "西北风");
//         break;
//     case 15:
//         rt_memset(direction_op, '\0', 10);
//         sprintf(direction_op, "%s", "北风  ");
//         break;
//     default:
//         break;
//     }
//     return direction_op;
// }

// //区域1显示数据格式化,返回长度
// uint16_t Area1_dis_format(uint8_t *buff)
// {
//     uint16_t i = 0;
//     char sensor_value[50] = {0};
//     uint16_t total = 0; /* 记录当前数据长度 */
//     char sensor_nop[4] = {0};

//     //加上字体大小
//     total = rt_sprintf((char *)buff, "%s", font);

//     for (i = 0; i < qxz.Param.Num_sensors; i++)
//     {
//         rt_memset(sensor_value, 0, 50);         //判断是否传感器未接或故障，如果是则显示为空
//         if (strcmp(sensor[i].eName, "\0") != 0) /*传感器eName不能为空*/
//         {
//             if (strstr(sensor[i].eValue, "-99.99") == NULL)
//             {
//                 if (strcmp(sensor[i].eName, "WindDirection") == 0)
//                     strcpy(sensor_value, Display_Data_wind_direction360(sensor[i].value)); //如果是风向则角度转为汉字
//                 else if (strcmp(sensor[i].eName, "RainSnow") == 0)
//                 {
//                     if (sensor[i].value == 0)
//                         strcpy(sensor_value, "  无  ");
//                     else if (sensor[i].value == 1)
//                         strcpy(sensor_value, "  有  ");
//                 }
//                 else
//                     strcpy(sensor_value, sensor[i].eValue);
//             }

//                 total += rt_sprintf((char *)(buff + total), sensor[i].dotled_s, green , green , sensor_value);
//         }
//     }
//     return total; /* 返回前数据长度 */
// }

/*区域1显示数据格式化,返回长度*/
/*pos 需要截断显示的要素位置，DynamicArea 显示动态区域编号*/

// Control_card != 5 &&		//Y1A 单区域（1Bit）
// Control_card != 6 &&		//Y1A 单区域（8Bit）
// Control_card != 7 &&		//Y1A 双区域（1Bit）
// Control_card != 8)       //Y1A 双区域（8Bit）

uint16_t Area1_dis_format_area(uint8_t *buff, uint8_t pos, uint8_t DynamicArea)
{
    uint16_t i = 0;
    char sensor_value[50] = {0};
    uint16_t total = 0; /* 记录当前数据长度 */
//    char sensor_nop[4] = {0};

    uint8_t ForTime_D0 = 0, ForTime_D1 = 0, ForStart_D0 = 0, ForStart_D1 = 0;

    if (qxz.Param.Dotled_Option == 5 || qxz.Param.Dotled_Option == 6)
    {
        ForTime_D0 = qxz.Param.Num_sensors;
        ForStart_D0 = 0;
    }
    else if (qxz.Param.Dotled_Option == 7 || qxz.Param.Dotled_Option == 8)
    {
        ForStart_D0 = 0;
        ForTime_D0 = qxz.Param.Num_sensors / 2;

        ForStart_D1 = qxz.Param.Num_sensors / 2;
        ForTime_D1 = qxz.Param.Num_sensors;
    }

    //加上字体大小
    total = rt_sprintf((char *)buff, "\\F00%02d", qxz.Param.dotled_p0.front);

    if (DynamicArea == 0)
    {
        //        rt_kprintf("MARK 0 \n\n");
        for (i = ForStart_D0; i < ForTime_D0; i++)
        {
            rt_memset(sensor_value, 0, 50);         //判断是否传感器未接或故障，如果是则显示为空
                                                    //           rt_kprintf("MARK 1 \n");
            if (strcmp(sensor[i].eName, "\0") != 0) /*传感器eName不能为空*/
            {
                //                rt_kprintf("MARK 2 \n");
                if (strstr(sensor[i].eValue, "-99.99") == NULL && sensor[i].online_flag == 1)
                {
                    //                   rt_kprintf("MARK 3 \n");
                    //if (strstr(sensor[i].eName, "WindDirection") != RT_NULL)//xz 2.7.5改strcmp(==0)-> strstr(!=RT_NULL)
                    if ((strstr(sensor[i].eName, "WindDirection") != RT_NULL) || (strstr(sensor[i].eName, "360TO_") != RT_NULL))
                        strcpy(sensor_value, Display_Data_wind_direction360(sensor[i].value)); //如果是风向则角度转为汉字
                    else if (strcmp(sensor[i].eName, "RainSnow") == 0)
                    {
                        if (sensor[i].value == 0)
                            strcpy(sensor_value, "  无  ");
                        else if (sensor[i].value == 1)
                            strcpy(sensor_value, "  有  ");
                    }
                    else
                        strcpy(sensor_value, sensor[i].eValue);
                }
                else
                {
                    //                    rt_kprintf("MARK 4 \n");
                    rt_sprintf(sensor_value, "-99.99");
                }
                total += rt_sprintf((char *)(buff + total), sensor[i].dotled_s, green, red, sensor_value);
                //rt_kprintf("%s eval >%s \n",sensor[i].eName , sensor_value);
            }
        }
    }
    else if (DynamicArea == 1)
    {
        for (i = ForStart_D1; i < ForTime_D1; i++)
        {
            rt_memset(sensor_value, 0, 50);         //判断是否传感器未接或故障，如果是则显示为空
            if (strcmp(sensor[i].eName, "\0") != 0) /*传感器eName不能为空*/
            {
                if (strstr(sensor[i].eValue, "-99.99") == NULL)
                {
                    //if (strstr(sensor[i].eName, "WindDirection") != RT_NULL)//xz 2.7.5改strcmp(==0)-> strstr(!=RT_NULL)
                    if ((strstr(sensor[i].eName, "WindDirection") != RT_NULL) || (strstr(sensor[i].eName, "360TO_") != RT_NULL))
                        strcpy(sensor_value, Display_Data_wind_direction360(sensor[i].value)); //如果是风向则角度转为汉字
                    else if (strcmp(sensor[i].eName, "RainSnow") == 0)
                    {
                        if (sensor[i].value == 0)
                            strcpy(sensor_value, "  无  ");
                        else if (sensor[i].value == 1)
                            strcpy(sensor_value, "  有  ");
                    }
                    else
                        strcpy(sensor_value, sensor[i].eValue);
                }
                total += rt_sprintf((char *)(buff + total), sensor[i].dotled_s, green, sensor_value, red);
            }
        }
    }
    return total; /* 返回前数据长度 */
}

//计算控制卡型号：
// void controller_type(uint8_t type)
// {
//     switch (type)
//     {
//     case 1:
//         header[10] = 0x51;
//         break;
//     case 2:
//         header[10] = 0x52;
//         break;
//     case 3:
//         header[10] = 0x53;
//         break;
//     default:
//         break;
//     }
// }

static SYSTEMTIMESET TimeSet = {
    .Frame = frame,   //帧头 8 bytes (A5)
    .Header = header, //包头 12 bytes (01 00 00 80 00 00 00 00 00 00 FE 02)

    .Len = {0, 0}, //整个发送数据除去帧头，包头，CRC校验后的长度 2 bytes
    .Cmd_Group = 0xA2,
    .Cmd = 0x03,
    .Response = 0x02,
    //	.Reserved   = {0,0},
    .DataLen = {0, 0},
    .System_time = 0,
    .crc_data = {0, 0}, //CRC
};

//控制卡校准时间
void DotLED_TIMESET_y(uint8_t set)
{
    uint16_t add_len = 0; //整个数据总长度
    uint16_t total = 0;   /* 记录当前数据长度 */
    uint16_t crc_data = 0;
//    uint16_t i, j, t = 0;
    uint16_t t = 0;
    static uint8_t SETIME_RUN1TIME = 1; /*清除功能1次标志*/
    if ((hour == 1) || (set == 1))      //每天1点对时或强制对时
    {
        if (SETIME_RUN1TIME == 1)
        {
            rt_memset(Dis_Comm, '\0', dis_buff_len + 300);

            Time2BCD((char *)TimeSet.System_time);

            total = 8;

            TimeSet.Len[0] = (char)((total + 5) & 0xff); /*计算动态区域0数据长度*/
            TimeSet.Len[1] = (char)((total + 5) >> 8);

            TimeSet.DataLen[0] = (char)(total & 0xff); /**/
            TimeSet.DataLen[1] = (char)(total >> 8);

            rt_memcpy(Dis_Comm + add_len, TimeSet.Header, 12);
            add_len = 12;
            rt_memcpy(Dis_Comm + add_len, TimeSet.Len, 2);
            add_len += 2;

            rt_memcpy(Dis_Comm + add_len, &TimeSet.Cmd_Group, 1);
            add_len += 1;
            rt_memcpy(Dis_Comm + add_len, &TimeSet.Cmd, 1);
            add_len += 1;
            rt_memcpy(Dis_Comm + add_len, &TimeSet.Response, 1);
            add_len += 1;
            //	rt_memcpy(Dis_Comm + add_len , TimeSet.Reserved,  2);add_len += 2;
            rt_memcpy(Dis_Comm + add_len, TimeSet.DataLen, 2);
            add_len += 2;
            rt_memcpy(Dis_Comm + add_len, TimeSet.System_time, total);
            add_len += total;

            t = (TimeSet.Len[1] << 8) + TimeSet.Len[0];
            t = t + 14;                        //加Data_Field_1+数据长度2
            crc_data = CRC16_IBM(Dis_Comm, t); /*先计算出CRC值再来查询转义字符*/
            Dis_Comm[t] = crc_data >> 8;
            t = t + 1;
            Dis_Comm[t] = crc_data;
            t = t + 1;
            t = Escape_character(Dis_Comm, t); //字符转义处理

            Dis_Comm[t] = 0x5a;

            rt_pin_write(RS485_DOTLED_EN, PIN_HIGH);

            rt_device_write(dotled, 0, TimeSet.Frame, 8);
            rt_device_write(dotled, 0, (Dis_Comm), t + 1);

            char *led_blink_mode_1 = "50,50,"; //10Hz闪烁
            led_set_mode(DOTLED, 5, led_blink_mode_1);

            rt_pin_write(RS485_DOTLED_EN, PIN_LOW); /*485输入使能*/

            SETIME_RUN1TIME = 0; /*只运行一次*/
        }
    }
    else
        SETIME_RUN1TIME = 1; /*其他时间运行1次标志复位*/
}

//char time_test[] = "\\DL月\\DD日\\C3\\DH时\\DM分";//\\DS秒";
static char time_YM[] = "\\C3      20\\DY年\\DL月"; //"\\C3\\DY 年\\DL月\\DD日\\C3\\DH时\\DM分\\DS秒
static char time_DHM[] = "\\C3\\DD日\\C3\\DH时\\DM分";
static char time_YMDHM[] = " 20\\DY年\\DL月\\DD日  \\C3    \\DH时\\DM分";
//抬头：区域0显示函数，显示抬头
void DotLED_DisplayTime_y(uint8_t x, uint8_t y, uint8_t Width, uint8_t Height, uint8_t TURNON_RUN)
{

    uint16_t add_len = 0; //整个数据总长度
    uint16_t total = 0;   /* 记录当前数据长度 */
    rt_uint32_t e;
    uint16_t crc_data = 0;
    //    uint16_t i, j, t = 0;
        uint16_t t = 0;
    if ((rt_event_recv(&timed_events, timed_events_RTC,
                       RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR,
                       0, &e) == RT_EOK) ||
        (TURNON_RUN == 1)) //定时时间到或者开机运行1次
    {
        rt_thread_mdelay(1000);
        rt_memset(Dis_Comm, '\0', dis_buff_len + 300);
        rt_memset(bx_5k.dis_buff, '\0', dis_buff_len);

        bx_5k.AreaX[0] = (char)(x & 0xff);
        bx_5k.AreaX[1] = (char)((x >> 8) | 0x80); //最高位置一，以像素点为单位
                                                  //		bx_5k.AreaX[1] = (char)( x >> 8);

        bx_5k.AreaY[0] = (char)(y & 0xff);
        bx_5k.AreaY[1] = (char)(y >> 8);

        bx_5k.AreaWidth[0] = (char)(Width & 0xff);
        bx_5k.AreaWidth[1] = (char)((Width >> 8) | 0x80); //最高位置一，以像素点为单位
                                                          //		bx_5k.AreaWidth[1] 	= (char)( Width >> 8);

        bx_5k.AreaHeight[0] = (char)(Height & 0xff);
        bx_5k.AreaHeight[1] = (char)(Height >> 8);

        bx_5k.DynamicAreaLoc = 0x00; //设置动态区域为0
        bx_5k.Lines_sizes = 0;       //行间距
        bx_5k.RunMode = 0x00;        //动态区域运行模式，动态区数据循环显示*/
        bx_5k.Timeout[0] = 0x03;     //
        bx_5k.Timeout[1] = 0x00;     //超时时间
        bx_5k.SingleLine = 0x02;     //设置是否单行显示 ：01单行显示02多行显示
        bx_5k.NewLine = 0x01;        //设置是否自动换行：01不自动换行 02自动换行

        /*正常显示抬头效果配置*/
        bx_5k.DisplayMode = 0x02;         //设置显示方式：02快速打出/03向左移动
        bx_5k.ExitMode = 0x00;            //设置退出方式
        bx_5k.Speed = 0x02;               //设置运行速度
        bx_5k.StayTime = 0x05;            //设置停留时间 0x01为0.5s
        if (qxz.Param.Dotled_Option != 1) //5k1显示整个内容
        {
            if (qxz.Param.application_model == 0)                                 //当前应用模式：环境气象站
                total += sprintf((char *)bx_5k.dis_buff + total, "%s", time_YM);  //显示抬头\\C3\\DH时\\DM分\\DS秒
            else if (qxz.Param.application_model == 1)                            //当前应用模式：墒情监测站
                total += sprintf((char *)bx_5k.dis_buff + total, "%s", time_DHM); //显示抬头\\C3\\DH时\\DM分\\DS秒
        }
        else
            total += sprintf((char *)bx_5k.dis_buff + total, "%s", time_YMDHM); //显示抬头\\C3\\DH时\\DM分\\DS秒
        bx_5k.Len[0] = (char)((total + 9 + 27) & 0xff);                         /*计算动态区域0数据长度*/
        bx_5k.Len[1] = (char)((total + 9 + 27) >> 8);
        bx_5k.AreaLen[0] = (char)((total + 27) & 0xff); /*计算动态区域0数据长度*/
        bx_5k.AreaLen[1] = (char)((total + 27) >> 8);

        bx_5k.DataLen[0] = (char)(total & 0xff); /*实际显示内容长度,实际占32位，只实现了16位*/
        bx_5k.DataLen[1] = (char)(total >> 8);

        rt_memcpy(Dis_Comm + add_len, bx_5k.Header, 12);
        add_len = 12;
        rt_memcpy(Dis_Comm + add_len, bx_5k.Len, 2);
        add_len += 2;
        rt_memcpy(Dis_Comm + add_len, bx_5k.Cmd_dis, 2);
        add_len += 2;
        rt_memcpy(Dis_Comm + add_len, &bx_5k.Reply_f, 1);
        add_len += 1;
        rt_memcpy(Dis_Comm + add_len, bx_5k.Reserved0, 2);
        add_len += 2;
        rt_memcpy(Dis_Comm + add_len, &bx_5k.Areadealnum, 1);
        add_len += 1;
        rt_memcpy(Dis_Comm + add_len, &bx_5k.AreaNum, 1);
        add_len += 1;
        rt_memcpy(Dis_Comm + add_len, bx_5k.AreaLen, 2);
        add_len += 2;
        rt_memcpy(Dis_Comm + add_len, &bx_5k.AreaType, 1);
        add_len += 1;
        rt_memcpy(Dis_Comm + add_len, bx_5k.AreaX, 2);
        add_len += 2;
        rt_memcpy(Dis_Comm + add_len, bx_5k.AreaY, 2);
        add_len += 2;
        rt_memcpy(Dis_Comm + add_len, bx_5k.AreaWidth, 2);
        add_len += 2;
        rt_memcpy(Dis_Comm + add_len, bx_5k.AreaHeight, 2);
        add_len += 2;
        rt_memcpy(Dis_Comm + add_len, &bx_5k.DynamicAreaLoc, 1);
        add_len += 1;
        rt_memcpy(Dis_Comm + add_len, &bx_5k.Lines_sizes, 1);
        add_len += 1;
        rt_memcpy(Dis_Comm + add_len, &bx_5k.RunMode, 1);
        add_len += 1;
        rt_memcpy(Dis_Comm + add_len, bx_5k.Timeout, 2);
        add_len += 2;
        rt_memcpy(Dis_Comm + add_len, bx_5k.Reserved1, 3);
        add_len += 3;
        rt_memcpy(Dis_Comm + add_len, &bx_5k.SingleLine, 1);
        add_len += 1;
        rt_memcpy(Dis_Comm + add_len, &bx_5k.NewLine, 1);
        add_len += 1;
        rt_memcpy(Dis_Comm + add_len, &bx_5k.DisplayMode, 1);
        add_len += 1;
        rt_memcpy(Dis_Comm + add_len, &bx_5k.ExitMode, 1);
        add_len += 1;
        rt_memcpy(Dis_Comm + add_len, &bx_5k.Speed, 1);
        add_len += 1;
        rt_memcpy(Dis_Comm + add_len, &bx_5k.StayTime, 1);
        add_len += 1;
        rt_memcpy(Dis_Comm + add_len, bx_5k.DataLen, 4);
        add_len += 4;
        rt_memcpy(Dis_Comm + add_len, (uint8_t *)bx_5k.dis_buff, total);
        add_len += total;

        t = (bx_5k.Len[1] << 8) + bx_5k.Len[0];
        t = t + 14;                        //加Data_Field_1+数据长度2
        crc_data = CRC16_IBM(Dis_Comm, t); /*先计算出CRC值再来查询转义字符*/
        Dis_Comm[t] = crc_data >> 8;
        t = t + 1;
        Dis_Comm[t] = crc_data;
        t = t + 1;
        t = Escape_character(Dis_Comm, t); //字符转义处理
        Dis_Comm[t] = 0x5a;

        rt_pin_write(RS485_DOTLED_EN, PIN_HIGH); /*485输出使能*/

        rt_device_write(dotled, 0, bx_5k.Frame, 8);
        rt_device_write(dotled, 0, (Dis_Comm), t + 1);

        char *led_blink_mode_1 = "50,50,"; //10Hz闪烁
        led_set_mode(DOTLED, 5, led_blink_mode_1);

        rt_pin_write(RS485_DOTLED_EN, PIN_LOW); /*485输入使能*/
    }
}

//抬头：区域0显示函数，显示抬头
void DotLED_DisplayArea0_y(uint8_t x, uint8_t y, uint8_t Width, uint8_t Height, uint8_t TURNON_RUN)
{

    uint16_t add_len = 0; //整个数据总长度
    uint16_t total = 0;   /* 记录当前数据长度 */
    rt_uint32_t e;
    uint16_t crc_data = 0;
    //    uint16_t i, j, t = 0;
        uint16_t t = 0;
    if ((rt_event_recv(&timed_events, timed_events_TITLE,
                       RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR,
                       0, &e) == RT_EOK) ||
        (TURNON_RUN == 1)) //定时时间到或者开机运行1次
    {
        rt_memset(Dis_Comm, '\0', dis_buff_len + 300);
        rt_memset(bx_5k.dis_buff, '\0', dis_buff_len);

        bx_5k.AreaX[0] = (char)(x & 0xff);
        bx_5k.AreaX[1] = (char)((x >> 8) | 0x80); //最高位置一，以像素点为单位
                                                  //		bx_5k.AreaX[1] = (char)( x >> 8);

        bx_5k.AreaY[0] = (char)(y & 0xff);
        bx_5k.AreaY[1] = (char)(y >> 8);

        bx_5k.AreaWidth[0] = (char)(Width & 0xff);
        bx_5k.AreaWidth[1] = (char)((Width >> 8) | 0x80); //最高位置一，以像素点为单位
                                                          //		bx_5k.AreaWidth[1] 	= (char)( Width >> 8);

        bx_5k.AreaHeight[0] = (char)(Height & 0xff);
        bx_5k.AreaHeight[1] = (char)(Height >> 8);

        bx_5k.DynamicAreaLoc = 0x00; //设置动态区域为0
        bx_5k.Lines_sizes = 0;       //行间距
        bx_5k.RunMode = 0x00;        //动态区域运行模式，动态区数据循环显示*/
        bx_5k.Timeout[0] = 0x00;     //
        bx_5k.Timeout[1] = 0x00;     //超时时间
        bx_5k.SingleLine = 0x01;     //设置是否单行显示 ：单行显示
        bx_5k.NewLine = 0x01;        //设置是否自动换行：不自动换行

        if (title_timeout == 0) //正常显示气象站抬头
        {
            /*正常显示抬头效果配置*/
            bx_5k.DisplayMode = 0x01; //设置显示方式：02快速打出/03向左移动/05向上移动
            bx_5k.ExitMode = 0x00;    //设置退出方式
            bx_5k.Speed = 0x02;       //设置运行速度
            bx_5k.StayTime = 0xa0;    //设置停留时间 0x01为5s

            total += sprintf((char *)bx_5k.dis_buff + total, "%s", dotledtitle); //显示抬头
        }
        else //滚动显示下发内容
        {
            /*显示自定义抬头滚动效果配置*/
            bx_5k.DisplayMode = 0x03; //设置显示方式：02快速打出/03向左移动
            bx_5k.ExitMode = 0x00;    //设置退出方式
            bx_5k.Speed = 0x04;       //设置运行速度
            bx_5k.StayTime = 0x01;    //设置停留时间 0x01为0.5s

            total += sprintf((char *)bx_5k.dis_buff + total, "%s", dotledtitle_down); //显示抬头
        }

        bx_5k.Len[0] = (char)((total + 9 + 27) & 0xff); /*计算动态区域0数据长度*/
        bx_5k.Len[1] = (char)((total + 9 + 27) >> 8);
        bx_5k.AreaLen[0] = (char)((total + 27) & 0xff); /*计算动态区域0数据长度*/
        bx_5k.AreaLen[1] = (char)((total + 27) >> 8);

        bx_5k.DataLen[0] = (char)(total & 0xff); /*实际显示内容长度,实际占32位，只实现了16位*/
        bx_5k.DataLen[1] = (char)(total >> 8);

        rt_memcpy(Dis_Comm + add_len, bx_5k.Header, 12);
        add_len = 12;
        rt_memcpy(Dis_Comm + add_len, bx_5k.Len, 2);
        add_len += 2;
        rt_memcpy(Dis_Comm + add_len, bx_5k.Cmd_dis, 2);
        add_len += 2;
        rt_memcpy(Dis_Comm + add_len, &bx_5k.Reply_f, 1);
        add_len += 1;
        rt_memcpy(Dis_Comm + add_len, bx_5k.Reserved0, 2);
        add_len += 2;
        rt_memcpy(Dis_Comm + add_len, &bx_5k.Areadealnum, 1);
        add_len += 1;
        rt_memcpy(Dis_Comm + add_len, &bx_5k.AreaNum, 1);
        add_len += 1;
        rt_memcpy(Dis_Comm + add_len, bx_5k.AreaLen, 2);
        add_len += 2;
        rt_memcpy(Dis_Comm + add_len, &bx_5k.AreaType, 1);
        add_len += 1;
        rt_memcpy(Dis_Comm + add_len, bx_5k.AreaX, 2);
        add_len += 2;
        rt_memcpy(Dis_Comm + add_len, bx_5k.AreaY, 2);
        add_len += 2;
        rt_memcpy(Dis_Comm + add_len, bx_5k.AreaWidth, 2);
        add_len += 2;
        rt_memcpy(Dis_Comm + add_len, bx_5k.AreaHeight, 2);
        add_len += 2;
        rt_memcpy(Dis_Comm + add_len, &bx_5k.DynamicAreaLoc, 1);
        add_len += 1;
        rt_memcpy(Dis_Comm + add_len, &bx_5k.Lines_sizes, 1);
        add_len += 1;
        rt_memcpy(Dis_Comm + add_len, &bx_5k.RunMode, 1);
        add_len += 1;
        rt_memcpy(Dis_Comm + add_len, bx_5k.Timeout, 2);
        add_len += 2;
        rt_memcpy(Dis_Comm + add_len, bx_5k.Reserved1, 3);
        add_len += 3;
        rt_memcpy(Dis_Comm + add_len, &bx_5k.SingleLine, 1);
        add_len += 1;
        rt_memcpy(Dis_Comm + add_len, &bx_5k.NewLine, 1);
        add_len += 1;
        rt_memcpy(Dis_Comm + add_len, &bx_5k.DisplayMode, 1);
        add_len += 1;
        rt_memcpy(Dis_Comm + add_len, &bx_5k.ExitMode, 1);
        add_len += 1;
        rt_memcpy(Dis_Comm + add_len, &bx_5k.Speed, 1);
        add_len += 1;
        rt_memcpy(Dis_Comm + add_len, &bx_5k.StayTime, 1);
        add_len += 1;
        rt_memcpy(Dis_Comm + add_len, bx_5k.DataLen, 4);
        add_len += 4;
        rt_memcpy(Dis_Comm + add_len, (uint8_t *)bx_5k.dis_buff, total);
        add_len += total;

        t = (bx_5k.Len[1] << 8) + bx_5k.Len[0];
        t = t + 14;                        //加Data_Field_1+数据长度2
        crc_data = CRC16_IBM(Dis_Comm, t); /*先计算出CRC值再来查询转义字符*/
        Dis_Comm[t] = crc_data >> 8;
        t = t + 1;
        Dis_Comm[t] = crc_data;
        t = t + 1;
        t = Escape_character(Dis_Comm, t); //字符转义处理

        Dis_Comm[t] = 0x5a;

        rt_pin_write(RS485_DOTLED_EN, PIN_HIGH); /*485输出使能*/

        rt_device_write(dotled, 0, bx_5k.Frame, 8);
        rt_device_write(dotled, 0, (Dis_Comm), t + 1);

        char *led_blink_mode_1 = "50,50,"; //10Hz闪烁
        led_set_mode(DOTLED, 5, led_blink_mode_1);

        rt_pin_write(RS485_DOTLED_EN, PIN_LOW); /*485输入使能*/
    }
}

// //内容：区域1显示函数
// void DotLED_DisplayArea1(uint8_t x, uint8_t y, uint8_t Width, uint8_t Height, uint8_t keeptime)
// {

//     uint16_t add_len = 0; //整个数据总长度
//     uint16_t total = 0;   /* 记录当前数据长度 */

//     uint16_t crc_data = 0;
//     uint16_t i, j, t = 0;
//     rt_uint32_t e;

//     if (rt_event_recv(&timed_events, timed_events_MAIN,
//                       RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR,
//                       0, &e) == RT_EOK)
//     {
//         rt_memset(Dis_Comm, '\0', dis_buff_len + 300);
//         rt_memset(bx_5k.dis_buff, '\0', dis_buff_len);

//         bx_5k.AreaX[0] = (char)(x & 0xff);
//         bx_5k.AreaX[1] = (char)((x >> 8) | 0x80); //最高位置一，以像素点为单位
//                                                   //		bx_5k.AreaX[1] = (char)( x >> 8);

//         bx_5k.AreaY[0] = (char)(y & 0xff);
//         bx_5k.AreaY[1] = (char)(y >> 8);

//         bx_5k.AreaWidth[0] = (char)(Width & 0xff);
//         bx_5k.AreaWidth[1] = (char)((Width >> 8) | 0x80); //最高位置一，以像素点为单位
//                                                           //		bx_5k.AreaWidth[1] 	= (char)( Width >> 8);

//         bx_5k.AreaHeight[0] = (char)(Height & 0xff);
//         bx_5k.AreaHeight[1] = (char)(Height >> 8);

//         bx_5k.DynamicAreaLoc = 0x01; //设置动态区域为1

//         bx_5k.Lines_sizes = 0x01; //行间距

//         bx_5k.RunMode = 0x02; //动态区域运行模式，动态区数据循环显示，超过设定时间后数据仍未更新时不再显示*/

//         bx_5k.Timeout[0] = 0xa0; //

//         bx_5k.Timeout[1] = 0x00; //超时10s

//         bx_5k.SingleLine = 0x02; //设置是否单行显示 ：多行显示

//         bx_5k.NewLine = 0x02; //设置是否自动换行：自动换行

//         bx_5k.DisplayMode = 0x02; //设置显示方式：快速打出

//         bx_5k.ExitMode = 0x00; //设置退出方式

//         bx_5k.Speed = 0x18; //设置运行速度

//         bx_5k.StayTime = keeptime; //设置停留时间 0x01为0.5s

//         total = Area1_dis_format(bx_5k.dis_buff);

//         bx_5k.Len[0] = (char)((total + 9 + 27) & 0xff); /*计算动态区域0数据长度*/

//         bx_5k.Len[1] = (char)((total + 9 + 27) >> 8);

//         bx_5k.AreaLen[0] = (char)((total + 27) & 0xff); /*计算动态区域0数据长度*/

//         bx_5k.AreaLen[1] = (char)((total + 27) >> 8);

//         bx_5k.DataLen[0] = (char)(total & 0xff); /*实际显示内容长度,实际占32位，只实现了16位*/

//         bx_5k.DataLen[1] = (char)(total >> 8);

//         rt_memcpy(Dis_Comm + add_len, bx_5k.Header, 12);
//         add_len = 12;
//         rt_memcpy(Dis_Comm + add_len, bx_5k.Len, 2);
//         add_len += 2;
//         rt_memcpy(Dis_Comm + add_len, bx_5k.Cmd_dis, 2);
//         add_len += 2;
//         rt_memcpy(Dis_Comm + add_len, &bx_5k.Reply_f, 1);
//         add_len += 1;
//         rt_memcpy(Dis_Comm + add_len, bx_5k.Reserved0, 2);
//         add_len += 2;
//         rt_memcpy(Dis_Comm + add_len, &bx_5k.Areadealnum, 1);
//         add_len += 1;
//         rt_memcpy(Dis_Comm + add_len, &bx_5k.AreaNum, 1);
//         add_len += 1;
//         rt_memcpy(Dis_Comm + add_len, bx_5k.AreaLen, 2);
//         add_len += 2;
//         rt_memcpy(Dis_Comm + add_len, &bx_5k.AreaType, 1);
//         add_len += 1;
//         rt_memcpy(Dis_Comm + add_len, bx_5k.AreaX, 2);
//         add_len += 2;
//         rt_memcpy(Dis_Comm + add_len, bx_5k.AreaY, 2);
//         add_len += 2;
//         rt_memcpy(Dis_Comm + add_len, bx_5k.AreaWidth, 2);
//         add_len += 2;
//         rt_memcpy(Dis_Comm + add_len, bx_5k.AreaHeight, 2);
//         add_len += 2;
//         rt_memcpy(Dis_Comm + add_len, &bx_5k.DynamicAreaLoc, 1);
//         add_len += 1;
//         rt_memcpy(Dis_Comm + add_len, &bx_5k.Lines_sizes, 1);
//         add_len += 1;
//         rt_memcpy(Dis_Comm + add_len, &bx_5k.RunMode, 1);
//         add_len += 1; //动态区域运行模式
//         rt_memcpy(Dis_Comm + add_len, bx_5k.Timeout, 2);
//         add_len += 2;
//         rt_memcpy(Dis_Comm + add_len, bx_5k.Reserved1, 3);
//         add_len += 3;
//         rt_memcpy(Dis_Comm + add_len, &bx_5k.SingleLine, 1);
//         add_len += 1;
//         rt_memcpy(Dis_Comm + add_len, &bx_5k.NewLine, 1);
//         add_len += 1;
//         rt_memcpy(Dis_Comm + add_len, &bx_5k.DisplayMode, 1);
//         add_len += 1;
//         rt_memcpy(Dis_Comm + add_len, &bx_5k.ExitMode, 1);
//         add_len += 1;
//         rt_memcpy(Dis_Comm + add_len, &bx_5k.Speed, 1);
//         add_len += 1;
//         rt_memcpy(Dis_Comm + add_len, &bx_5k.StayTime, 1);
//         add_len += 1;
//         rt_memcpy(Dis_Comm + add_len, bx_5k.DataLen, 4);
//         add_len += 4;
//         rt_memcpy(Dis_Comm + add_len, (uint8_t *)bx_5k.dis_buff, total);
//         add_len += total;

//         t = (bx_5k.Len[1] << 8) + bx_5k.Len[0];
//         t = t + 14;                        //加Data_Field_1+数据长度2
//         crc_data = CRC16_IBM(Dis_Comm, t); /*先计算出CRC值再来查询转义字符*/

//         t = Escape_character(Dis_Comm, t); //字符转义处理

//         Dis_Comm[t] = crc_data >> 8;
//         t = t + 1;
//         Dis_Comm[t] = crc_data;
//         t = t + 1;
//         Dis_Comm[t] = 0x5a;

//         rt_pin_write(RS485_DOTLED_EN, PIN_HIGH); /*485输出使能*/
//         rt_device_write(dotled, 0, bx_5k.Frame, 8);
//         rt_device_write(dotled, 0, Dis_Comm, t + 1);

//         char *led_blink_mode_1 = "50,50,"; //10Hz闪烁
//         led_set_mode(DOTLED, 5, led_blink_mode_1);

//         rt_pin_write(RS485_DOTLED_EN, PIN_LOW); /*485输入使能*/
//     }
// }

//内容：区域1显示函数
void DotLED_DisplayArea_y(uint8_t x, uint8_t y, uint8_t Width, uint8_t Height, uint8_t keeptime, uint8_t pos, uint8_t DynamicArea)
{

    uint16_t add_len = 0; //整个数据总长度
    uint16_t total = 0;   /* 记录当前数据长度 */

    uint16_t crc_data = 0;
    //    uint16_t i, j, t = 0;
    uint16_t t = 0;
//    rt_uint32_t e;

    rt_memset(Dis_Comm, '\0', dis_buff_len + 300);
    rt_memset(bx_5k.dis_buff, '\0', dis_buff_len);

    bx_5k.AreaX[0] = (char)(x & 0xff);

    //根据控制卡型号设定显示格式（X ：1BIt or 8Bit）
    if (qxz.Param.Dotled_Option == 5 || qxz.Param.Dotled_Option == 7)
    {
        bx_5k.AreaX[1] = (char)((x >> 8) | 0x80); //最高位置一，以像素点为单位
    }
    else if (qxz.Param.Dotled_Option == 6 || qxz.Param.Dotled_Option == 8)
    {
        bx_5k.AreaX[1] = (char)(x >> 8); //8Bit
    }

    bx_5k.AreaY[0] = (char)(y & 0xff);
    bx_5k.AreaY[1] = (char)(y >> 8);

    bx_5k.AreaWidth[0] = (char)(Width & 0xff);

    //根据控制卡型号设定显示格式（W ：1BIt or 8Bit）
    if (qxz.Param.Dotled_Option == 5 || qxz.Param.Dotled_Option == 7)
    {
        bx_5k.AreaWidth[1] = (char)((Width >> 8) | 0x80); //最高位置一，以像素点为单位
    }

    if (qxz.Param.Dotled_Option == 6 || qxz.Param.Dotled_Option == 8)
    {
        bx_5k.AreaWidth[1] = (char)(Width >> 8);
    }

    bx_5k.AreaHeight[0] = (char)(Height & 0xff);
    bx_5k.AreaHeight[1] = (char)(Height >> 8);

    bx_5k.DynamicAreaLoc = DynamicArea; //设置动态区域为1

    bx_5k.Lines_sizes = 0x01; //行间距

    bx_5k.RunMode = 0x02; //动态区域运行模式，动态区数据循环显示，超过设定时间后数据仍未更新时不再显示*/

    bx_5k.Timeout[0] = 0xa0; //

    bx_5k.Timeout[1] = 0x00; //超时10s

    bx_5k.SingleLine = 0x02; //设置是否单行显示 ：多行显示

    bx_5k.NewLine = 0x02; //设置是否自动换行：自动换行

    bx_5k.DisplayMode = 0x02; //设置显示方式：快速打出

    bx_5k.ExitMode = 0x00; //设置退出方式

    bx_5k.Speed = 0x18; //设置运行速度

    bx_5k.StayTime = keeptime; //设置停留时间 0x01为0.5s

    total = Area1_dis_format_area(bx_5k.dis_buff, pos, DynamicArea);

    bx_5k.Len[0] = (char)((total + 9 + 27) & 0xff); /*计算动态区域0数据长度*/

    bx_5k.Len[1] = (char)((total + 9 + 27) >> 8);

    bx_5k.AreaLen[0] = (char)((total + 27) & 0xff); /*计算动态区域0数据长度*/

    bx_5k.AreaLen[1] = (char)((total + 27) >> 8);

    bx_5k.DataLen[0] = (char)(total & 0xff); /*实际显示内容长度,实际占32位，只实现了16位*/

    bx_5k.DataLen[1] = (char)(total >> 8);

    rt_memcpy(Dis_Comm + add_len, bx_5k.Header, 12);
    add_len = 12;
    rt_memcpy(Dis_Comm + add_len, bx_5k.Len, 2);
    add_len += 2;
    rt_memcpy(Dis_Comm + add_len, bx_5k.Cmd_dis, 2);
    add_len += 2;
    rt_memcpy(Dis_Comm + add_len, &bx_5k.Reply_f, 1);
    add_len += 1;
    rt_memcpy(Dis_Comm + add_len, bx_5k.Reserved0, 2);
    add_len += 2;
    rt_memcpy(Dis_Comm + add_len, &bx_5k.Areadealnum, 1);
    add_len += 1;
    rt_memcpy(Dis_Comm + add_len, &bx_5k.AreaNum, 1);
    add_len += 1;
    rt_memcpy(Dis_Comm + add_len, bx_5k.AreaLen, 2);
    add_len += 2;
    rt_memcpy(Dis_Comm + add_len, &bx_5k.AreaType, 1);
    add_len += 1;
    rt_memcpy(Dis_Comm + add_len, bx_5k.AreaX, 2);
    add_len += 2;
    rt_memcpy(Dis_Comm + add_len, bx_5k.AreaY, 2);
    add_len += 2;
    rt_memcpy(Dis_Comm + add_len, bx_5k.AreaWidth, 2);
    add_len += 2;
    rt_memcpy(Dis_Comm + add_len, bx_5k.AreaHeight, 2);
    add_len += 2;
    rt_memcpy(Dis_Comm + add_len, &bx_5k.DynamicAreaLoc, 1);
    add_len += 1;
    rt_memcpy(Dis_Comm + add_len, &bx_5k.Lines_sizes, 1);
    add_len += 1;
    rt_memcpy(Dis_Comm + add_len, &bx_5k.RunMode, 1);
    add_len += 1; //动态区域运行模式
    rt_memcpy(Dis_Comm + add_len, bx_5k.Timeout, 2);
    add_len += 2;
    rt_memcpy(Dis_Comm + add_len, bx_5k.Reserved1, 3);
    add_len += 3;
    rt_memcpy(Dis_Comm + add_len, &bx_5k.SingleLine, 1);
    add_len += 1;
    rt_memcpy(Dis_Comm + add_len, &bx_5k.NewLine, 1);
    add_len += 1;
    rt_memcpy(Dis_Comm + add_len, &bx_5k.DisplayMode, 1);
    add_len += 1;
    rt_memcpy(Dis_Comm + add_len, &bx_5k.ExitMode, 1);
    add_len += 1;
    rt_memcpy(Dis_Comm + add_len, &bx_5k.Speed, 1);
    add_len += 1;
    rt_memcpy(Dis_Comm + add_len, &bx_5k.StayTime, 1);
    add_len += 1;
    rt_memcpy(Dis_Comm + add_len, bx_5k.DataLen, 4);
    add_len += 4;
    rt_memcpy(Dis_Comm + add_len, (uint8_t *)bx_5k.dis_buff, total);
    add_len += total;

    t = (bx_5k.Len[1] << 8) + bx_5k.Len[0];
    t = t + 14;                        //加Data_Field_1+数据长度2
    crc_data = CRC16_IBM(Dis_Comm, t); /*先计算出CRC值再来查询转义字符*/

    Dis_Comm[t] = crc_data >> 8;
    t = t + 1;
    Dis_Comm[t] = crc_data;
    t = t + 1;
    t = Escape_character(Dis_Comm, t); //字符转义处理

    Dis_Comm[t] = 0x5a;

    rt_pin_write(RS485_DOTLED_EN, PIN_HIGH); /*485输出使能*/
    rt_device_write(dotled, 0, bx_5k.Frame, 8);
    rt_device_write(dotled, 0, Dis_Comm, t + 1);

    char *led_blink_mode_1 = "50,50,"; //10Hz闪烁
    led_set_mode(DOTLED, 5, led_blink_mode_1);

    rt_pin_write(RS485_DOTLED_EN, PIN_LOW); /*485输入使能*/
}

//显示清屏
void DotLED_DisplayClear_y(void)
{

    uint16_t add_len = 0; //整个数据总长度
//    uint16_t total = 0;   /* 记录当前数据长度 */
    char clr[] = {0x05, 0x00, 0xA3, 0x10, 0x01, 0x00, 0x00};
    uint16_t crc_data = 0;
    //    uint16_t i, j, t = 0;
    uint16_t t = 0;

    rt_memset(Dis_Comm, '\0', dis_buff_len + 300);

    rt_memcpy(Dis_Comm + add_len, bx_5k.Header, 12);
    add_len = 12;
    rt_memcpy(Dis_Comm + add_len, clr, 7);
    add_len += 7;

    t = add_len;
    crc_data = CRC16_IBM(Dis_Comm, t); /*先计算出CRC值再来查询转义字符*/
    Dis_Comm[t] = crc_data >> 8;
    t = t + 1;
    Dis_Comm[t] = crc_data;
    t = t + 1;
    t = Escape_character(Dis_Comm, t); //字符转义处理

    Dis_Comm[t] = 0x5a;

    rt_pin_write(RS485_DOTLED_EN, PIN_HIGH); /*485输出使能*/

    rt_device_write(dotled, 0, bx_5k.Frame, 8);
    rt_device_write(dotled, 0, (Dis_Comm), t + 1);

    char *led_blink_mode_1 = "50,50,"; //10Hz闪烁
    led_set_mode(DOTLED, 5, led_blink_mode_1);

    rt_pin_write(RS485_DOTLED_EN, PIN_LOW); /*485输入使能*/
}

//显示属性初始化
//LED_DIS_PAR led_dis[2] = {0};
static void dotled_y_thread_entry(void *parameter)
{

    rt_thread_mdelay(8000); //等待led参数读取

    rt_pin_mode(RS485_DOTLED_EN, PIN_MODE_OUTPUT);

    if (qxz.Param.Dotled_Option > 1) //其他尺寸，没有抬头的显示
    {

        // Control_card != 5 &&		//Y1A 单区域（1Bit）
        // Control_card != 6 &&		//Y1A 单区域（8Bit）
        // Control_card != 7 &&		//Y1A 双区域（1Bit）
        // Control_card != 8)		//Y1A 双区域（8Bit）

        /*
    Note:

    1. 控制卡大于等于5 说明启用Y1A控制卡（Y08通用）
    2. 当keeptime小于11的时候 负责keeptime 大于等于的时候 同时负责调整动态区域间的间隙
    此时keeptime为 （数值%11）
    此时刷新延时为5秒
    此时两个区域间隔为 keeptime * 2
    综上可得 间隔可调区域为 22-64


*/

        uint16_t spacing = 0; //两动态区域之间的间距
        uint16_t D1_X = 0;    //D1 的起始位置的计算

//        uint8_t Screen_Cnt = 0;
//        uint8_t len = 0;
        uint8_t All_elem = 0;

        screen_line = qxz.Param.dotled_p0.Height / qxz.Param.dotled_p0.front; //高度除以字体高度

        while (1)
        {

            All_elem = qxz.Param.Num_sensors;
            for (uint8_t c = 0; c < qxz.Param.Num_sensors; c++)
            {
                if (strstr(sensor[c].eName, "ALINE") != NULL)
                {
                    All_elem++;
                }
            }

            if (qxz.Param.dotled_p0.keep_time > 10)
            {
                spacing = qxz.Param.dotled_p0.keep_time * 2;
            }
            else
            {
                spacing = 30;
            }

            //    rt_kprintf("spacing %d D1_X %d\n" , spacing ,D1_X);

            if (qxz.Param.Dotled_Option >= 5)
            {
                DotLED_DisplayArea_y(qxz.Param.dotled_p0.Start_x,
                                     qxz.Param.dotled_p0.Start_y,
                                     qxz.Param.dotled_p0.Width,
                                     qxz.Param.dotled_p0.Height,
                                     (qxz.Param.dotled_p0.keep_time % 11) * 2,
                                     qxz.Param.dotled_p0.keep_time, 0);
            }
            //rt_kprintf("D0 send\n");
            if (qxz.Param.dotled_p0.keep_time <= 10)
            {
                rt_thread_mdelay(qxz.Param.dotled_p0.keep_time * 2000);
            }
            else
            {
                rt_thread_mdelay(5000);
            }

            if (qxz.Param.Dotled_Option >= 7)
            {
                if (qxz.Param.Dotled_Option == 7)
                {
                    D1_X = (qxz.Param.dotled_p0.Start_x + qxz.Param.dotled_p0.Width + spacing);
                }
                else if (qxz.Param.Dotled_Option == 8)
                {
                    D1_X = qxz.Param.dotled_p0.Start_x + qxz.Param.dotled_p0.Width + spacing / 8;
                }

                DotLED_DisplayArea_y(D1_X,
                                     qxz.Param.dotled_p0.Start_y,
                                     qxz.Param.dotled_p0.Width,
                                     qxz.Param.dotled_p0.Height,
                                     (qxz.Param.dotled_p0.keep_time % 11) * 2,
                                     qxz.Param.dotled_p0.keep_time, 1);
                //rt_kprintf("D1 send\n");
                if (qxz.Param.dotled_p0.keep_time <= 10)
                {
                    rt_thread_mdelay(qxz.Param.dotled_p0.keep_time * 2000);
                }
                else
                {
                    rt_thread_mdelay(5000);
                }
            }
        }
    }
}

// led点阵屏控制线程
static void dotled_y_thread(void *param)
{
    rt_err_t ret = RT_EOK;
    char uart_name[RT_NAME_MAX];
    struct serial_configure config = RT_SERIAL_CONFIG_DEFAULT; /* 初始化配置参数 */
//    uint8_t dotled_size;

    if (qxz.Param.Dotled_Option > 3 && qxz.Param.Dotled_Option < 9) //彩屏led点阵屏使能
    {

        //		controller_type(qxz.Param.Dotled_Option);//计算控制卡型号
        Dis_Comm = (unsigned char *)rt_malloc(dis_buff_len + 300);
        if (Dis_Comm == RT_NULL)
        {
            log_i("Dis_Comm out of memory");
            ret = RT_ERROR;
            goto __exit;
        }

        bx_5k.dis_buff = (unsigned char *)rt_malloc(dis_buff_len);
        if (Dis_Comm == RT_NULL)
        {
            log_i("bx_5k.dis_buff out of memory");
            ret = RT_ERROR;
            goto __exit;
        }

        /* 初始化事件对象 */
        ret = rt_event_init(&timed_events, "event", RT_IPC_FLAG_FIFO);
        if (ret != RT_EOK)
        {
            log_i("init event failed.\n");
            return (void)ret;
        }
        /* 创建定时器 1  周期定时器 */
        dotled_timed_task = rt_timer_create("dotled_timer", dotled_timed,
                                            (void *)1, 1000,
                                            RT_TIMER_FLAG_PERIODIC);

        /* 启动定时器 1 */
        if (dotled_timed_task != RT_NULL)
            rt_timer_start(dotled_timed_task);

        /* 查找串口设备 */
        rt_strncpy(uart_name, DOTLED_UART_NAME, RT_NAME_MAX);
        dotled = rt_device_find(uart_name);
        if (!dotled)
        {
            rt_kprintf("find %s failed!\n", uart_name);
            return RT_ERROR;
        }
        /* step2：修改串口配置参数 */
        config.baud_rate = BAUD_RATE_57600; //修改波特率为57600
        config.data_bits = DATA_BITS_8;     //数据位 8
        config.stop_bits = STOP_BITS_1;     //停止位 1
        config.bufsz = 1024;                //修改缓冲区 buff size 为 128
        config.parity = PARITY_NONE;        //无奇偶校验位

        /* step3：控制串口设备。通过控制接口传入命令控制字，与控制参数 */
        rt_device_control(dotled, RT_DEVICE_CTRL_CONFIG, &config);

        rt_device_open(dotled, RT_DEVICE_FLAG_INT_RX);

        /* 创建 serial 线程 */
        rt_thread_t thread1 = rt_thread_create("dotled_y", dotled_y_thread_entry, RT_NULL, 2048, 17, 10);
        /* 创建成功则启动线程 */
        if (thread1 != RT_NULL)
        {
            rt_thread_startup(thread1);
        }
        else
        {
            ret = RT_ERROR;
        }
    }
    else
        ret = RT_EEMPTY;
__exit:
    if (ret == RT_EOK)
    {
        //return ret;
    }
    else
    {
        rt_free(Dis_Comm);
        Dis_Comm = RT_NULL;
        rt_free(bx_5k.dis_buff);
        bx_5k.dis_buff = RT_NULL;
    }

    //return ret;
}

INIT_APP_EXPORT(dotled_y_thread);