T536_DTU/dtu/dtu_main_t536/app/IEC104.c

/********************************************************************
版权所有：
文件版本： V1.00
文件名称： IEC104.c
生成日期： 2007年04月26日
作    者：xxxxxx
使用范围：

功    能： IEC104规约处理
更新信息：
更新日志1：
修改者:
修改日期:
修改内容:
修改原因:
*********************************************************************/
#include "head.h"
#ifdef LINUX_KERNEL_APP
#include <linux/delay.h>
#endif

#define IEC104_printf rt_printf_time

IEC104_DEF g_t104[IEC104_TOTAL_SOCKETS]; /*104规约结构定义*/
static bool g_104_comm_status[IEC104_TOTAL_SOCKETS];

void IEC104_Info_Printf_One(IEC104_DEF *p);

void IEC104_UnPackFrame(IEC104_DEF *pt104, BYTE *pd, int type)
{

    if (!g_bCommLed)
        g_bCommLed = true;
    if (g_print_104 && (g_print_port & (1 << pt104->chnl)))
    {
        if (type == 0)
        {
            print_msg("RX_104:", pd, pd[1] + 2);
        }
        else if (type == 1)
        {
            print_msg("TX_104:", pd, pd[1] + 2);
        }
        else if (type == 2)
        {
            print_msg("TX_104:", &pd[1], pd[0]);
        }
    }
}
void set_104_link_status(WORD net)
{
    if (net > CFG_ETH_NUM_MAX - 1)
        return;

    g_104_comm_status[net] = true;
}
void cls_104_link_status(WORD net)
{
    if (net > CFG_ETH_NUM_MAX - 1)
        return;

    g_104_comm_status[net] = false;
}

bool get_104_link_status(WORD net)
{
    if (net > CFG_ETH_NUM_MAX - 1)
        return 0;

    return g_104_comm_status[net];
}

void IEC104_Init(void)
{
    int i;
    IEC104_DEF *pt104;
    for (i = 0; i < CFG_ETH_MAX_LOGIC; i++)
    {
        pt104 = &g_t104[i];

        memset(pt104, 0, sizeof(IEC104_DEF));
        pt104->type = IEC104_TYPE_NET;
        pt104->chnl = i + CFG_UART_NUM_MAX;

        pt104->cNetIndex = i;

        // 初始化接收buf结构
        pt104->RxBuf.chn = pt104->chnl;
        pt104->RxBuf.buf = pt104->arrRecvBuf;
        rt_fifo_init(&pt104->recv_fifo, pt104->recv_fifo_buf, IEC104_FIFO_SIZE);

        s_stat_protocol(pt104->chnl, PROTOCOL_104); // 统计规约
#ifdef RCD_STRAN_S
        queue_init(&pt104->rcd_qt.queue, NEWRCD_COUNT, &pt104->rcd_qt.data, NEWRCD_SIZE);
#endif
    }
}

void IEC104_Init_RS(IEC104_DEF *pt104, BYTE chnl)
{
    memset(pt104, 0, sizeof(IEC104_DEF));
    pt104->type = IEC104_TYPE_RS;
    pt104->chnl = chnl;

    // 初始化接收buf结构
    pt104->RxBuf.chn = pt104->chnl;
    pt104->RxBuf.buf = pt104->arrRecvBuf;
    rt_fifo_init(&pt104->recv_fifo, pt104->recv_fifo_buf, IEC104_FIFO_SIZE);
}

static void IEC104_Reset(IEC104_DEF *pt104)
{
    // 通道属性、连接计数不允许复位

    // 规约状态复位
    if (g_comm_link_status & (1 << pt104->chnl))
    {
        char buf[64];
        char log_info[128];
        if (pt104->type == IEC104_TYPE_NET)
        {
            sprintf(buf, "104主站断开(%sIP=%d.%d.%d.%d)!\r\n", get_comm_name(pt104->chnl + 1), pt104->ip[0], pt104->ip[1], pt104->ip[2], pt104->ip[3]);
        }
        else
        {
            sprintf(buf, "104主站断开(%s)!\r\n", get_comm_name(pt104->chnl + 1));
        }
        log_str_time(LOG_OPERATE, buf, 0, 0);

        sprintf(log_info, "IEC104(%d):104 main station disconnection", pt104->chnl + 1);
        load_hs_log_rcd(TYPE_CHNL_LINK, true, NULL, log_info, 0);

        g_comm_link_status &= ~(1 << pt104->chnl);
    }

    IEC104_printf("IEC104(%d) reset state: %d => %d,linkcount=%d!\r\n",
                  pt104->chnl, pt104->state, 0, pt104->LinkCountApp);

    pt104->state = 0;
    pt104->bSendChange = false;

    // 序号复位
    pt104->SendNum.ss = 0; // 发送序列号
    pt104->RecvNum.ss = 0; // 接收序列号
    pt104->AckNum.ss = 0;  // 确认序列号
    pt104->AckRecvNum = 0;
    // 计时
    pt104->us0_yc = ustimer_get_origin();
    pt104->us0_sec = pt104->us0_yc;
    pt104->secs = 0;
    pt104->us0_client = ustimer_get_origin();

    // 测试状态复位
    pt104->bStartTest = false;
    pt104->us0_test = ustimer_get_origin();

    // 其它状态复位
    pt104->bRmtSM2 = false;
    pt104->bClientStart = false;

    // SOE发送缓冲区复位，发送指针回到ACK的位置
    if (tRunPara.w104K && pRunSet->bTT_SoeResumeComm)
    {
        g_soe_queue.tail_send[pt104->chnl].n = g_soe_queue.tail_ack[pt104->chnl].n;
    }

    // 遥控信息复位
    ResetRctrl(MASTER_104 + pt104->chnl);

    // 104发送缓冲区复位
    memset(&pt104->TxBuf, 0, sizeof(pt104->TxBuf));
#ifdef RCD_STRAN_S
    rt_printf_time("-> Link Reset, Clear File Cache\r\n");
    iec_freefile(&pt104->tf);
    pt104->tf.bTransing = false;
    pt104->tf.bdatTraned = false;
#endif
}

// 规约主动关闭连接
static void IEC104_ActiveClose(IEC104_DEF *pt104)
{
    // 复位状态
    IEC104_Reset(pt104);

    // 如果是网络104，直接断开TCP连接
    if (pt104->type != IEC104_TYPE_RS)
    {
        net_104_close_flag(pt104->cNetIndex);
    }
}

// 检查是否当前连接的报文
static int IEC104_IsCurFrame(IEC104_DEF *pt104)
{
    int n;

    if (tRunPara.b104Client)
        return 1;
    // 检查是否当前连接的报文
    n = pt104->LinkCountRecv - pt104->LinkCountApp;
    // 是新连接的报文，直接退出，待重新初始化后再处理
    if (n > 0)
    {
        IEC104_printf("IEC104(%d) Recv new frame: Recv=%d,App=%d!\r\n",
                      pt104->chnl, pt104->LinkCountRecv, pt104->LinkCountApp);
        return 0;
    }
    // 是旧报文，直接丢弃不处理
    else if (n < 0)
    {
        IEC104_printf("IEC104(%d) Recv old frame: n=%d,Recv=%d,App=%d!\r\n",
                      pt104->chnl, n, pt104->LinkCountRecv, pt104->LinkCountApp);
        pt104->bRecvOk = false;
        pt104->bSM2Data = false;
        return 0;
    }
    // 是旧报文，直接丢弃不处理(在没有连接的情况下，只有在串口104下，启动数据传输命令可以处理)
    else if (pt104->state == 0 && !(pt104->type == IEC104_TYPE_RS && pt104->arrRecvBuf[2] == FRAME_U_SATRT))
    {
        IEC104_printf("IEC104(%d) Recv old frame: n=%d,state=%d,type=%d,frame=%02x!\r\n",
                      pt104->chnl, n, pt104->state, pt104->type, pt104->arrRecvBuf[2]);
        pt104->bRecvOk = false;
        pt104->bSM2Data = false;
        return 0;
    }

    return 1;
}

/**************************************************************************
函数名称：Reset104Recv
函数版本：1.00
作者：
创建日期：2007.9.1
函数功能说明：复归104的数据接收
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/
void IEC104_Recv_Reset(IEC104_DEF *pt104)
{
    pt104->cTypeCounter = 0;
    pt104->cRecvCnt = 0;
}

static bool IEC104_SM2RmtCheck(IEC104_DEF *pt) // 判断是否是遥控报文
{
    if (!pRunSet->bTT_SM2)
        return false; // 加密功能未投入

    if ((pt->arrRecvBuf[0] == 0x68) && (pt->arrRecvBuf[1] > 4) && ((pt->arrRecvBuf[6] == 46) || (pt->arrRecvBuf[6] == 45))) // 遥控报文
    {
        return true;
    }

    return false;
}

/**************************************************************************
函数名称：IEC104_Recv
函数版本：1.00
作者：
创建日期：2007.9.1
函数功能说明：104数据接受，只判断是否满足帧格式
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/
int IEC104_Recv_Normal(IEC104_DEF *pt104, BYTE cRcvData)
{
    pt104->arrRecvBuf[pt104->cRecvCnt++] = cRcvData;
    s_stat_rx(pt104->chnl, 1);

    switch (pt104->cTypeCounter)
    {
    case 0:
        if (cRcvData == 0x68)
        {
            pt104->cTypeCounter = 1;
            s_stat_rx_frame(pt104->chnl); // 统计接收帧数

            memset(&pt104->arrRecvBuf[1], 0, 30);
        }
        else if (cRcvData == 0x16) // SM2 报文
        {
            pt104->cTypeCounter = 20;
            pt104->cRecvCnt = 256;
            pt104->arrRecvBuf[pt104->cRecvCnt++] = cRcvData;
            pt104->arrRecvBuf[0] = 0x68;  // 恢复被0x16 覆盖的第一字节数据
            s_stat_rx_frame(pt104->chnl); // 统计接收帧数

            if (!pRunSet->bTT_SM2) // 加密功能未投入
            {
                IEC104_Recv_Reset(pt104);
                s_stat_rx_errframe(pt104->chnl); // 统计接收错误帧数
            }
        }
        else
        {
            IEC104_Recv_Reset(pt104);
            s_stat_rx_err(pt104->chnl, 1); // 统计接收错误字节数
        }
        break;
    case 1:
        pt104->cRecvLenth = cRcvData + 2;
        pt104->cTypeCounter = 2;
        break;

    case 2:
        if (pt104->cRecvCnt >= pt104->cRecvLenth)
        {
            // 报文接受完毕
            IEC104_Recv_Reset(pt104);

            if (IEC104_SM2RmtCheck(pt104))
            {
                // 如果是加密遥控报文，应用层暂不处理，等解密完成后处理
                pt104->bRmtSM2 = true;
                pt104->us0_SM2Over = ustimer_get_origin();
            }
            else
            {
                // 接收到一帧普通报文：
                // 1、设置普通帧接收标志
                // 2、唤醒主循环
                pt104->LinkCountRecv = pt104->LinkCountNet;
                pt104->bRecvOk = true;
                mainloop_wakeup();
                return 1;
            }
        }
        break;

    case 20: // SM2报文 L2长度
        pt104->SM2L2 = cRcvData;
        pt104->cTypeCounter++;
        break;
    case 21: // SM2报文 L2长度
        pt104->cTypeCounter++;
        if (cRcvData >= pt104->SM2L2) // L2长度包含L3长度，L3<L2，做一简单校验
        {
            s_stat_rx_errframe(pt104->chnl); // 统计接收帧数
            IEC104_Recv_Reset(pt104);
        }
        break;
    case 22:
        if (cRcvData == 0x16)
        {
            pt104->cTypeCounter++;
            pt104->csm2RecvCnt = 0;
        }
        else
        {
            s_stat_rx_errframe(pt104->chnl); // 统计接收帧数
            IEC104_Recv_Reset(pt104);
        }
        break;
    case 23:
        if (++pt104->csm2RecvCnt >= pt104->SM2L2)
        {
            pt104->cTypeCounter++;
        }
        break;

    case 24: // 校验和
        pt104->cTypeCounter++;
        break;

    case 25: // 结束符
        IEC104_Recv_Reset(pt104);
        if (cRcvData == 0x16) // 校验结束字符,报文接收完毕，
        {
            // 接收到一帧加密报文
            // 1、设置加密帧接收标志
            // 2、唤醒主循环
            pt104->LinkCountRecv = pt104->LinkCountNet;
            pt104->bSM2Data = true;
            mainloop_wakeup();
            return 1;
        }
        else
        {
            s_stat_rx_errframe(pt104->chnl); // 统计接收帧数
        }
        break;
    default:
        s_stat_rx_errframe(pt104->chnl); // 统计接收帧数
        IEC104_Recv_Reset(pt104);
        break;
    }

    return 0;
}

void IEC104_Recv_Int(IEC104_DEF *pt, u8 byRevData)
{
    rt_fifo_put(&pt->recv_fifo, &byRevData, 1);
}

void IEC104_Recv_App(IEC104_DEF *pt)
{
    u8 c;
    // 接收数据
    while (pt->bSM2Data == false && pt->bRecvOk == false)
    {
        if (rt_fifo_get(&pt->recv_fifo, &c, 1))
        {
            // rt_printf("----[%02x]",c);
            IEC104_Recv(pt, c);
        }
        else
        {
            break;
        }
    }
}

int IEC104_Recv(IEC104_DEF *pt104, BYTE cRcvData)
{
    int ret;
    if (pRunSet->bTT_ESAM)
    {
        ret = sec_recv(&pt104->RxBuf, cRcvData, pt104->extSendBuf, false);
        if (ret == SEC_FRAME_OK_APP) // 带规约的报文
        {
            pt104->bRecvOk = 1;
            pt104->LinkCountRecv = pt104->LinkCountNet;
        }
        else if (ret == SEC_FRAME_OK_EXT) // 纯安全扩展报文 发送
        {
            net_104_send_ext(pt104->cNetIndex, pt104->extSendBuf + 2, ((pt104->extSendBuf[0] << 8) + pt104->extSendBuf[1]));
        }
    }
    else
    {
        ret = IEC104_Recv_Normal(pt104, cRcvData);
    }

    return ret;
}

static int IEC104_BufFree(iec_tbuf_t *pt)
{
    return (pt->tb_tail_ack - pt->tb_head - 1) & (IEC_TBUF_NUM - 1);
}

static u16 IEC104_GetOneBuf(iec_tbuf_t *pt)
{
    u16 head;

    head = pt->tb_head;
    pt->tb_head++;

    // 系统设计时，保证缓冲不会满，以下情况不应出现
    if (pt->tb_head == pt->tb_tail_ack || pt->tb_head == pt->tb_tail_send)
    {
        IEC104_printf("IEC104: IEC104_GetOneBuf error:head=%d,send=%d,ack=%d.\r\n", pt->tb_head, pt->tb_tail_send, pt->tb_tail_ack);
    }

    return head;
}

static void IEC104_UpdateCOS(u8 *pd)
{
    u8 sq, num, i, ti;
    u16 cp;
    u8 SIQ;
    ti = pd[0];
    sq = pd[1] & 0x80;
    num = pd[1] & 0x7f;
    cp = pd[6] | (pd[7] << 8);
    pd += 9;

    for (i = 0; i < num; i++)
    {

        SIQ = tbl_get_yx(tbl_cp2index(cp), (ti == 3 ? 1 : 0));
#if !defined FUNC_JX_YX_BEFORE
        if (g_run_stu.bjx)
            SIQ |= 0x80;
#endif
        *pd++ = SIQ;
        if (sq == 0)
        {
            cp = pd[0] | (pd[1] << 8);
            pd += 3;
        }
        else
        {
            cp++;
        }
    }
}

static void IEC104_Send_Polling(IEC104_DEF *pt104)
{
    u16 i, k, len, frm_attr;
    u8 *pd;
    iec_tbuf_t *pt;

    // 运行到这，如果有数据就无条件发送
    for (i = 0; i < 2; i++)
    {
        pt = &pt104->TxBuf[i];
        while (pt->tb_head != pt->tb_tail_send)
        {
            // 如果是串口以太网，中断还有上帧数据没有发送完，直接返回。
            if (pt104->type == IEC104_TYPE_RS)
            {
                if (g_tRsComm[pt104->chnl].bSend)
                {
                    return;
                }
            }

            frm_attr = pt->tb_info[pt->tb_tail_send].frm_attr;
            len = pt->tb_data[pt->tb_tail_send][0];
            if ((frm_attr & 0xff) == FRAME_I)
            {
                // 检查状态
                if (pt104->state != IEC104_ST_STARTED)
                {
                    return;
                }

                // 检查K值，k为待确认帧数，如果大于等于设定值就不再发送
                k = pt104->SendNum.ss - pt104->AckNum.ss;
                if (tRunPara.w104K && k >= tRunPara.w104K)
                {
                    return;
                }

                // 完善6字节帧头
                pd = &pt->tb_data[pt->tb_tail_send][1];
                *pd++ = 0x68;
                *pd++ = (BYTE)(len - 2);
                CopySwap(pd, pt104->SendNum.tt, 2, true); // 发送序列号
                *pd = (*pd) & 0xfe;
                pd += 2;

                CopySwap(pd, pt104->RecvNum.tt, 2, true); // 接收序列号
                *pd = (*pd) & 0xfe;
                pd += 2;

                pt104->AckRecvNum = pt104->RecvNum.ss;

                // 更新低优先级的COS
                if ((frm_attr & (FRAME_I_PRIOR_LOW | FRAME_I_COS)) == (FRAME_I_PRIOR_LOW | FRAME_I_COS))
                {
                    IEC104_UpdateCOS(pd);
                }

                // 更新发送序号
                pt104->SendNum.ss += 2;

                // 保存报文的发送帧号，为待发帧的序号，放在序号加之后
                pt->tb_info[pt->tb_tail_send].tb_SendNum = pt104->SendNum.ss;
            }

            // 真正发送
            pd = &pt->tb_data[pt->tb_tail_send][1];
            if (pt104->type != IEC104_TYPE_RS) // 非串口以太网
            {
                net_104_send(pt104->cNetIndex, &pt->tb_data[pt->tb_tail_send][1], len);
            }
            else
            {
                pd = g_tRsComm[pt104->chnl].sendbuf;
                memcpy(g_tRsComm[pt104->chnl].sendbuf, pt->tb_data[pt->tb_tail_send], len + 1); // 拷贝数据

                RS_Send_Enable(pt104->chnl);
                g_tRsComm[pt104->chnl].nSendCnt = 1; // 发送缓冲区的第一个字节为发送长度
                g_tRsComm[pt104->chnl].bSend = true;

#ifdef FUN_FUXI_ESAM
                if (UART_CHANNEL[pt104->chnl] == CFG_UART_CHIP_S1)
                {
                    write_chip_s1(&pt->tb_data[pt->tb_tail_send][1], len);
                    g_tRsComm[pt104->chnl].bSend = false;
                }
#endif
            }

            // T1 超时计时开始点
            pt->tb_info[pt->tb_tail_send].us0 = ustimer_get_origin();

            // 亮通讯灯和打印报文
            IEC104_UnPackFrame(pt104, pt->tb_data[pt->tb_tail_send], 2);
            s_stat_tx_frame(pt104->chnl); // 统计发送帧数
            s_stat_tx(pt104->chnl, len);  // 统计发送数

            // 更新发送尾指针
            pt->tb_tail_send++;

#if 1
            // 如果不检查ACK,取消确认功能，不能投入SOE通讯续传和SOE断电续传。
            if (tRunPara.w104K == 0)
            {
                pt->tb_tail_ack = pt->tb_tail_send;
            }
#endif
        }
    }
}

static int IEC104_Ack(IEC104_DEF *pt104)
{
    s16 i, n;
    u16 ack_new, ack_old;
    iec_tbuf_t *pt;

#if 1
    // 如果系统不能检查ACK，就不能正确的进行ACK确认，直接返回。
    if (tRunPara.w104K == 0)
    {
        return 0;
    }
#endif

    // ACK序号必须在pt104->SendNum之前。
    // 如果ack序号大于发送序号，出错，主动关闭
    n = pt104->SendNum.ss - pt104->AckNum.ss;
    if (n < 0) // 根据C语言算法，此差值判断在两个值距离小于32768时有效
    {
        char log_info[128];
        IEC104_printf("IEC104(%d) Reset: 报文接收帧号错误(AckNum=%d,SendNum=%d)!\r\n", pt104->chnl, pt104->AckNum.ss, pt104->SendNum.ss);

        sprintf(log_info, "IEC104(%d):Message receiving frame number error(AckNum=%d,SendNum=%d)", pt104->chnl + 1, pt104->AckNum.ss, pt104->SendNum.ss);
        load_hs_log_rcd(TYPE_COMM_ERR, true, NULL, log_info, 1);
        log_flag.com_err[pt104->chnl] = true;

        return -1;
    }

    // 循环搜索所有没有确认的帧
    ack_old = g_soe_queue.tail_ack[pt104->chnl].n;
    ack_new = ack_old;
    for (i = 0; i < 2; i++)
    {
        pt = &pt104->TxBuf[i];
        while (pt->tb_tail_ack != pt->tb_tail_send)
        {
            n = pt104->AckNum.ss - pt->tb_info[pt->tb_tail_ack].tb_SendNum;
            if (n >= 0)
            {
                // 如果是SOE报文，需确认SOE缓冲池中SOE.
                if (pt->tb_info[pt->tb_tail_ack].frm_attr & FRAME_I_SOE)
                {
                    ack_new = pt->tb_info[pt->tb_tail_ack].soe_tail_send;
                    soe_ack(pt104->chnl, ack_new);
                }

                // 更新tail_ack
                pt->tb_tail_ack++;
            }
            else
            {
                break;
            }
        }
    }

#if 0
	if(ack_new != ack_old)
	{
		sbi_t cnt_send,cnt_remain;
		cnt_send.n = ack_new - ack_old;
		cnt_remain.n = g_soe_queue.tail_send[pt104->chnl].n - g_soe_queue.tail_ack[pt104->chnl].n;
		IEC104_printf("IEC104_Ack:cnt_send=%d,cnt_remain=%d,head=%d,send=%d,ack=%d.\r\n",
			cnt_send.n,cnt_remain.n,g_soe_queue.head.n,g_soe_queue.tail_send[pt104->chnl].n,g_soe_queue.tail_ack[pt104->chnl].n);
	}
#endif

    // K值可能发生变化，尝试发送报文
    IEC104_Send_Polling(pt104);

    return 0;
}

// 发送带soe_tail_send指针
static void IEC104_Send_sts(IEC104_DEF *pt104, UINT frm_attr, UINT len, u16 soe_tail_send)
{
    u16 head;
    iec_tbuf_t *pt;

    // 检查状态
    if (pt104->state == 0)
    {
        return;
    }

    // 检查长度，由于串口BUF只有255长，所以是255.
    len += 6;
    if (len > 255)
    {
        char log_info[128];
        IEC104_printf("IEC104(%d) IEC104_AddToBuf: 帧太长(len=%d)!\r\n", pt104->chnl, len);

        sprintf(log_info, "IEC104(%d):The frame is too long(len=%d)", pt104->chnl + 1, len);
        load_hs_log_rcd(TYPE_COMM_ERR, true, NULL, log_info, 1);
        log_flag.com_err[pt104->chnl] = true;

        return;
    }

    pt = (frm_attr & FRAME_I_PRIOR_LOW) ? &pt104->TxBuf[1] : &pt104->TxBuf[0];

    // 保存数据
    head = IEC104_GetOneBuf(pt);
    pt->tb_info[head].frm_attr = frm_attr;
    pt->tb_info[head].soe_tail_send = g_soe_queue.tail_send[pt104->chnl].n;
    pt->tb_data[head][0] = len;
    memcpy(&pt->tb_data[head][1], pt104->arrSendBuf, len);

    // 直接尝试发送报文
    IEC104_Send_Polling(pt104);

    // 复位T3定时器(测试帧超时)
    pt104->us0_test = ustimer_get_origin();
}

static void IEC104_Send(IEC104_DEF *pt104, UINT frm_attr, UINT len)
{
    IEC104_Send_sts(pt104, frm_attr, len, 0);
}

void IEC104_SM2Send(IEC104_DEF *pt104)
{
    u16 head;
    iec_tbuf_t *pt = &pt104->TxBuf[0];
    int len = pt104->arrSendBuf[0];

    if (pt104->type != IEC104_TYPE_RS) // 非串口以太网
    {
        net_104_send(pt104->cNetIndex, &pt104->arrSendBuf[1], len);
        IEC104_UnPackFrame(pt104, pt104->arrSendBuf, 2);
        s_stat_tx_frame(pt104->chnl);
        s_stat_tx(pt104->chnl, len); // 统计发送数
    }
    else
    {
        // 保存数据
        head = IEC104_GetOneBuf(pt);
        pt->tb_info[head].frm_attr = FRAME_SM2;
        pt->tb_data[head][0] = len;
        memcpy(&pt->tb_data[head][1], &pt104->arrSendBuf[1], len);
    }
}

/**************************************************************************
函数名称：IEC104_Echo
函数版本：1.00
作者：
创建日期：2007.9.1
函数功能说明：IEC104应答帧响应
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/
void IEC104_Echo_US(IEC104_DEF *pt104, BYTE frametype)
{
    BYTE *pd = pt104->arrSendBuf;
    *pd++ = 0x68;
    *pd++ = 4;
    *pd++ = frametype;
    *pd++ = 0;
    if (frametype == FRAME_S)
    {
        CopySwap(pd, pt104->RecvNum.tt, 2, true); // 接收序列号
        *pd = (*pd) & 0xfe;
        pd += 2;
        pt104->AckRecvNum = pt104->RecvNum.ss;
    }
    else
    {
        *pd++ = 0;
        *pd++ = 0;
    }

    if (pt104->type != IEC104_TYPE_RS) // 以太网，直接发送
    {
        net_104_send(pt104->cNetIndex, pt104->arrSendBuf, 6);
        IEC104_UnPackFrame(pt104, pt104->arrSendBuf, 1);
        s_stat_tx_frame(pt104->chnl);
        s_stat_tx(pt104->chnl, 6); // 统计发送数
    }
    else // 串口以太网，将数据放入缓冲器
    {
        IEC104_Send(pt104, frametype, 0);
    }
}

static void IEC104_Echo_I(IEC104_DEF *pt104, BYTE cot, bool brst)
{
    BYTE *ps = pt104->arrRecvBuf;
    BYTE *pd = pt104->arrSendBuf;
    int len;

    len = ps[1] + 2;
    memcpy(pd, ps, len);
    pd[8] = cot;
    pd[10] = (BYTE)tRunPara.byAddr;        // 应用服务数据单元地址低
    pd[11] = (BYTE)(tRunPara.byAddr >> 8); // 应用服务数据单元地址高

#if defined GD_AREA_ZHONGSHAN || defined GD_AREA_ZHONGSHAN_2020
    if ((cot & 0x40) && brst) // 否定应答
    {
        IEC104_ActiveClose(pt104);
    }
    else
    {
        IEC104_Send(pt104, FRAME_I, len - 6);
    }

#else
    IEC104_Send(pt104, FRAME_I, len - 6);

#endif
}

static void IEC104_Echo_I_Direct(IEC104_DEF *pt104, BYTE cot)
{
    BYTE *ps = pt104->arrRecvBuf;
    BYTE *pd = pt104->arrSendBuf;
    int len;

    len = ps[1] + 2;
    memcpy(pd, ps, len);

    CopySwap(&pd[2], pt104->SendNum.tt, 2, true); // 发送序列号
    pd[2] &= 0xfe;

    CopySwap(&pd[4], pt104->RecvNum.tt, 2, true); // 接收序列号
    pd[4] &= 0xfe;

    pt104->AckRecvNum = pt104->RecvNum.ss;
    // COT
    pd[8] = cot;

    // 地址
    pd[10] = (BYTE)tRunPara.byAddr;        // 应用服务数据单元地址低
    pd[11] = (BYTE)(tRunPara.byAddr >> 8); // 应用服务数据单元地址高

    if (pt104->type != IEC104_TYPE_RS) // 以太网，直接发送
    {
        net_104_send(pt104->cNetIndex, pt104->arrSendBuf, len);
        IEC104_UnPackFrame(pt104, pt104->arrSendBuf, 1);
        s_stat_tx_frame(pt104->chnl);
        s_stat_tx(pt104->chnl, len); // 统计发送数
    }
    else // 串口以太网，将数据放入缓冲器
    {
        IEC104_Send(pt104, FRAME_I, len - 6);
    }
}

/**************************************************************************
函数名称：IEC104_Timer
函数版本：1.00
作者：
创建日期：2007.9.1
函数功能说明：定时处理函数，判断socekt超时
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/
static void IEC104_Timer(IEC104_DEF *pt104)
{
    int i;
    iec_tbuf_t *pt;

#if 0
	if(pt104->secs > 10)
	{
		IEC104_printf("IEC104(%d) Reset: 测试10秒关闭!\r\n",pt104->chnl);
		IEC104_ActiveClose(pt104);
		return;
	}
#endif

    // 检查I帧超时
    if (tRunPara.w104K)
    {
        for (i = 0; i < 2; i++)
        {
            pt = &pt104->TxBuf[i];
            while (pt->tb_tail_ack != pt->tb_tail_send)
            {
                if ((pt->tb_info[pt->tb_tail_ack].frm_attr & 0xff) == FRAME_I)
                {
                    if (ustimer_get_duration(pt->tb_info[pt->tb_tail_ack].us0) > (tRunPara.w104AckTime * USTIMER_SEC))
                    {
                        char log_info[128];

                        IEC104_printf("IEC104(%d) Reset: 发送I帧确认超时!\r\n", pt104->chnl);
                        IEC104_ActiveClose(pt104);

                        sprintf(log_info, "IEC104(%d):Send I frame confirmation timeout", pt104->chnl + 1);
                        load_hs_log_rcd(TYPE_COMM_ERR, true, NULL, log_info, 1);
                        log_flag.com_err[pt104->chnl] = true;

                        return;
                    }
                    break;
                }
                else
                {

                    // 不是I帧，不需要确认(在串口模式下，发送队列中有U帧)
                    pt->tb_tail_ack++;
                }
            }
        }
    }

    // 检查测试帧超时
    if (pt104->bStartTest) // 启动了
    {
        if (ustimer_get_duration(pt104->us0_test_wait) > (tRunPara.w104AckTime * USTIMER_SEC))
        {
            char log_info[128];
            // 测试帧没有及时返回，主动关闭连接
            IEC104_printf("IEC104(%d) 测试帧超时!\r\n", pt104->chnl);
            IEC104_ActiveClose(pt104);

            sprintf(log_info, "IEC104(%d):Test frame timeout", pt104->chnl + 1);
            load_hs_log_rcd(TYPE_COMM_ERR, true, NULL, log_info, 1);
            log_flag.com_err[pt104->chnl] = true;

            return;
        }
    }
    else if (ustimer_get_duration(pt104->us0_test) > (tRunPara.w104TestTime * USTIMER_SEC)) // 超时测试
    {
        if (pt104->state == IEC104_ST_STARTED) // 测试帧在收到启动命令后发送
        {
            // 发送测试帧
            IEC104_Echo_US(pt104, FRAME_U_TEST);
            pt104->bStartTest = true;
        }
        pt104->us0_test = ustimer_get_origin();
        pt104->us0_test_wait = ustimer_get_origin();
    }

    IEC104_SegmentContinue(pt104);
    if (pt104->tfile.bFiletransing)
    {
        if (ustimer_get_duration(pt104->tfile.us0_file_trans) > (tRunPara.w104AckTime * USTIMER_SEC * 5))
            IEC104_FreeFile(pt104);
    }

    // 新国网标准文件传输处理
    if (pt104->tf.bTransing)
    {
        // 检查发送队列空间,空间应大于1/4，防止发送缓冲区满
        if (IEC104_BufFree(&pt104->TxBuf[1]) >= (IEC_TBUF_NUM >> 2))
        {
            iec_readfile_send(pt104, true);
        }
    }
    if (pt104->bEchosecmd5)
    {
        u8 md5buf[24];
        u16 len;
        len = sec_md5_echo(md5buf);
        net_104_send_ext(pt104->cNetIndex, md5buf, len);
        pt104->bEchosecmd5 = false;
    }
    if (pt104->tf.bTransing || pt104->tf.bdatTraned)
    {
        if (ustimer_get_duration(pt104->tf.us0_file_trans) > (tRunPara.w104AckTime * USTIMER_SEC * 5))
        {
#ifdef RCD_STRAN_S
            log_str_time(LOG_OPERATE, "读文件传输超时!!!!!!!", 0, 1);
#endif
            iec_freefile(&pt104->tf);
            pt104->tf.bTransing = false;
            pt104->tf.bdatTraned = false;
        }
    }

    if (pt104->tf.bdatwriting) // 文件启动了传输，在3次重发间隔内，未有文件内容传输更新，释放已申请的写文件内存
    {
        if (ustimer_get_duration(pt104->tf.us0_file_write) > ((tRunPara.w104AckTime * USTIMER_SEC * 5)))
        {
            if (!pt104->tf.writebuf)
            {
                rt_free(&pt104->tf.writebuf);
                pt104->tf.writebuf = NULL;
            }
            pt104->tf.bdatwriting = false;
        }
    }

    if (pt104->tf.bUpdateReset) // 文件启动了传输，在3次重发间隔内，未有文件内容传输更新，释放已申请的写文件内存
    {
        if (ustimer_get_duration(pt104->tf.us0_updatereset) > (USTIMER_SEC * 2))
        {
            rt_printf("104远程升级，装置复位\r\n");
            pt104->tf.bUpdateReset = false;
            watchdog_reset_cpu(2); // 装置复位
        }
    }
    if (pt104->tr.bpreset) // 参数预置
    {
        if (ustimer_get_duration(pt104->tr.us0_preset) > (tRunPara.dSM2Time * USTIMER_SEC))
        {
            rt_printf("104预置参数超时清除\r\n");
            pt104->tr.bpreset = false;
            for (i = 0; i < RMT_SET_NUMBER; i++)
            {
                pt104->tr.di[i] = 0;
            }
        }
    }
}

/**************************************************************************
函数名称：IEC104_InitOK
函数版本：1.00
作者：
创建日期：2007.9.1
函数功能说明：子站初始化完毕
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/

static void IEC104_InitOK(IEC104_DEF *pt104)
{
    BYTE *pd = &pt104->arrSendBuf[6]; // 从第7个字节开始

    *pd++ = 70;                           // 总召唤确认帧	  1
    *pd++ = 1;                            // 可变结构限定词
    *pd++ = IEC_COT_INIT;                 // 传送原因：被初始化
    *pd++ = 0;                            // 传送原因：时间确认
    *pd++ = (BYTE)tRunPara.byAddr;        // 应用服务数据单元地址
    *pd++ = (BYTE)(tRunPara.byAddr >> 8); // 应用服务数据单元地址
    *pd++ = 0;                            // 信息体地址L
    *pd++ = 0;                            // 信息体地址H
    *pd++ = 0;                            // 信息体地址H
    if (pt104->bInitCOI)
    {
        *pd++ = 2; // 远方复位
    }
    else
    {
        *pd++ = 0; // 当地电源合上
    }
    pt104->bInitCOI = true;

    IEC104_Send(pt104, FRAME_I, 10);
}

/**************************************************************************
函数名称：IEC104_SetTime
函数版本：1.00
作者：
创建日期：2007.9.1
函数功能说明：时间同步
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/

static void IEC104_SetTime(IEC104_DEF *pt104, BYTE *ps, BYTE scot)
{
    TIME ct;
    int check_time = false;
    u8 cot;
    struct timespec ts;
#ifdef IEC_SETTIME_ANS_WEK // 东莞局要求返回设置后的时间
    u8 week;
#endif
    BYTE *pd = &pt104->arrSendBuf[6]; // 从第7个字节开始

    if (scot == IEC_COT_ACT) // 设置系统时间
    {
        ct.ms = ps[0] + ((WORD)ps[1] << 8);
        ct.min = (ps[2] & 0x3F);
        ct.hour = (ps[3] & 0x1F);
        ct.day = (ps[4] & 0x1F);
        ct.month = (ps[5] & 0x0F);
        ct.year = (ps[6] & 0x7F);

        check_time = check_rtc(&ct);
        if (check_time)
        {
            sys_time_set_rmt(&ct);
        }
    }
    else // 时钟读取命令上送终端时间，设置命令上送下发命令时间
    {
        clk_time_get(&ts);
        timespec_to_rtc(ts, &ct, 1);
    }

    if (scot == IEC_COT_REQ)
    {
        cot = 0x05;
    }
    else
    {
        cot = check_time ? 0x07 : 0x47; // 对时内容非法，即将传送原因的P/N位置为1
    }
#ifdef IEC_SETTIME_ANS_WEK // 东莞局要求返回设置后的时间
    ustimer_delay(1600);
    clk_time_get(&ts);
    timespec_to_rtc(ts, &ct, 1);
    // 得到星期
    rtc_to_timespec(&ct, &ts);
    week = WEEK_DAY(ts.tv_sec);
#endif
    *pd++ = 103;                          // 时钟同步
    *pd++ = 1;                            // 可变结构限定词
    *pd++ = cot;                          // 传送原因：被初始化
    *pd++ = 0;                            // 传送原因：时间确认
    *pd++ = (BYTE)tRunPara.byAddr;        // 应用服务数据单元地址
    *pd++ = (BYTE)(tRunPara.byAddr >> 8); // 应用服务数据单元地址
    *pd++ = 0;                            // 信息体地址L
    *pd++ = 0;                            // 信息体地址H
    *pd++ = 0;                            // 信息体地址H
#if defined GD_AREA_ZHONGSHAN || defined GD_AREA_ZHONGSHAN_2020
    if (scot == IEC_COT_ACT)
    {
        *pd++ = ps[0]; // MsL
        *pd++ = ps[1]; // MsH
        *pd++ = ps[2]; // Min
        *pd++ = ps[3]; // hour
        *pd++ = ps[4]; // Day
        *pd++ = ps[5]; // month
        *pd++ = ps[6]; // year
    }
    else
    {
        *pd++ = (u8)ct.ms;        // MsL
        *pd++ = (u8)(ct.ms >> 8); // MsH
        *pd++ = ct.min;           // Min
        *pd++ = ct.hour;          // hour
        *pd++ = ct.day;           // Day
        *pd++ = ct.month;         // month
        *pd++ = ct.year;          // year
    }
#else
    *pd++ = (u8)ct.ms;        // MsL
    *pd++ = (u8)(ct.ms >> 8); // MsH
    *pd++ = ct.min;           // Min
    *pd++ = ct.hour;          // hour
#ifdef IEC_SETTIME_ANS_WEK
    *pd++ = ((week << 5) | ct.day); // Day
#else
    *pd++ = ct.day; // Day
#endif
    *pd++ = ct.month; // month
    *pd++ = ct.year;  // year
#endif
    IEC104_Send(pt104, FRAME_I, 16);
}
/**************************************************************************
函数名称：IEC104_CallAll
函数版本：1.00
作者：
创建日期：2007.9.1
函数功能说明：响应总查询
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/
static void IEC104_CallAll(IEC104_DEF *pt104, BYTE QOI)
{
    int num;
    BYTE *pd;
    int i, begin, end;
    WORD cp = 0;
    long lmeaval = 0;

    // 总召唤确认帧
    IEC104_Echo_I(pt104, IEC_COT_ACTCON, false);

    // 遥测帧
    if ((QOI == IEC_QOI_CALL_ALL_GROUP) || (QOI >= IEC_QOI_CALL_YC_BEGIN && QOI <= IEC_QOI_CALL_YC_END))
    {
        int maxsendnum;
        int ycvalue;
        BYTE frametype;
        union
        {

            float ff;
            BYTE tt[4];
        } ff;
        if (pRunSet->bDIContinue) // 点号连续上送
        {
            pd = &pt104->arrSendBuf[15];
            if (tRunPara.bYcFloat)
                maxsendnum = 40; // 浮点值字数 4+1
            else
                maxsendnum = 70; // 非 浮点值字数 2+1
        }
        else
        {
            pd = &pt104->arrSendBuf[12];
            if (tRunPara.bYcFloat)
                maxsendnum = 25; // 浮点值字数 4+1+3  浮点4字节，描述符1字节，信息体3字节
            else
                maxsendnum = 35; // 非 浮点值字数 2+1+3
        }

        if (tRunPara.bYcBDH) // 标度化值
        {
            frametype = 11; // 带品质描述的遥测帧  1
        }
        else if (tRunPara.bYcFloat) // 浮点值
        {
            frametype = 13; // 带品质描述的遥测帧  1
        }
        else
        {
            frametype = 9; // 带品质描述的遥测帧  1
        }

        // 确认起止点号
        if (QOI == IEC_QOI_CALL_ALL_GROUP || pRunSet->dGroupYcSize == 0)
        {
            begin = 0;
            end = g_table_head->ac_num;
        }
        else if (pRunSet->dGroupYcSize)
        {
            begin = (QOI - IEC_QOI_CALL_YC_BEGIN) * pRunSet->dGroupYcSize;
            end = begin + pRunSet->dGroupYcSize;
            if (end > g_table_head->ac_num)
            {
                end = g_table_head->ac_num;
            }
        }

        num = 0;
        if (g_ac_table)
        {
            cp = g_ac_table[begin].cp;
        }
        for (i = begin; i < end; i++)
        {
            BYTE QDS = 0; // 品质描述， 默认为零
            u8 link_qds = 0;
            BYTE no = g_ac_table[i].indexno;
            if (no > 0)
            {
                DWORD dwMax;
                DWORD dwDeadVal;
                float rate;
                float f_65536 = 65536.0;
                no -= 1;
                rate = (float)g_ac_table[i].rate / 65536.0;
                // dwMax=(DWORD)g_ac_table[i].normal;
                dwMax = (tRunPara.bDeadType == true) ? (DWORD)g_ac_table[i].normal : _AbsL(pt104->yc_save[i]);
                if (dwMax == 0) // 防止额定或者前一次保存值为0
                    dwMax = 1;
                dwDeadVal = _Mul_Div_U(g_ac_table[i].dead_value, dwMax, 6553600);
                if (dwDeadVal == 0)
                    dwDeadVal = 1;
                if (dwMax == 0)
                    f_65536 = 1.0;
                lmeaval = GetRmtMeaVal(g_ac_table[i].owner, no, &link_qds);
                ff.ff = ((float)lmeaval) / f_65536 * rate; // 转为浮点数

#ifdef VOLT_ADAPTIVE_FACTOR
                if (pRunSet->bTT_AdaptiveFactor)
                {
                    if (0 == g_ac_table[i].owner)
                    {
                        if ((no <= PUB_AC_UCA1) && (no >= PUB_AC_UA1))
                        {
                            ff.ff = ((float)lmeaval) / f_65536 * 10 / pRunSet->a_pt_two;
                        }
                        else if ((no <= PUB_AC_UCA2) && (no >= PUB_AC_UA2))
                        {
                            ff.ff = ((float)lmeaval) / f_65536 * 10 / pRunSet->b_pt_two;
                        }
                    }
                }
#endif

                ycvalue = (int)rt_round(ff.ff);
                if (tRunPara.bYcFloat)
                {
                    if (_AbsL(lmeaval) > (dwMax * 10)) // 大于额定值的10倍*65536
                    {
                        if (dwMax > 0)
                            QDS |= 0x01; // 遥测溢出
                    }
                }
                else
                {
                    if (ycvalue >= 0)
                    {
                        if (ycvalue > 32767)
                        {
                            ycvalue = 32767;
                            QDS |= 0x01; // 遥测溢出
                        }
                    }
                    else
                    {
                        if (ycvalue < (-32768))
                        {
                            ycvalue = -32768;
                            QDS |= 0x01; // 遥测溢出
                        }
                    }
                }
            }
            else // 备用点号，数值上送0
            {
                ycvalue = 0;
                ff.ff = 0;
            }

            if (g_run_stu.bToolRmtTest || g_run_stu.bHmiRmtTest) // 在测试模式下，置无效状态
            {
                if (pRunSet->bTT_RmtTest)
                    QDS |= 0x80;
            }
            if (i < MAX_YC_NUMBER)
                pt104->yc_save[i] = lmeaval;
            if (!pRunSet->bDIContinue) //
            {
                cp = g_ac_table[i].cp;
                *pd++ = (BYTE)cp;
                *pd++ = (BYTE)(cp >> 8);
                *pd++ = 0; // 信息体地址H
            }
            if (tRunPara.bYcFloat) // 浮点值上送
            {
                pd += CopySwap(pd, ff.tt, sizeof(ff.tt), true);
            }
            else
            {
                *pd++ = (BYTE)(BYTE)(ycvalue);
                *pd++ = (BYTE)(BYTE)(ycvalue >> 8);
            }
#if !defined FUNC_JX_YC_SIQ00
            if (g_run_stu.bjx)
            {
                QDS |= 0x80; // 带品质描述，有效 <1>：=无效
            }
#endif
#ifdef IEC_QDS_HAVE
            QDS |= link_qds;
#endif

            *pd++ = QDS; // 品质描述

            // 数量达到最大值或是最后一个,发送
            num++;
            if ((num > maxsendnum) || (i == (end - 1))) // 超过一帧数据  一帧最大数据66
            {
                pd = &pt104->arrSendBuf[6];
                *pd++ = frametype;        // 带品质描述的遥测帧  1
                if (pRunSet->bDIContinue) // 点号连续上送
                {
                    *pd++ = (num | 0x80);                 // 可变结构限定词
                    *pd++ = QOI;                          // 传送原因：总召唤
                    *pd++ = 0;                            // 传送原因：总召唤
                    *pd++ = (BYTE)tRunPara.byAddr;        // 应用服务数据单元地址
                    *pd++ = (BYTE)(tRunPara.byAddr >> 8); // 应用服务数据单元地址 6
                    *pd++ = (BYTE)cp;
                    *pd++ = (BYTE)(cp >> 8);
                    *pd++ = 0; // 信息体地址H
                    cp += num;
                    num = tRunPara.bYcFloat ? (num * 5 + 9) : (num * 3 + 9);
                    pd = &pt104->arrSendBuf[15];
                }
                else
                {
                    *pd++ = (num);                        // 可变结构限定词
                    *pd++ = QOI;                          // 传送原因：总召唤
                    *pd++ = 0;                            // 传送原因：总召唤
                    *pd++ = (BYTE)tRunPara.byAddr;        // 应用服务数据单元地址
                    *pd++ = (BYTE)(tRunPara.byAddr >> 8); // 应用服务数据单元地址 6
                    num = tRunPara.bYcFloat ? (num * 8 + 6) : (num * 6 + 6);
                    pd = &pt104->arrSendBuf[12];
                }

                if (pt104->bSendChange)
                {
                    IEC104_Send(pt104, FRAME_I_PRIOR_LOW, num);
                }
                else
                {
                    IEC104_Send(pt104, FRAME_I, num);
                }
                num = 0;
            }
        }
    }

    // 事件帧
    if ((QOI == IEC_QOI_CALL_ALL_GROUP) || (QOI >= IEC_QOI_CALL_YX_BEGIN && QOI <= IEC_QOI_CALL_YX_END))
    {
        BYTE frameType, SIQ;
        int maxsendnum;
        u8 yxtype = 0;

        // 确定最大发送数量和起始地址
        if (pRunSet->bDIContinue)
        {
            pd = &pt104->arrSendBuf[15];
            maxsendnum = 120; // ngd最高位需置1，因此最大遥信个数不能超过128
        }
        else
        {
            pd = &pt104->arrSendBuf[12];
            maxsendnum = 50; // 1个字节遥信+3个字节信息体地址
        }

        // 确定报文类型，单点(1)或双点(3)
        frameType = tRunPara.bDPI ? 3 : 1;

        // 确定起止点号
        if (QOI == IEC_QOI_CALL_ALL_GROUP || pRunSet->dGroupYxSize == 0)
        {
            begin = 0;
            end = g_table_head->di_num;
        }
        else
        {
            begin = (QOI - IEC_QOI_CALL_YX_BEGIN) * pRunSet->dGroupYxSize;
            end = begin + pRunSet->dGroupYxSize;
            if (end > g_table_head->di_num)
            {
                end = g_table_head->di_num;
            }
        }

        // 循环发送所有遥信通讯点
        num = 0;
        if (g_di_table)
        {
            cp = g_di_table[begin].cp;
            yxtype = tbl_get_dpi(begin);
        }

        for (i = begin; i < end; i++)
        {
            if (tRunPara.bSDPI) // 单双点分别上送
            {
                u8 type = tbl_get_dpi(i);
                if (yxtype != type && num > 0)
                {
                    pd = &pt104->arrSendBuf[6];
                    *pd++ = yxtype ? 3 : 1;
                    ;                         // 带品质描述的遥信帧  1
                    if (pRunSet->bDIContinue) // 点号连续上送
                    {
                        *pd++ = (num | 0x80);                 // 可变结构限定词
                        *pd++ = QOI;                          // 传送原因：总召唤
                        *pd++ = 0;                            // 传送原因：总召唤
                        *pd++ = (BYTE)tRunPara.byAddr;        // 应用服务数据单元地址
                        *pd++ = (BYTE)(tRunPara.byAddr >> 8); // 应用服务数据单元地址 6
                        *pd++ = (BYTE)cp;
                        *pd++ = (BYTE)(cp >> 8);

                        *pd++ = 0; // 信息体地址H
                        pd = &pt104->arrSendBuf[15];
                        cp += num;
                        num = num + 9;
                    }
                    else
                    {
                        *pd++ = (num);                        // 可变结构限定词
                        *pd++ = QOI;                          // 传送原因：总召唤
                        *pd++ = 0;                            // 传送原因：总召唤
                        *pd++ = (BYTE)tRunPara.byAddr;        // 应用服务数据单元地址
                        *pd++ = (BYTE)(tRunPara.byAddr >> 8); // 应用服务数据单元地址 6
                        pd = &pt104->arrSendBuf[12];
                        num = num * 4 + 6;
                    }
                    if (pt104->bSendChange)
                    {
                        IEC104_Send(pt104, FRAME_I_PRIOR_LOW | FRAME_I_COS, num);
                    }
                    else
                    {
                        IEC104_Send(pt104, FRAME_I, num);
                    }
                    num = 0;
                    yxtype = type;
                }
                // 填写SIQ
                frameType = type ? 3 : 1;
                SIQ = tbl_get_yx(i, type);
            }
            else
            {
                // 填写SIQ
                SIQ = tbl_get_yx(i, tRunPara.bDPI);
            }
#if !defined FUNC_JX_YX_BEFORE
            if (g_run_stu.bjx)
            {
                SIQ |= 0x80; // 带品质描述，有效 <1>：=无效
            }
#endif
            // 填写地址
            if (!pRunSet->bDIContinue)
            {
                cp = g_di_table[i].cp;
                *pd++ = (BYTE)cp;
                *pd++ = (BYTE)(cp >> 8);
                *pd++ = 0;
            }

            if (g_run_stu.bToolRmtTest || g_run_stu.bHmiRmtTest) // 测试模式，遥信置为无效
            {
                if (pRunSet->bTT_RmtTest)
                    SIQ |= 0x80;
            }
            *pd++ = SIQ; // 事件值	SIQ

            // 数量达到最大值或是最后一个,发送
            num++;
            if ((num >= maxsendnum) || (i == (end - 1)))
            {
                pd = &pt104->arrSendBuf[6];
                *pd++ = frameType;        // 带品质描述的遥信帧  1
                if (pRunSet->bDIContinue) // 点号连续上送
                {
                    *pd++ = (num | 0x80);                 // 可变结构限定词
                    *pd++ = QOI;                          // 传送原因：总召唤
                    *pd++ = 0;                            // 传送原因：总召唤
                    *pd++ = (BYTE)tRunPara.byAddr;        // 应用服务数据单元地址
                    *pd++ = (BYTE)(tRunPara.byAddr >> 8); // 应用服务数据单元地址 6
                    *pd++ = (BYTE)cp;
                    *pd++ = (BYTE)(cp >> 8);
                    *pd++ = 0; // 信息体地址H
                    pd = &pt104->arrSendBuf[15];
                    cp += num;
                    num = num + 9;
                }
                else
                {
                    *pd++ = (num);                        // 可变结构限定词
                    *pd++ = QOI;                          // 传送原因：总召唤
                    *pd++ = 0;                            // 传送原因：总召唤
                    *pd++ = (BYTE)tRunPara.byAddr;        // 应用服务数据单元地址
                    *pd++ = (BYTE)(tRunPara.byAddr >> 8); // 应用服务数据单元地址 6
                    pd = &pt104->arrSendBuf[12];
                    num = num * 4 + 6;
                }

                if (pt104->bSendChange)
                {
                    IEC104_Send(pt104, FRAME_I_PRIOR_LOW | FRAME_I_COS, num);
                }
                else
                {
                    IEC104_Send(pt104, FRAME_I, num);
                }
                num = 0;
            }
        }
    }

    // 总召唤结束帧
    pd = &pt104->arrSendBuf[6];
    *pd++ = 100;                          // 总召唤确认帧
    *pd++ = 1;                            // 可变结构限定词
    *pd++ = 10;                           // 传送原因：总召唤
    *pd++ = 0;                            // 传送原因：总召唤
    *pd++ = (BYTE)tRunPara.byAddr;        // 应用服务数据单元地址L
    *pd++ = (BYTE)(tRunPara.byAddr >> 8); // 应用服务数据单元地址H
    *pd++ = 0;                            // 信息体地址L
    *pd++ = 0;                            // 信息体地址H
    *pd++ = 0;                            // 信息体地址H
    *pd++ = QOI;                          // QOI

    if (pt104->bSendChange)
    {
        IEC104_Send(pt104, FRAME_I_PRIOR_LOW, 10);
    }
    else
    {
        IEC104_Send(pt104, FRAME_I, 10);
    }

    // 不允许通讯续传的情况下，第一次总召先清SOE队列，保证上传事件是总召后产生的，后续总召不清SOE队列
    if ((pRunSet->bTT_SoeResumeComm == 0) && (!pt104->bSendChange))
    {
        g_soe_queue.tail_send[pt104->chnl].n = g_soe_queue.head.n;
        g_soe_queue.tail_ack[pt104->chnl].n = g_soe_queue.tail_send[pt104->chnl].n;
    }

#ifdef FUN_SOE_DELAY_TIME
    if (pt104->bSendChange == false)
    {
        pt104->DTSendChange = dTCounter;
        pt104->bfirst_call = true;
    }
#endif
    // 置总召标志
    pt104->bSendChange = true;
}

static void IEC104_DDAll(IEC104_DEF *pt104, u8 QCC) // 确认帧
{
    u8 *pd;
    u8 cot; // 通用分类数据集数目
    u16 cp;
    int i, num;

    // 总召唤确认帧
    IEC104_Echo_I(pt104, IEC_COT_ACTCON, false);

    // 电度值
    if ((QCC == 1) || (QCC == 5))
    {
        // 初始数据
        num = 0;
        cp = g_dd_table[0].cp;
        if (QCC == 5)
            cot = 37; // 总召
        else
            cot = QCC + 37; // 召某一组
        pd = &pt104->arrSendBuf[15];
        for (i = 0; i < g_table_head->dd_num; i++)
        {
            int sw, no;
            float rate;
            union
            {
                float ff;
                u8 tt[4];
            } ff;
            sw = g_dd_table[i].owner;
            no = g_dd_table[i].indexno;
            if (no > 0)
            {
                rate = (float)g_dd_table[i].rate / 65536.0;
                ff.ff = GetRmtDdVal(sw, no - 1) * rate;
            }
            else
            {
                ff.ff = 0;
            }
            pd += CopySwap(pd, ff.tt, sizeof(ff.tt), true);

            *pd++ = 0; // QDS
            num++;
            // 发送一帧
            if (num > 30 || (i == g_table_head->dd_num - 1))
            {
                pd = &pt104->arrSendBuf[6];
                *pd++ = 206;                          // 带品质描述的遥测帧  1
                *pd++ = (num | 0x80);                 // 可变结构限定词
                *pd++ = cot;                          // 传送原因：总召唤
                *pd++ = 0;                            // 传送原因：总召唤
                *pd++ = (BYTE)tRunPara.byAddr;        // 应用服务数据单元地址
                *pd++ = (BYTE)(tRunPara.byAddr >> 8); // 应用服务数据单元地址 6
                *pd++ = (BYTE)cp;
                *pd++ = (BYTE)(cp >> 8);
                *pd++ = 0; // 信息体地址H
                IEC104_Send(pt104, FRAME_I_PRIOR_LOW, num * 5 + 9);
                pd = &pt104->arrSendBuf[15];
                cp += num;
                num = 0;
            }
        }
    }
    if (QCC == 0x45) // 主站扩展瞬时冻结电度命令
    {
        // rand_file_info.b_frz=true;
    }
    // 总召唤结束帧
    pd = &pt104->arrSendBuf[6];
    *pd++ = 101;                          // 总召唤确认帧
    *pd++ = 1;                            // 可变结构限定词
    *pd++ = IEC_COT_ACTTERM;              // 传送原因：总召唤
    *pd++ = 0;                            // 传送原因：总召唤
    *pd++ = (BYTE)tRunPara.byAddr;        // 应用服务数据单元地址L
    *pd++ = (BYTE)(tRunPara.byAddr >> 8); // 应用服务数据单元地址H
    *pd++ = 0;                            // 信息体地址L
    *pd++ = 0;                            // 信息体地址H
    *pd++ = 0;                            // 信息体地址H
    *pd++ = QCC;                          // QOI

    IEC104_Send(pt104, FRAME_I_PRIOR_LOW, 10);
}

/**************************************************************************
函数名称：IEC104_RmtCtrl
函数版本：1.00
作者：
创建日期：2007.9.1
函数功能说明：遥控处理
输入参数： 点号开始21 0b 00 82 （10-13）
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/
void IEC104_Echo_YK(IEC104_DEF *pt104, u16 cp, u8 ti, u8 cot, u8 v)
{
    BYTE *pd = &pt104->arrSendBuf[6];     // 从第7个字节开始
    *pd++ = ti;                           // 类型标识
    *pd++ = 1;                            // 可变结构限定词
    *pd++ = cot;                          // 传送原因：
    *pd++ = 0;                            // 传送原因：
    *pd++ = (BYTE)tRunPara.byAddr;        // 应用服务数据单元地址
    *pd++ = (BYTE)(tRunPara.byAddr >> 8); // 应用服务数据单元地址
    *pd++ = (BYTE)cp;                     // 信息体地址L
    *pd++ = (BYTE)(cp >> 8);              // 信息体地址H
    *pd++ = 0;                            // 信息体地址H
    *pd++ = v;                            // DCS
    IEC104_Send(pt104, FRAME_I, 10);
    pt104->bRmtSM2 = false; // 遥控执行完成，清除SM2标志，开放事件上传
}

static void IEC104_RmtCtrl(IEC104_DEF *pt104, BYTE *ps, BYTE frametype)
{
    BYTE cot, ykcot, ykvalue, yktype = 0, ykThz;
    WORD ykno;
    WORD yksave;
    int i, ret;
    u8 yk_cmd;
    bool bValidYk = false;

    ykcot = (ps[0] & 0x01f);
    ykvalue = ps[7];
    yk_cmd = ykvalue & 0x03;
    ykno = ps[4] + (WORD)ps[5] * 256;
    yksave = ykno;
    cot = IEC_COT_UN_OA | IEC_COT_PN;
    if (frametype == 45) // 单点遥控，转为双点值，统一处理
    {
        ykvalue += 1;
    }
    for (i = 0; i < g_table_head->do_num; i++) // 查找遥控转发表，看是否有有效的遥控点
    {
        if (ykno != g_do_table[i].cp) // 遥控点号对应
        {
            continue;
        }

        // 如果配置了级联通道，转发
        if (g_do_table[i].link_ch)
        {
            if (lnk_master_yk(&g_do_table[i], frametype, ps[0], ps[7]) == 0)
            {
                pt104->lnk_yk_send_flag |= (1 << g_do_table[i].owner);
                pt104->us0_lnk_yk = ustimer_get_origin();

                // 先回S帧，告诉主站已收到
                IEC104_Echo_US(pt104, FRAME_S);
            }
            else
            {
                cot = (ykcot == IEC_COT_ACT) ? IEC_COT_ACTCON : IEC_COT_DEACTCON;
                cot |= IEC_COT_PN;
                IEC104_Echo_I(pt104, cot, false);
            }
            cot = ps[0];
            if (ykvalue & 0x80)
            {
                yktype = YK_TYPE_SEL;
            }
            else
            {
                yktype = YK_TYPE_EXE;
            }

            if (ykcot == IEC_COT_DEACT) // 遥控撤销
            {
                yktype = YK_TYPE_CANCEL;
                cot = IEC_COT_DEACTCON;
            }

            refresh_co_file(true, frametype, yktype, ykno, cot, yk_cmd);
            return;
        }
        // 本装置遥控
        else
        {
            bValidYk = true;
            cot = IEC_COT_ACTCON;
            if (ykvalue & 0x80)
            {
                yktype = YK_TYPE_SEL;
            }
            else
            {
                yktype = YK_TYPE_EXE;
            }

            if (ykcot == IEC_COT_DEACT) // 遥控撤销
            {
                yktype = YK_TYPE_CANCEL;
                cot = IEC_COT_DEACTCON;
            }
            if ((ykvalue & 0x03) == 2)
            {
                ykThz = YK_VAL_HZ;
            }
            else
            {
                ykThz = YK_VAL_TZ;
            }
            ret = RemoteCtrl(yktype, i, ykThz, MASTER_104 + pt104->chnl);
            if (ret != 0)
            {
                cot = IEC_COT_ACTCON | IEC_COT_PN; // 否定应答
            }

            refresh_co_file(true, frametype, yktype, ykno, cot, yk_cmd);
            break;
        }
    }

    // 没有找到对应遥控点
    if (i == g_table_head->do_num)
    {
        char buf[128];
        sprintf(buf, "遥控:转发点表未找到对应点(ykno=0x%04x,yktype=%d,ykvalue=%d)", ykno, yktype, ykvalue);
        log_str_time(LOG_OPERATE, buf, 0, 0);
        rt_printf_time("%s\r\n", buf);
    }

    // 必须有对应点号
    if (i != g_table_head->do_num)
    {
        // 终端发出遥控信息:选择确认，执行确认
        refresh_co_file(false, frametype, yktype, ykno, cot, yk_cmd);
    }

    pt104->bRmtSM2 = false; // 遥控执行完成，清除SM2标志，开放事件上传

    // 应答报文
    IEC104_Echo_I(pt104, cot, false);

    if ((yktype == YK_TYPE_EXE) && (cot == IEC_COT_ACTCON))
    {
        // 执行完毕应答
        IEC104_Echo_YK(pt104, yksave, frametype, IEC_COT_ACTTERM, ps[7]);

        refresh_co_file(false, frametype, yktype, ykno, IEC_COT_ACTTERM, yk_cmd);
    }
}

/**************************************************************************
函数名称：IEC104_SendEvent
函数版本：1.00
作者：
创建日期：2007.9.1
函数功能说明：自动发送事件及变位信息，
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/
#define MAX_SOE_PER_FRAME 16
u32 IEC104_SendEvent(IEC104_DEF *pt104, int is_send_cos) /*104规约自动处理,比如收集变位及变化的遥测*/
{
    BYTE arrCos[200], arrSoe[200];
    BYTE *pd, vsq;
    u16 head, soe_no, arg_index;
    u32 cnt;
    EVENT_STRUCT event;
    bool bFault;
    FAULT_PARA_BUF *tf = &pt104->tfault;
    // 主动上送条件:
    // 1、是IEC104_ST_STARTED状态
    // 2、没有在处理加密遥控报文
    if ((pt104->state != IEC104_ST_STARTED) || pt104->bRmtSM2)
    {
        return 0;
    }

    // 不允许通讯续传的情况下，总召后才允许上送事件
    if (pt104->bSendChange == 0 && pRunSet->bTT_SoeResumeComm == 0)
    {
        return 0;
    }

#ifdef FUN_SOE_DELAY_TIME
    if ((pt104->bfirst_call) && (dTCounter - pt104->DTSendChange <= 15 * T_1s))
    {
        return 0;
    }
    pt104->bfirst_call = false;
#endif

    // 等SOE保存后再发送，避免通讯确认没有保存的事件
    if (g_soe_queue.tail_eep.n != g_soe_queue.head.n)
    {
        return 0;
    }
#ifndef IEC_JXYB_DEAL
    if (g_run_stu.bjx) // 检修压板投入，不发送变化的事件记录
    {
        g_soe_queue.tail_send[pt104->chnl].n = g_soe_queue.tail_eep.n; // soe cos
        tf->head = tf->tail;                                           // 故障参数
        return 0;
    }
#endif
    // 发送级联来的故障参数
    if (tRunPara.bEvPara)
    {

        if (tf->head != tf->tail)
        {
            u8 index = tf->tail;
            tf->tail++;
            pd = &pt104->arrSendBuf[6];
            *pd++ = 42;                           // 类型标识				1
            *pd++ = 0;                            // 可变结构限定词  		2
            *pd++ = IEC_COT_SPONT;                // 传送原因：突发		3
            *pd++ = 0;                            // 传送原因：总召唤     	4
            *pd++ = (BYTE)tRunPara.byAddr;        // 应用服务数据单元地址 	5
            *pd++ = (BYTE)(tRunPara.byAddr >> 8); // 应用服务数据单元地址 	6
            memcpy(pd, &tf->data[index][1], tf->data[index][0]);
            IEC104_Send_sts(pt104, FRAME_I_PRIOR_LOW, tf->data[index][0] + 6, 0);
            return 0;
        }
    }
    head = g_soe_queue.head.n;
    // 一次调用，将事件池中所有事件发送完，
    // 已保证满足"重新连接后，总召前，发送完所有老的SOE,不发送COS"的需求。
    cnt = 0;
    while (1)
    {
        u8 yxtype = 0;
        // 检查发送队列空间,空间应大于1/4，防止发送缓冲区满
        if (IEC104_BufFree(&pt104->TxBuf[0]) < (IEC_TBUF_NUM >> 2))
        {
            break;
        }

        // 获取一帧报文的事件
        bFault = false;
        vsq = asdu_get_event_104(pt104->chnl, head, arrCos, arrSoe, &soe_no, 1, &bFault, &event, &arg_index, &yxtype);
        if (vsq == 0)
        {
            break;
        }
        cnt += vsq;

        // 发送COS
        if (is_send_cos)
        {
            pd = &pt104->arrSendBuf[6];
            *pd++ = (yxtype == 1) ? 3 : 1;        // 类型标识				1
            *pd++ = vsq;                          // 可变结构限定词  		2
            *pd++ = IEC_COT_SPONT;                // 传送原因：突发		3
            *pd++ = 0;                            // 传送原因：总召唤     	4
            *pd++ = (BYTE)tRunPara.byAddr;        // 应用服务数据单元地址 	5
            *pd++ = (BYTE)(tRunPara.byAddr >> 8); // 应用服务数据单元地址 	6
            memcpy(pd, arrCos, vsq * 4);

            IEC104_Send(pt104, FRAME_I_COS | FRAME_I_PRIOR_HIGH, 6 + 4 * vsq);
        }

        // 发送SOE
        pd = &pt104->arrSendBuf[6];
        *pd++ = (yxtype == 1) ? 31 : 30;      // 类型标识				1
        *pd++ = vsq;                          // 可变结构限定词  		2
        *pd++ = IEC_COT_SPONT;                // 传送原因：突发		3
        *pd++ = 0;                            // 传送原因：总召唤     	4
        *pd++ = (BYTE)tRunPara.byAddr;        // 应用服务数据单元地址 	5
        *pd++ = (BYTE)(tRunPara.byAddr >> 8); // 应用服务数据单元地址 	6
        memcpy(pd, arrSoe, vsq * 11);

        IEC104_Send_sts(pt104, FRAME_I_SOE | FRAME_I_PRIOR_HIGH, 6 + vsq * 11, soe_no);

        if (bFault) // 上送故障信息
        {
            u16 no;
            u8 SIQ, week;
            struct rtc_time_t rt;
            pd = &pt104->arrSendBuf[6];
            *pd++ = 42;                           // 类型标识				1
            *pd++ = 0;                            // 可变结构限定词  		2
            *pd++ = IEC_COT_SPONT;                // 传送原因：突发		3
            *pd++ = 0;                            // 传送原因：总召唤     	4
            *pd++ = (BYTE)tRunPara.byAddr;        // 应用服务数据单元地址 	5
            *pd++ = (BYTE)(tRunPara.byAddr >> 8); // 应用服务数据单元地址 	6

            no = soe_lp2cp(event.ev_type, event.ev_code, event.ev_arg[1]);
            SIQ = event.ev_value;
            if (yxtype == 1)
            {
                SIQ += 1; // 转为双点信息
            }
            timespec_to_rtc(event.ts, &rt, 1);
            week = WEEK_DAY(event.ts.tv_sec);
#if !defined FUNC_JX_YC_SIQ00
            if (g_run_stu.bjx)
            {
                SIQ |= 0x80; // 带品质描述，有效 <1>：=无效
            }
#endif
            *pd++ = 1;                // 遥信个数
            *pd++ = yxtype ? 31 : 30; // 类型标识		1
            *pd++ = (u8)no;           // 信息体地址L
            *pd++ = (u8)(no >> 8);    // 信息体地址H
            if (pRunSet->bTT_faultparaDKY)
            {
                *pd++ = 0; // 信息体地址H2  按照规约规定，101 及104 遥信信息体地址都是两个字节
            }
            //*pd++=0;			// 信息体地址H2  按照规约规定，101 及104 遥信信息体地址都是两个字节
            *pd++ = SIQ; // 遥信
            *pd++ = (u8)rt.ms;
            *pd++ = (u8)(rt.ms >> 8);
            *pd++ = (u8)rt.min;
            *pd++ = (u8)rt.hour;
            *pd++ = ((week << 5) | rt.day);
            *pd++ = (u8)rt.month;
            *pd++ = (u8)rt.year;

            vsq = asdu_get_event_yc(arrSoe, 1, arg_index);
            *pd++ = vsq; // 遥 测个数
            *pd++ = 13;  // 类型标识	浮点值
            memcpy(pd, arrSoe, vsq * 7);
            if (pRunSet->bTT_faultparaDKY)
            {
                IEC104_Send_sts(pt104, FRAME_I_PRIOR_LOW, (pd - &pt104->arrSendBuf[6]) + vsq * 7, 0); //  21 改为20 原因: 按照规约规定，101 及104 事件参数 遥信信息体地址都是两个字节
            }
            else
            {
                IEC104_Send_sts(pt104, FRAME_I_PRIOR_LOW, (pd - &pt104->arrSendBuf[6]) + vsq * 7, 0); //  21 改为20 原因: 按照规约规定，101 及104 事件参数 遥信信息体地址都是两个字节
            }
        }
    }
    return cnt;
}

void IEC104_SendYC(IEC104_DEF *pt104)
{
    int i;
    int num;
    BYTE *pd;
    int ycvalue;
    BYTE frametype;
    union
    {

        float ff;
        BYTE tt[4];
    } ff;

    // 主动上送条件:
    // 1、是IEC104_ST_STARTED状态
    // 2、没有在处理加密遥控报文
    if ((pt104->state != IEC104_ST_STARTED) || pt104->bRmtSM2)
    {
        return;
    }

    // 检查发送队列空间,空间应大于1/4，防止发送缓冲区满
    if (IEC104_BufFree(&pt104->TxBuf[0]) < (IEC_TBUF_NUM >> 2))
    {
        return;
    }

    // 遥测值需总召之后且遥测自动上送投入才允许上送
    if (pt104->bSendChange == 0 || tRunPara.bAutoSendYc == 0 || byc_filter)
    {
        return;
    }

#if defined IEC_JXYB_DEAL
    if (g_run_stu.bjx)
        return;
#endif

    if (tRunPara.bYcBDH) // 标度化值
    {
        frametype = 11; // 带品质描述的遥测帧  1
    }
    else if (tRunPara.bYcFloat) // 浮点值
    {
        frametype = 13; // 带品质描述的遥测帧  1
    }
    else
    {
        frametype = 9; // 带品质描述的遥测帧  1
    }
    pd = &pt104->arrSendBuf[12];
    num = 0;
    for (i = 0; i < g_table_head->ac_num; i++)
    {
        WORD cp;
        bool bsend = false;
        BYTE QDS = 0; // 品质描述， 默认为零
        u8 link_qds = 0;
        BYTE no = g_ac_table[i].indexno;
        long lmeaval;
        if (g_ac_table[i].dead_value == 0 || g_ac_table[i].normal == 0)
            continue; // 死区或额定为零，不主动上送
        if (no > 0)
        {
            DWORD dwMax;
            DWORD dwDeadVal = 0;
            float rate;
            float f_65536 = 65536.0;
            no -= 1;
            rate = (float)g_ac_table[i].rate / 65536.0;
            // dwMax=(DWORD)g_ac_table[i].normal;
            dwMax = (tRunPara.bDeadType == true) ? (DWORD)g_ac_table[i].normal : _AbsL(pt104->yc_save[i]);
            if (dwMax == 0)
                dwMax = 1;
            dwDeadVal = _Mul_Div_U(g_ac_table[i].dead_value, dwMax, 6553600);
            if (dwDeadVal == 0)
                dwDeadVal = 1;
            if (dwMax == 0)
                f_65536 = 1.0;
            lmeaval = GetRmtMeaVal(g_ac_table[i].owner, no, &link_qds);
            ff.ff = (float)lmeaval / f_65536 * rate; // 转为浮点数

#ifdef VOLT_ADAPTIVE_FACTOR
            if (pRunSet->bTT_AdaptiveFactor)
            {
                if (0 == g_ac_table[i].owner)
                {
                    if ((no <= PUB_AC_UCA1) && (no >= PUB_AC_UA1))
                    {
                        ff.ff = ((float)lmeaval) / f_65536 * 10 / pRunSet->a_pt_two;
                    }
                    else if ((no <= PUB_AC_UCA2) && (no >= PUB_AC_UA2))
                    {
                        ff.ff = ((float)lmeaval) / f_65536 * 10 / pRunSet->b_pt_two;
                    }
                }
            }
#endif

            ycvalue = (int)rt_round(ff.ff);

            if (tRunPara.bYcFloat)
            {
                if (_AbsL(lmeaval) > (dwMax * 10)) // 大于额定值的10倍*65536
                {
                    if (dwMax > 0)
                        QDS |= 0x01; // 遥测溢出
                }
            }
            else
            {
                if (ycvalue >= 0)
                {
                    if (ycvalue > 32767)
                    {
                        ycvalue = 32767;
                        QDS |= 0x01; // 遥测溢出
                    }
                }
                else
                {
                    if (ycvalue < (-32768))
                    {
                        ycvalue = -32768;
                        QDS |= 0x01; // 遥测溢出
                    }
                }
            }
#if (0) /* 会一直突发上送 */
            if (((no == PUB_AC_YC9) || (no == PUB_AC_YC10) || (no == PUB_AC_YC11) || (no == PUB_AC_YC12)))
            {
                bsend = true;
            }
#endif
#ifndef IEC_JXYB_DEAL
            if (bsend || ((i < MAX_YC_NUMBER) && (_AbsL(lmeaval - pt104->yc_save[i]) >= dwDeadVal)))
#else
            if (bsend || ((i < MAX_YC_NUMBER) && (_AbsL(lmeaval - pt104->yc_save[i]) >= dwDeadVal) && link_qds != 0x80))
#endif
            {
                if (g_run_stu.bToolRmtTest || g_run_stu.bHmiRmtTest) // 在测试模式下，置无效状态
                {
                    if (pRunSet->bTT_RmtTest)
                        QDS |= 0x80;
                }

                cp = g_ac_table[i].cp;
                if (i < MAX_YC_NUMBER)
                    pt104->yc_save[i] = lmeaval; // 遥测保存
                *pd++ = (BYTE)cp;
                *pd++ = (BYTE)(cp >> 8);
                *pd++ = 0; // 信息体地址H

                if (tRunPara.bYcFloat) // 浮点值上送
                {
                    pd += CopySwap(pd, ff.tt, sizeof(ff.tt), true);
                }
                else
                {
                    *pd++ = (BYTE)(ycvalue);
                    *pd++ = (BYTE)(ycvalue >> 8);
                }
                if (g_run_stu.bjx)
                {
                    QDS |= 0x80; // 带品质描述，有效 <1>：=无效
                }

#ifdef IEC_QDS_HAVE
                QDS |= link_qds;
#endif

                *pd++ = QDS; // 品质描述
                num++;
                if (num > 10) // 超过一帧数据
                {
                    pd = &pt104->arrSendBuf[6];
                    *pd++ = frametype;                    // 带品质描述的遥测帧  1
                    *pd++ = num;                          // 可变结构限定词
                    *pd++ = IEC_COT_SPONT;                // 传送原因：突发
                    *pd++ = 0;                            // 传送原因：源地址
                    *pd++ = (BYTE)tRunPara.byAddr;        // 应用服务数据单元地址
                    *pd++ = (BYTE)(tRunPara.byAddr >> 8); // 应用服务数据单元地址 6

                    if (tRunPara.bYcFloat) // 浮点值
                    {
                        IEC104_Send(pt104, FRAME_I, num * 8 + 6);
                    }
                    else
                    {
                        IEC104_Send(pt104, FRAME_I, num * 6 + 6);
                    }
                    pd = &pt104->arrSendBuf[12];
                    num = 0;
                }
            }
        }
    }
    if (num) // 有数据
    {
        pd = &pt104->arrSendBuf[6];
        *pd++ = frametype;                    // 带品质描述的遥测帧  1
        *pd++ = num;                          // 可变结构限定词
        *pd++ = IEC_COT_SPONT;                // 传送原因：总召唤
        *pd++ = 0;                            // 传送原因：总召唤
        *pd++ = (BYTE)tRunPara.byAddr;        // 应用服务数据单元地址
        *pd++ = (BYTE)(tRunPara.byAddr >> 8); // 应用服务数据单元地址 6

        if (tRunPara.bYcFloat) // 浮点值
        {
            IEC104_Send(pt104, FRAME_I, num * 8 + 6);
        }
        else
        {
            IEC104_Send(pt104, FRAME_I, num * 6 + 6);
        }
    }
}

void IEC104_lnk_yk(IEC104_DEF *pt104)
{

    int i;
    LINKYK_DEF *yk;
    LINK_YKDATA *yd = NULL;

    if (pt104->lnk_yk_send_flag == 0)
    {
        return;
    }

    for (i = 0; i < SWITCH_NUM_EXT_PUB; i++)
    {
        if (pt104->lnk_yk_send_flag & (1 << i))
        {
            u8 yktype, yk_cmd;
            bool yk_hs = false;
            yk = &g_lnk_yk[i];

            // 遥控应答帧
            if (yk->flag[IECLINK_YK_ACK])
            {
                yd = &yk->data[IECLINK_YK_ACK];
                IEC104_Echo_YK(pt104, yk->cp_m, yd->ti, yd->cot, yd->v);
                yk->flag[IECLINK_YK_ACK] = 0;
                yk_hs = true;
            }

            // 遥控结束帧
            if (yk->flag[IECLINK_YK_END])
            {
                yd = &yk->data[IECLINK_YK_END];
                IEC104_Echo_YK(pt104, yk->cp_m, yd->ti, yd->cot, yd->v);
                yk->flag[IECLINK_YK_END] = 0;

                pt104->lnk_yk_send_flag &= ~(1 << i);
                yk_hs = true;
            }

            // 遥控超时，复位
            if (ustimer_get_duration(pt104->us0_lnk_yk) > tRunPara.dSM2Time * USTIMER_SEC)
            {
                yd = &yk->data[IECLINK_YK_SND];
                rt_printf("级联遥控超时复位:cp_m=%04x,cp_s=%04x,ti=%d,v=%d.\r\n", yk->cp_m, yk->cp_s, yd->ti, yd->v);

                pt104->lnk_yk_send_flag &= ~(1 << i);
            }
            if (yk_hs && yd)
            {
                if (yd->v & 0x80)
                {
                    yktype = YK_TYPE_SEL;
                }
                else
                {
                    yktype = YK_TYPE_EXE;
                }

                if (yd->cot == IEC_COT_DEACT) // 遥控撤销
                {
                    yktype = YK_TYPE_CANCEL;
                }

                yk_cmd = yd->v & 0x03;

                refresh_co_file(false, yd->ti, yktype, yk->cp_m, yd->cot, yk_cmd);
            }
        }
    }
}

#ifdef YPARA_LINK
void IEC104_lnk_msg_ypara(IEC104_DEF *pt104)
{
    u8 ti = 0, vsq = 0;
    int i = 0, index = 0;

    msg_data_struct *msg_data = &pt104->msg_ypara_recv;
    BYTE *pd = &pt104->arrSendBuf[6]; // 从第7个字节开始
    u8 num = 0;
    u8 cot = 0, pdi = 0;

#if 0
/*返回信息是否超时*/
	if(pt104->msg_ypara.flag)
	{
		if(ustimer_get_duration(pt104->us0_msg_ypara)	> 10*USTIMER_SEC)
		{
			pt104->msg_ypara.flag = 0;
			return;
		}
	}		
/*返回信息是否超时*/
#endif

    if (!msg_data->flag)
        return; /*有返回消息*/
    msg_data->flag = 0;

    if (msg_data->type == modify_set)
    {
        msg_ypara_data_struct *ypara_msg = &pt104->msg_ypara_recv.ypara_msg;

        ti = 203;
        /*该协议各类遥参返回格式一致,统一接口即可*/
        switch (ypara_msg->cmd)
        {
        case YP_SEL_RETURN:
            pdi = 0x80;
            cot = IEC_COT_ACTCON;
            break;

        case YP_SEL_FAULT:
            pdi = 0x80;
            cot = IEC_COT_ACTCON | IEC_COT_PN;
            break;

        case YP_EXE_RETURN:
            pdi = 0x00;
            cot = IEC_COT_ACTCON;
            break;

        case YP_EXE_FAULT:
            pdi = 0x00;
            cot = IEC_COT_ACTCON | IEC_COT_PN;
            break;

        case YP_CANCEL_RETURN:
            pdi = 0x40;
            cot = IEC_COT_DEACTCON;
            break;

        case YP_CANCEL_FAULT:
            pdi = 0x40;
            cot = IEC_COT_DEACTCON | IEC_COT_PN;
            break;

        default:
            break;
        }

        pd[0] = ti;                           // 类型标识
        pd[1] = 0;                            // 可变结构限定词
        pd[2] = cot;                          // 传送原因：
        pd[3] = 00;                           // 传送原因：
        pd[4] = (BYTE)tRunPara.byAddr;        // 应用服务数据单元地址
        pd[5] = (BYTE)(tRunPara.byAddr >> 8); // 应用服务数据单元地址
        num += 6;

        pd[num++] = (u8)m_runsection;        // 当前定值区
        pd[num++] = (u8)(m_runsection >> 8); // 当前定值区
        pd[num++] = pdi;                     /*特征符*/

        // print_msg_base(ypara_msg);

        for (i = 0; i < ypara_msg->num; i++)
        {
            index = get_index_link(msg_data->sport, ypara_msg->base_data[i].cp_s);
            if (index < 0)
                continue;

            pd[num++] = (u8)tParaID[index].parId;
            pd[num++] = (u8)(tParaID[index].parId >> 8);
            pd[num++] = 0;

            pd[num++] = ypara_msg->base_data[i].val_iec.tag;
            pd[num++] = ypara_msg->base_data[i].val_iec.size;
            if (ypara_msg->base_data[i].val_iec.size > 0)
            {
                memcpy(&pd[num], ypara_msg->base_data[i].val_iec.value, ypara_msg->base_data[i].val_iec.size);
                num += ypara_msg->base_data[i].val_iec.size;
            }
            vsq++;
        }

        pd[1] = vsq;
        IEC104_Send(pt104, FRAME_I, num);
    }
}

void IEC104_Rmt_msg_ypara_write(IEC104_DEF *pt, BYTE *pdat, BYTE vsq, u8 link_cp)
{
    WORD section = 0;
    BYTE *ps = 0; // 从点号开始
    int i, j = 0;
    u16 di = 0;
    msg_data_struct *msg_data;
    msg_ypara_data_struct *msg;
    iec_val_struct v;
    BYTE pdi; // 参数特征标识符

    msg_data = &pt->msg_ypara_send;
    msg = &pt->msg_ypara_send.ypara_msg;
    memset(msg, 0, sizeof(msg_ypara_data_struct));

    pt->msg_ypara_send.dport = link_cp;
    pt->msg_ypara_send.sport = pt->chnl;
    pt->msg_ypara_send.flag = 1;

    section = pdat[0] + (pdat[1] << 8); // 定值区号
    pdi = pdat[2];

    msg->section_p = section; // 定值区
    if ((pdi & 0xc0) == 0)    // 定值固化
    {
        msg->cmd = YP_EXE;
    }
    else if ((pdi & 0xc0) == 0x40) /*撤销*/
    {
        msg->cmd = YP_CANCEL;
    }
    else // 参数预置
    {
        msg->cmd = YP_SEL;
        ps = &pdat[3];
        for (i = 0; i < vsq; i++)
        {
            di = ps[0] + (ps[1] << 8);
            ps += 3;
            v.tag = *ps++;
            v.size = *ps++;
            memcpy(v.value, ps, v.size);
            ps += v.size;

            for (j = 0; j < ParaIDNum; j++)
            {
                if (tParaID[j].link_ch == 0)
                    continue; /*本地定值*/
                if (di != tParaID[j].parId)
                    continue;

                msg->base_data[msg->num].cp_m = tParaID[j].parId;
                msg->base_data[msg->num].cp_s = tParaID[j].link_cp;
                msg->base_data[msg->num].val_iec = v;
                msg->num++;
                break;
            }
        }
    }

    msg_data->type = modify_set;
    msg_data->sport = pt->chnl;
    msg_data->dport = link_cp;

    mananger_msg_ypara_s(msg_data, msg_data->sport, msg_data->dport);
    pt->us0_msg_ypara = ustimer_get_origin();
}
#endif

#ifdef YPARA_LINK_S
void IEC104_lnk_set_up(IEC104_DEF *pt104)
{
    BYTE *pd = &pt104->arrSendBuf[6]; // 从第7个字节开始
    u8 num = 0;

    if (pt104->para_updata_flag)
    {
        pd[0] = SET_UP_TYPE;                  // 类型标识
        pd[1] = 0x01;                         // 可变结构限定词
        pd[2] = 0x03;                         // 传送原因：
        pd[3] = 00;                           // 传送原因：
        pd[4] = (BYTE)tRunPara.byAddr;        // 应用服务数据单元地址
        pd[5] = (BYTE)(tRunPara.byAddr >> 8); // 应用服务数据单元地址
        num += 6;

        pd[num++] = 0;                       /*信息体地址*/
        pd[num++] = 0;                       /**/
        pd[num++] = 0;                       /*信息体地址*/
        pd[num++] = pt104->para_updata_flag; /*定值是否更新*/

        IEC104_Send(pt104, FRAME_I, num);
        pt104->para_updata_flag = 0;
    }
}

#endif

#ifdef RCD_STRAN_S
static void IEC104_Rcd_Ack(IEC104_DEF *pt104) // 发送新录波文件名
{
    BYTE *pd = &pt104->arrSendBuf[6]; // 从第7个字节开始
    u8 num = 0;
    char tmp[128] = {0};
    char note[100];

    pd[0] = RCD_TYPE;                     // 类型标识
    pd[1] = 1;                            // 可变结构限定词
    pd[2] = 0x07;                         // 传送原因：
    pd[3] = 00;                           // 传送原因：
    pd[4] = (BYTE)tRunPara.byAddr;        // 应用服务数据单元地址
    pd[5] = (BYTE)(tRunPara.byAddr >> 8); // 应用服务数据单元地址
    num += 6;

    if (get_queue_count(&pt104->rcd_qt.queue) > 0) /*有新录波*/
    {
        check_data_queque(&pt104->rcd_qt.queue, tmp);
        sprintf(note, "%s----------准备\r\n", tmp);
        log_str_time(LOG_OPERATE, note, 0, 1);

        pd[num++] = 0; // 信息体地址
        pd[num++] = 0;
        pd[num++] = 0;           // 信息体地址
        pd[num++] = 1;           /*文件数量*/
        pd[num++] = strlen(tmp); /*文件名长度*/
        memcpy(&pd[num], tmp, strlen(tmp));
        num += strlen(tmp);
    }
    else
    {
        pd[num++] = 0; // 信息体地址
        pd[num++] = 0; //
        pd[num++] = 0; // 信息体地址
        pd[num++] = 0; /*文件数量*/
    }

    IEC104_Send(pt104, FRAME_I, num);
}
#endif

/**************************************************************************
函数名称：IEC101_link_par
函数版本：1.00
作者：
创建日期：2019.4.19
函数功能说明：101规约遥参级联处理
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/
void IEC104_link_par(IEC104_DEF *pt104)
{

    int i;
    LINKPAR_DEF *par;
    LINK_PARDATA *yd;

    if (pt104->lnk_par_send_flag == 0)
    {
        return;
    }

    for (i = 0; i < SWITCH_NUM_EXT_PUB; i++)
    {
        if (pt104->lnk_par_send_flag & (1 << i))
        {
            par = &g_link_par[i];

            // 遥控应答帧
            if (par->flag[IECLINK_YK_ACK])
            {
                yd = &par->data[IECLINK_YK_ACK];

                IEC104_AddFrame_dz((IEC104_DEF *)pt104, &yd->buf[0], yd->len, yd->vsq, yd->cot, yd->ti, true);

                par->flag[IECLINK_YK_ACK] = 0;
                rt_printf("参数应答帧\r\n");
            }

            // 遥控结束帧
            if (par->flag[IECLINK_YK_END])
            {
                yd = &par->data[IECLINK_YK_END];

                IEC104_AddFrame_dz((IEC104_DEF *)pt104, &yd->buf[0], yd->len, yd->vsq, yd->cot, yd->ti, true);

                par->flag[IECLINK_YK_END] = 0;
                pt104->lnk_par_send_flag &= ~(1 << i);
                rt_printf("参数结束帧\r\n");
            }

            // 遥控超时，复位
            if (ustimer_get_duration(pt104->us0_lnk_par) > tRunPara.dSM2Time * USTIMER_SEC)
            {
                yd = &par->data[IECLINK_YK_SND];
                rt_printf("参数遥控超时复位:cp_m=%04x,cp_s=%04x,ti=%d,v=%d.\r\n", par->cp_m, par->cp_s, yd->ti, yd->len);
                g_link_par[i].flag[IECLINK_YK_SND] = false;
                pt104->lnk_par_send_flag &= ~(1 << i);
            }
        }
    }
}

#ifdef FUNC_MORE_PRESET
YT_BUF PresetData104[256];
YT_BUF SetData104[256];
int WrongCount104[256];
int g_CountPreset104 = 0, g_CountSet104 = 0;
#endif

static void IEC104_ParCtrl(IEC104_DEF *pt104, u8 *pdat) // ps从传送原因开始
{
    WORD parAddr = 0;
    u8 *ps = &pdat[10]; // 主站下发帧第10位开始为地址位
    u8 qos = ps[7];
    u8 ti = pdat[4];    // 类型标示
    u8 vsq = pdat[5];   // 可变帧长限定词
    u8 ytcot = pdat[6]; // 传输原因
    struct do_table parTab;
    BYTE buf[256];
    BYTE len = 0, addlen = 0;
    RMT_SET_VAL yt_buf;
    WORD sw = 1;
    bool b104 = true;
    u8 cot;
    static DWORD ctrlParTime = 0;        // 系统定时器
    static bool bSetParaDisable = false; // 为1时：取消预置，禁止写；为0时：非取消预置，允许写；

    parAddr = (ps[1] << 8) + ps[0]; // 遥参通信地址
    len = get_par_link_data_dz(&buf[0], &ps[0], vsq, ti);
    if (ti == FOS_PAR_SET_ONE || ti == FOS_PAR_SET_MUL)
    {
        qos = ps[7]; //
    }
    else
    {
        qos = ps[6]; //
    }

    if (pRunSet->wEquTypeManager) // 通信管理机模式，转发
    {
#ifdef YC_QUANTITY
        if (!get_par_ch_info(parAddr, &parTab) || vsq > pRunSet->dYC_num)
#else
        if (!get_par_ch_info(parAddr, &parTab) || vsq > FOS_PAR_SW_NUM)
#endif
        {
            cot = IEC_COT_ACTCON | IEC_COT_PN; // 否定应答
            return;
        }
        if (lnk_master_par(&parTab, ti, ytcot, len, &buf[0], vsq) == 0)
        {
#ifdef FUNC_MORE_PREREAD /*级联遥参方式:0开关,1队列*/
            pt104->lnk_par_send_flag |= (1 << g_link_par_cnt);
            rt_printf("-------lnk_par_send_flag=%x,g_link_par_cnt=%d\r\n", pt104->lnk_par_send_flag, g_link_par_cnt);
            g_link_par_cnt = (g_link_par_cnt + 1) % SWITCH_NUM_EXT_PUB;
#else
            pt104->lnk_par_send_flag |= (1 << parTab.owner);
#endif
            pt104->us0_lnk_par = ustimer_get_origin();
        }
    }
    else if (pRunSet->wEquTypeDFTU) // 测控装置遥参交互
    {
        WORD parCount;
        WORD addLenParLen = 0;
        WORD offset = 0;

#ifdef FUNC_MORE_PRESET
        int n;
#endif
        cot = IEC_COT_ACTCON;
#ifndef FUNC_MORE_PRESET
        bfirst_sel = false;
#endif

#ifdef FUNC_MORE_PRESET
        if ((dTCounter - ctrlParTime) > tRunPara.dYKTime)
        { // 超时清零预置/执行/出错数据存储区
            memset(SetData104, 0, sizeof(SetData104));
            g_CountSet104 = 0;
            memset(PresetData104, 0, sizeof(PresetData104));
            g_CountPreset104 = 0;
            memset(WrongCount104, 0, sizeof(WrongCount104));
            rt_printf("超时清除104报文缓存区\r\n");
        }
#endif

        if (ti == FOS_PAR_SET_ONE || ti == FOS_PAR_SET_MUL)
        {
            if (((qos & 0x80) == 0x80) && (ytcot == IEC_COT_ACT))
            {
#ifdef FUNC_MORE_PRESET
                memcpy(&PresetData104[g_CountPreset104++].yc_data, ps, vsq * 8);

                rt_printf_time("104预置报文[第%d帧]：", g_CountPreset104);
                for (n = 0; n < vsq * 8; n++)
                {
                    rt_printf("%02x  ", PresetData104[g_CountPreset104 - 1].yc_data[n]);
                }
#else
                // 预置时先对buf_forCompare进行初始化，避免此数组有101/104共用的原因导致存储出错
                memset(buf_forCompare, 0, sizeof(buf_forCompare));
                i_forCompare = 0;
                j_forCompare = 0;
                bfirst_sel = true; // 为预置报文时才置1
#endif

                bSetParaDisable = false; // 重新预置时清0
            }
#ifdef FUNC_MORE_PRESET
            else if (((qos & 0x80) == 0x00) && (ytcot == IEC_COT_ACT))
            {
                memcpy(&SetData104[g_CountSet104++].yc_data, ps, vsq * 8);

                rt_printf_time("104固化报文[第%d帧]：", g_CountSet104);
                for (n = 0; n < vsq * 8; n++)
                {
                    rt_printf("%02x  ", SetData104[g_CountSet104 - 1].yc_data[n]);
                }
            }
#endif
        }
        else if (ti == FOS_PAR_SET_ONE_EXT || ti == FOS_PAR_SET_MUL_EXT)
        {
            if (((qos & 0x80) == 0x80) && (ytcot == IEC_COT_ACT))
            {
#ifdef FUNC_MORE_PRESET
                memcpy(&PresetData104[g_CountPreset104++].yc_data, ps, vsq * 7);

                rt_printf_time("104预置报文[第%d帧]：", g_CountPreset104);
                for (n = 0; n < vsq * 7; n++)
                {
                    rt_printf("%02x  ", PresetData104[g_CountPreset104 - 1].yc_data[n]);
                }
#else
                // 预置时先对buf_forCompare进行初始化，避免此数组有101/104共用的原因导致存储出错
                memset(buf_forCompare, 0, sizeof(buf_forCompare));
                i_forCompare = 0;
                j_forCompare = 0;
                bfirst_sel = true; // 为预置报文时才置1
#endif

                bSetParaDisable = false; // 重新预置时清0
            }
#ifdef FUNC_MORE_PRESET
            else if (((qos & 0x80) == 0x00) && (ytcot == IEC_COT_ACT))
            {
                memcpy(&SetData104[g_CountSet104++].yc_data, ps, vsq * 7);

                rt_printf_time("104固化报文[第%d帧]：", g_CountSet104);
                for (n = 0; n < vsq * 7; n++)
                {
                    rt_printf("%02x  ", SetData104[g_CountSet104 - 1].yc_data[n]);
                }
            }
#endif
        }

        for (parCount = 0; parCount < vsq; parCount++) // 多参数处理
        {
            if (ti == FOS_PAR_READ_ONE || ti == FOS_PAR_READ_MUL)
                addLenParLen = (parCount) * 7; // 每7位为一个定值的处理,3位地址,4位数据
            else if (ti == FOS_PAR_SET_ONE || ti == FOS_PAR_SET_MUL)
                addLenParLen = (parCount) * (7 + 1); // 每8位为一个定值的处理,3位地址,4位数据,1位QOS
            else if (ti == FOS_PAR_READ_ONE_EXT || ti == FOS_PAR_READ_MUL_EXT)
                addLenParLen = (parCount) * 6;
            else if (ti == FOS_PAR_SET_ONE_EXT || ti == FOS_PAR_SET_MUL_EXT)
                addLenParLen = (parCount) * (6 + 1);

            // ps[0]和ps[1]为地址位,ps[2]为地址第三位,默认为0x00
#ifdef YC_QUANTITY
            parAddr = ((ps[1 + addLenParLen] << 8) + ps[addLenParLen] - FOS_PAR_STATR_ADDR) % (pRunSet->dYC_num) + FOS_PAR_STATR_ADDR; // 遥参通信地址;
#else
            parAddr = ((ps[1 + addLenParLen] << 8) + ps[addLenParLen] - FOS_PAR_STATR_ADDR) % (FOS_PAR_SW_NUM) + FOS_PAR_STATR_ADDR; // 遥参通信地址;
#endif

#ifdef YC_QUANTITY
            if (((ps[1 + addLenParLen] << 8) + ps[addLenParLen]) >= FOS_PAR_STATR_ADDR && ((ps[1 + addLenParLen] << 8) + ps[addLenParLen]) < (FOS_PAR_STATR_ADDR + pRunSet->dYC_num))
#else
            if (((ps[1 + addLenParLen] << 8) + ps[addLenParLen]) >= FOS_PAR_STATR_ADDR && ((ps[1 + addLenParLen] << 8) + ps[addLenParLen]) < (FOS_PAR_STATR_ADDR + FOS_PAR_SW_NUM))
#endif
            {
                parAddr = (ps[1 + addLenParLen] << 8) + ps[addLenParLen];
            }
            rt_printf("parCount=%d,vsq=%x,parAddr=%x addrfirst=%X addLenParLen=%x\r\n", parCount, vsq, parAddr, (ps[1] << 8) + ps[0], addLenParLen);

            if (ti == FOS_PAR_READ_ONE || ti == FOS_PAR_READ_MUL || ti == FOS_PAR_READ_ONE_EXT || ti == FOS_PAR_READ_MUL_EXT)
            {
                rt_printf("读遥参 parAddr=%x\r\n", parAddr);
                if (!readRunParId(sw, parAddr, &(yt_buf.str[0]))) // 暂默认为0开关
                {
                    rt_printf("读遥参未找到对应地址的定值 parAddr=%x\r\n", parAddr);
                    cot = IEC_COT_ACTCON | IEC_COT_PN;
                }
                // yt_buf.di = parAddr;
                yt_buf.di = (ps[1 + addLenParLen] << 8) + ps[addLenParLen];
                yt_buf.len = 4;
                if (ti == FOS_PAR_READ_ONE || ti == FOS_PAR_READ_MUL)
                {
                    len = iec_add2frame_dz(buf + addlen, &yt_buf, b104);
                }
                else
                {
                    len = iec_add2frame_dz(buf + addlen, &yt_buf, false);
                }
                addlen += len;
                if (parCount == (vsq - 1))
                {
                    rt_printf("读最后一个参数,上送报文,addlen==%d\r\n", addlen);
                    IEC104_AddFrame_dz((IEC104_DEF *)pt104, buf, addlen, vsq, cot, ti, false);
                    addlen = 0;
                }
            }
            else if (ti == FOS_PAR_SET_ONE || ti == FOS_PAR_SET_MUL || ti == FOS_PAR_SET_ONE_EXT || ti == FOS_PAR_SET_MUL_EXT)
            {
                if (ti == FOS_PAR_SET_ONE || ti == FOS_PAR_SET_MUL)
                {
                    offset = 3 + addLenParLen;
                }
                else
                {
                    offset = 2 + addLenParLen;
                }

                if (((qos & 0x80) == 0x80) && (ytcot == IEC_COT_ACT))
                {
                    rt_printf("参数预置...\r\n");
                    if (!selectRunParId(sw, parAddr, &ps[offset]))
                    {
                        rt_printf("预置遥参失败,parAddr=%x,请检查地址或参数值\r\n", parAddr);
                        cot = IEC_COT_ACTCON | IEC_COT_PN;
#ifdef FUNC_MORE_PRESET
                        WrongCount104[g_CountPreset104 - 1] = g_CountPreset104;
#else
                        bSetParaDisable = true; // 预置报文出错时置1，禁止固化定值
#endif
                    }
                    // ps[3]、ps[4]、ps[5]、ps[6]为写定值数据位
                    yt_buf.str[0] = ps[offset];
                    yt_buf.str[1] = ps[offset + 1];
                    yt_buf.str[2] = ps[offset + 2];
                    yt_buf.str[3] = ps[offset + 3];
                    yt_buf.str[4] = 0x80;
                    // yt_buf.di = parAddr;
                    yt_buf.di = (ps[1 + addLenParLen] << 8) + ps[addLenParLen];
                    yt_buf.len = 5;
                    if (ti == FOS_PAR_SET_ONE || ti == FOS_PAR_SET_MUL)
                    {
                        len = iec_add2frame_dz(buf + addlen, &yt_buf, b104);
                    }
                    else
                    {
                        len = iec_add2frame_dz(buf + addlen, &yt_buf, false);
                    }
                    addlen += len;
                    if (parCount == (vsq - 1))
                    {
                        rt_printf("预置最后一个参数,上送报文,addlen==%d\r\n", addlen);
                        ctrlParTime = dTCounter; // 系统时间戳
                        // bSetParaDisable = 0;	//重新预置时置0
                        IEC104_AddFrame_dz((IEC104_DEF *)pt104, buf, addlen, vsq, cot, ti, false);
                        addlen = 0;
                    }
                }
                else if (((qos & 0x80) == 0x00) && (ytcot == IEC_COT_ACT))
                {
#ifdef FUNC_MORE_PRESET
                    int s_stop;
                    s_stop = WrongCount104[g_CountSet104 - 1];
#endif

                    rt_printf("参数固化...\r\n");
#ifdef FUNC_MORE_PRESET
                    if (((dTCounter - ctrlParTime) > tRunPara.dYKTime) || (0 != s_stop) || bSetParaDisable || !wirteRunParId(sw, parAddr, &ps[offset], ti))
#else
                    if (((dTCounter - ctrlParTime) > tRunPara.dYKTime) || bSetParaDisable || !wirteRunParId(sw, parAddr, &ps[offset], ti))
#endif
                    {
                        if ((dTCounter - ctrlParTime) > tRunPara.dYKTime)
                        {
                            bSetParaDisable = false; // 超时后才清0，避免取消预置后在超时时间内多次发执行帧而误执行
                            rt_printf("预置->固化过程时间超时..\r\n");
                        }
#ifdef FUNC_MORE_PRESET
                        else if (0 != s_stop)
                        {
                            rt_printf("[第%d帧]104预置报文出错,请检查...\r\n", s_stop);
                        }
#endif
                        else if (bSetParaDisable)
                        {
                            rt_printf("预置报文出错或取消预置,禁止固化定值\r\n");
                        }
                        else
                        {
                            rt_printf("固化遥参失败,parAddr=%x,请检查..\r\n", parAddr);
                        }
                        cot = IEC_COT_ACTCON | IEC_COT_PN;
                    }
                    // ps[3]、ps[4]、ps[5]、ps[6]为写定值数据位
                    yt_buf.str[0] = ps[offset];
                    yt_buf.str[1] = ps[offset + 1];
                    yt_buf.str[2] = ps[offset + 2];
                    yt_buf.str[3] = ps[offset + 3];
                    yt_buf.str[4] = 0x00;
                    // yt_buf.di = parAddr;
                    yt_buf.di = (ps[1 + addLenParLen] << 8) + ps[addLenParLen];
                    yt_buf.len = 5;
                    if (ti == FOS_PAR_SET_ONE || ti == FOS_PAR_SET_MUL)
                    {
                        len = iec_add2frame_dz(buf + addlen, &yt_buf, b104);
                    }
                    else
                    {
                        len = iec_add2frame_dz(buf + addlen, &yt_buf, false);
                    }
                    addlen += len;
                    if (parCount == (vsq - 1))
                    {
                        if ((dTCounter - ctrlParTime) > tRunPara.dYKTime && !bSetParaDisable)
                        {
                            rt_printf("设置遥参超时,上送报文...\r\n");
                        }
#ifdef FUNC_MORE_PRESET
                        else if (0 != s_stop)
                        {
                            rt_printf("预置报文出错,不允许写,上送报文...\r\n");
                        }
#endif
                        else if (bSetParaDisable)
                        {
#ifdef FUNC_MORE_PRESET
                            rt_printf("取消预置,不允许写,上送报文...\r\n");
#else
                            rt_printf("预置报文出错或取消预置,不允许写,上送报文...\r\n");
#endif
                        }
                        else
                        {
                            rt_printf("固化最后一个参数,上送报文,addlen==%d\r\n", addlen);
                        }
                        IEC104_AddFrame_dz((IEC104_DEF *)pt104, buf, addlen, vsq, cot, ti, false);
#ifndef FUNC_MORE_PRESET
                        memset(buf_forCompare, 0, sizeof(buf_forCompare));
                        i_forCompare = 0;
                        j_forCompare = 0;
                        ctrlParTime = 0;
#endif
                        addlen = 0;
                    }
                }
                else if (
#ifndef FUNC_FIT_QOS
                    ((qos & 0x80) == 0x00) &&
#endif
                    (ytcot == IEC_COT_DEACT))
                {
                    rt_printf("取消预置...\r\n");
                    // ps[3]、ps[4]、ps[5]、ps[6]为写定值数据位
                    if (ti == FOS_PAR_SET_ONE || ti == FOS_PAR_SET_MUL)
                    {
                        yt_buf.str[0] = ps[3 + parCount * 8];
                        yt_buf.str[1] = ps[3 + parCount * 8 + 1];
                        yt_buf.str[2] = ps[3 + parCount * 8 + 2];
                        yt_buf.str[3] = ps[3 + parCount * 8 + 3];
                    }
                    else
                    {
                        yt_buf.str[0] = ps[3 + parCount * 7];
                        yt_buf.str[1] = ps[3 + parCount * 7 + 1];
                        yt_buf.str[2] = ps[3 + parCount * 7 + 2];
                        yt_buf.str[3] = ps[3 + parCount * 7 + 3];
                    }

#ifdef FUNC_FIT_QOS
                    yt_buf.str[4] = qos;
#else
                    yt_buf.str[4] = 0x00;
#endif
                    // yt_buf.di = parAddr;
                    yt_buf.di = (ps[1 + addLenParLen] << 8) + ps[addLenParLen];
                    yt_buf.len = 5;
                    if (ti == FOS_PAR_SET_ONE || ti == FOS_PAR_SET_MUL)
                    {
                        len = iec_add2frame_dz(buf + addlen, &yt_buf, b104);
                    }
                    else
                    {
                        len = iec_add2frame_dz(buf + addlen, &yt_buf, false);
                    }
                    addlen += len;
                    if (parCount == (vsq - 1))
                    {
                        bSetParaDisable = true; // 取消预置时置1
                        rt_printf("取消预置最后一个参数,上送报文,addlen==%d,QOS(104)=%02x\r\n", addlen, qos);
                        IEC104_AddFrame_dz((IEC104_DEF *)pt104, buf, addlen, vsq, IEC_COT_DEACTCON, ti, false);
#ifndef FUNC_MORE_PRESET
                        memset(buf_forCompare, 0, sizeof(buf_forCompare));
                        i_forCompare = 0;
                        j_forCompare = 0;
#endif

                        ctrlParTime = 0;
                        addlen = 0;
                    }
                }
            }
        }
    }
}

/**************************************************************************
函数名称：IEC104_App
函数版本：1.00
作者：
创建日期：2007.9.1
函数功能说明：104数据处理任务
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/
void IEC104_App(IEC104_DEF *pt104)
{
    int cnt;
    u8 ti;
    // IEC101_DEF *pt = (IEC101_DEF *)g_tRsComm[0].ptBuf;
    //  printf("AAStep1: Deal the 104 msg. \n");

    // 接收报文
    IEC104_Recv_App(pt104);

#ifdef IEC_NOLINK_NO_CALLYX
    if (g_link_comm.link_flag == false)
        return;
#endif

    // 处理级联遥参
    IEC104_link_par(pt104);

    // 连接初始建立，所有状态复位
    if (pt104->LinkCountApp != pt104->LinkCountNet)
    {
        pt104->LinkCountApp = pt104->LinkCountNet;
        IEC104_Reset(pt104);

        IEC104_printf("IEC104(%d) state: 网络连接(%d => %d)!\r\n", pt104->chnl, pt104->state, IEC104_ST_STOPPED);
        pt104->state = IEC104_ST_STOPPED;
    }

    // 主动SOE处理，放在报文处理之前，使时间同步报文之前的SOE报文在时间报文应答前发送
    cnt = IEC104_SendEvent(pt104, tRunPara.bAutoCos);

    // 级联遥控处理
    IEC104_lnk_yk(pt104);
#ifdef YPARA_LINK
    IEC104_lnk_msg_ypara(pt104);
#endif

    if (pt104->state == IEC104_ST_STARTED)
    {
        g_bCommStatus = TRUE;
    }

#if 0
	if(cnt)
	{
		sbi_t cnt_remain;
		cnt_remain.n = g_soe_queue.head.n - g_soe_queue.tail_send[pt104->chnl].n;
		IEC104_printf("SendEvent:cnt_send=%d,cnt_remain=%d,head=%d,send=%d,ack=%d.\r\n",
			cnt,cnt_remain.n,g_soe_queue.head.n,g_soe_queue.tail_send[pt104->chnl].n,g_soe_queue.tail_ack[pt104->chnl].n);

	}
#endif

    // 处理接收的加密报文
    // 先处理加密报文，再处理普通报文，保证同一报文一个循环处理完
    if (pt104->bSM2Data)
    {
        // 检查是否是当前连接的报文
        if (IEC104_IsCurFrame(pt104) == 0)
        {
            return;
        }

        // 处理加密报文
        if (pRunSet->bTT_SM2)
        {
#ifdef ENCRYPT_SM2
            IEC104_SM2(pt104);
#endif
        }
        pt104->bSM2Data = false;
    }

    // printf("BBStep2: Deal the 104 msg. \n");
    // 处理接收的普通报文
    if (pt104->bRecvOk)
    {
        BYTE *pd = pt104->arrRecvBuf;
        u16 addr;
        Byte2WORD Num;
        u8 cot;

        // 检查是否是当前连接的报文
        if (IEC104_IsCurFrame(pt104) == 0)
        {
            return;
        }

        IEC104_UnPackFrame(pt104, pt104->arrRecvBuf, 0);

        // 检查0x68
        if (pd[0] != 0x68)
        {
            char log_info[128];
            // 不应该出现，因为接收时已检查过了，所以也不应该复位接收状态机
            IEC104_printf("IEC104(%d) recv error: state=%d,pd[0]=%d,ADDR0=%d!\r\n", pt104->chnl, pt104->state, pd[0], tRunPara.byAddr);

            sprintf(log_info, "IEC104(%d):recv error,state=%d,pd[0]=%d,ADDR0=%d", pt104->chnl + 1, pt104->state, pd[0], tRunPara.byAddr);
            load_hs_log_rcd(TYPE_COMM_ERR, true, NULL, log_info, 1);
            log_flag.com_err[pt104->chnl] = true;
        }
        // 正常报文处理
        else
        {
            pd += 2;
            switch ((*pd) & 0x03) // 控制域判断
            {
            // I格式
            case 0x00:
            case 0x02:
                // 如果不是STARTED状态，接收到I帧，应主动关闭连接
                if (pt104->state != IEC104_ST_STARTED)
                {
                    char log_info[128];

                    IEC104_printf("IEC104(%d) Reset(%d): 非STARTED状态接收到I帧!\r\n", pt104->chnl, pt104->state);
                    IEC104_ActiveClose(pt104);

                    sprintf(log_info, "IEC104(%d):The non-started state receives the I frame", pt104->chnl + 1, pt104->state);
                    load_hs_log_rcd(TYPE_COMM_ERR, true, NULL, log_info, 1);
                    log_flag.com_err[pt104->chnl] = true;

                    pt104->bRecvOk = false;
                    return;
                }
                // 检查报文的发送序号，报文中的发送帧号必须等于pt104->RecvNum。
                pd[0] &= 0xfe;
                CopySwap(Num.tt, pd, 2, false);

                // 南瑞主站一次连接过程中会多次发送STARTDT，并清零发送接收序号，与标准不符，先屏蔽检查
                // 序号检查投入才检查ACK。
                if (pRunSet->bTT_104ChkAck)
                {
                    if (Num.ss != pt104->RecvNum.ss)
                    {
                        char log_info[128];
                        IEC104_printf("IEC104(%d) Reset: 报文发送帧号错误(Num=%d,RecvNum=%d)!\r\n", pt104->chnl, Num.ss, pt104->RecvNum.ss);
                        IEC104_ActiveClose(pt104);
                        pt104->bRecvOk = false;

                        sprintf(log_info, "IEC104(%d):The message sends the frame number error(Num=%d,RecvNum=%d)", pt104->chnl + 1, Num.ss, pt104->RecvNum.ss);
                        load_hs_log_rcd(TYPE_COMM_ERR, true, NULL, log_info, 1);
                        log_flag.com_err[pt104->chnl] = true;

                        return;
                    }
                }

                pt104->RecvNum.ss = Num.ss + 2;

                // 得到ACK序号，确认主站已接收的数据
                pd[2] &= 0xfe;
                CopySwap(pt104->AckNum.tt, &pd[2], 2, false);

                if (Num.ss != pt104->RecvNum.ss) // 序列号不检查,但接收到发送序列号错误，电科院一二次融合错误
                {
                    pt104->AckNum.ss = pt104->SendNum.ss;
                }
                if (IEC104_Ack(pt104) != 0)
                {
                    IEC104_ActiveClose(pt104);
                    pt104->bRecvOk = false;
                    return;
                }

                // 以下开始处理ASDU的内容
                // 检查装置地址
                addr = pd[8] | (pd[9] << 8);
                if (addr != tRunPara.byAddr && addr != 0xFFFF)
                {
                    char log_info[128];
                    // 公共地址不对，返回原报文，并将COT设置为46(未知应用服务数据单元公共地址).
                    IEC104_Echo_I(pt104, IEC_COT_UN_CA | IEC_COT_PN, true);
                    IEC104_printf("IEC104(%d) recv error: state=%d,addr=%d,ADDR0=%d!\r\n", pt104->chnl, pt104->state, addr, tRunPara.byAddr);

                    sprintf(log_info, "IEC104(%d):Recv error,state=%d,addr=%d,ADDR0=%d", pt104->chnl + 1, pt104->state, addr, tRunPara.byAddr);
                    load_hs_log_rcd(TYPE_COMM_ERR, true, NULL, log_info, 1);
                    log_flag.com_err[pt104->chnl] = true;
                    if (soe_check(EV_COMM1_ERR + pt104->chnl) == false && get_104_link_status(pt104->chnl - CFG_UART_NUM_MAX))
                    {
                        soe_record_ev(EV_COMM1_ERR + pt104->chnl, 1, 0, 0, 0); // 记录该端口通信状态
                    }
                    cls_104_link_status(pt104->chnl - CFG_UART_NUM_MAX);
                    break;
                }

                // 检查确认完毕，开始正式处理报文
                ti = *(pd + 4);
                cot = *(pd + 6);
                switch (ti) // 类型标示判断
                {
                case 100: // 总查询
                    // 检查COT
                    if (cot != IEC_COT_ACT)
                    {
                        IEC104_Echo_I(pt104, IEC_COT_UN_COT | IEC_COT_PN, true);
                        break;
                    }
                    IEC104_CallAll(pt104, *(pd + 13));
                    lnk_call_all();
                    // 104网络通信异常
                    if (soe_check(EV_COMM1_ERR + pt104->chnl))
                    {
                        // rt_printf("104 ok,com=%d\r\n",pt104->chnl-CFG_UART_NUM_MAX);
                        soe_record_ev(EV_COMM1_ERR + pt104->chnl, 0, 0, 0, 0); // 记录该端口通信状态
                    }
                    set_104_link_status(pt104->chnl - CFG_UART_NUM_MAX);
                    break;

                case 101: // 电度总查询
                    // 检查COT
                    if (cot != IEC_COT_ACT)
                    {
                        IEC104_Echo_I(pt104, IEC_COT_UN_COT | IEC_COT_PN, false);
                        break;
                    }
                    IEC104_DDAll(pt104, *(pd + 13));
                    break;

                case 45: // 遥控命令单点
                case 46: // 遥控命令双点
                    // 检查单双点是否和参数设置相符
                    if ((ti == 45 && tRunPara.YKtype == 1) || (ti == 46 && tRunPara.YKtype == 0))
                    {
                        // 对不支持的类型标识，返回原报文，并将COT设置为44(未知类型标识).
                        IEC104_Echo_I(pt104, IEC_COT_UN_TI | IEC_COT_PN, true);
                        rt_printf("104遥控类型不符(ti=%d,YKtype=%d)\r\n", ti, tRunPara.YKtype);
                        break;
                    }

                    // 检查COT
                    if (cot != IEC_COT_ACT && cot != IEC_COT_DEACT)
                    {
                        IEC104_Echo_I(pt104, IEC_COT_UN_COT | IEC_COT_PN, false);
                        break;
                    }
                    IEC104_RmtCtrl(pt104, (pd + 6), *(pd + 4)); // 从传送原因开始
                    break;
                case 103:
                    // 检查COT
                    if (cot == IEC_COT_ACT || cot == IEC_COT_REQ)
                    {
                        IEC104_SetTime(pt104, (pd + 13), cot);
                    }
                    else
                    {
                        IEC104_Echo_I(pt104, IEC_COT_UN_COT | IEC_COT_PN, false);
                    }
                    break;
                case 105:
                    // 检查COT
                    if (cot != IEC_COT_ACT)
                    {
                        IEC104_Echo_I(pt104, IEC_COT_UN_COT | IEC_COT_PN, false);
                        break;
                    }

#ifdef FUNC_RESET_EQU
                    gb_ResetEqu = true;
#endif

                    switch (*(pd + 13)) // 复位进程命令限定词 QRP
                    {
                    // 进程的总复位
                    case 1:
                        IEC104_printf("IEC104(%d) Reset: 进程的总复位!\r\n", pt104->chnl);
                        IEC104_Echo_I_Direct(pt104, IEC_COT_ACTCON);
                        IEC104_ActiveClose(pt104);
                        pt104->bRecvOk = false;
#ifdef IEC_RESET_PROCESS
                        rt_printf("装置重启\r\n");
                        watchdog_reset_cpu(2); // 装置复位
#endif
                        return;
                        break;

                    // 复位事件缓冲区等待处理的带时标信息
                    case 2:
                        IEC104_printf("IEC104(%d) Reset: 复位事件缓冲区!\r\n", pt104->chnl);
                        IEC104_Echo_I(pt104, IEC_COT_ACTCON, false);
                        g_soe_queue.tail_send[pt104->chnl].n = g_soe_queue.head.n;
                        g_soe_queue.tail_ack[pt104->chnl].n = g_soe_queue.tail_send[pt104->chnl].n;
                        break;
                    }
                    break;

                case 122:                              // 召目录，选择文件，召唤文件，召唤节
                    IEC104_File_Echo(pt104, (pd + 4)); // 响应文件召唤
                    break;
                case 124:                              // 确认文件，确认节的应答
                    IEC104_File_Sure(pt104, (pd + 4)); // 对文件操作确认
                    break;

                case 176: //   本装置级联时的复归命令
                    ResetHzLed(0);
                    SignalReset(0, false);
                    IEC104_Echo_I(pt104, IEC_COT_ACTCON, false);
                    break;
#ifdef RCD_STRAN_S
                case RCD_TYPE: //  录波级联
                    IEC104_Rcd_Ack(pt104);
                    break;
#endif

                case 200: //  切换定值区
                    if (cot == IEC_COT_ACT)
                    {
                        IEC104_SectionWrite(pt104, &pd[13]); // Addbyte 链路地址和应用单元地址多了2个字节，传送原因多1个字节
                    }
                    else
                    {

                        IEC104_Echo_I(pt104, IEC_COT_UN_COT | IEC_COT_PN, false);
                    }
                    break;
                case 201: //  读取当前定值区号
                    if (cot == IEC_COT_ACT)
                    {
                        IEC104_SectionRead(pt104); // Addbyte 链路地址和应用单元地址多了2个字节，传送原因多1个字节
                    }
                    else
                    {
                        IEC104_Echo_I(pt104, IEC_COT_UN_COT | IEC_COT_PN, false);
                    }
                    break;
                case 202: // 读参数

                    if (cot == IEC_COT_ACT)
                    {
                        int ret;
#ifdef YPARA_LINK
                        ret = iec_setread_mananger((void *)pt104, &pd[10], pd[5], true);
#else
                        ret = iec_setread((void *)pt104, &pd[10], pd[5], true); // vsq为需读参数的个数，0，代表读全部参数，参数为从定值区开始的数据
#endif
                        if (ret != 0) // 读定值出错，否定应答
                        {
                            IEC104_Echo_I(pt104, IEC_COT_UN_OA, false);
                        }
                    }
                    else
                    {
                        IEC104_Echo_I(pt104, IEC_COT_UN_COT | IEC_COT_PN, false);
                    }
                    break;
                case 203: //  修改参数
                    if (cot == IEC_COT_ACT || cot == IEC_COT_DEACT)
                    {
                        int ret;
                        BYTE rcot = IEC_COT_UN_OA;
#ifdef YPARA_LINK
                        int link_ch;
                        link_ch = get_ypara_linkch_write((void *)pt104, &pd[10], pd[5], true);
                        if (link_ch == 0)
                        {
                            rt_printf("104------写本地定值\r\n");
                            ret = iec_setwrite((void *)pt104, &pd[10], cot, pd[5], true); // vsq为需读参数的个数，0，代表固化参数，参数为从定值区开始的数据
                            if (ret != 0)                                                 // 写定值出错，否定应答
                            {
                                if (cot == IEC_COT_DEACT)
                                    rcot = IEC_COT_DEACTCON | IEC_COT_PN;
                                else
                                    rcot = IEC_COT_ACTCON | IEC_COT_PN;
                            }
                            else
                            {
                                if (cot == IEC_COT_DEACT)
                                    rcot = IEC_COT_DEACTCON;
                                else
                                    rcot = IEC_COT_ACTCON;
                            }

                            IEC104_Echo_I(pt104, rcot, false);
                        }
                        else
                        {
                            IEC104_Rmt_msg_ypara_write(pt104, &pd[10], pd[5], link_ch);

                            if ((link_ch & 0x1f) == 0x1f) /*广播写直接返回确认*/
                            {
                                if (cot == IEC_COT_DEACT)
                                    rcot = IEC_COT_DEACTCON;
                                else
                                    rcot = IEC_COT_ACTCON;

                                IEC104_Echo_I(pt104, rcot, false);
                            }
                        }
#else
                        ret = iec_setwrite((void *)pt104, &pd[10], cot, pd[5], true); // vsq为需读参数的个数，0，代表固化参数，参数为从定值区开始的数据
                        if (ret != 0)                                                 // 写定值出错，否定应答
                        {
                            if (cot == IEC_COT_DEACT)
                                rcot = IEC_COT_DEACTCON | IEC_COT_PN;
                            else
                                rcot = IEC_COT_ACTCON | IEC_COT_PN;
                        }
                        else
                        {
                            if (cot == IEC_COT_DEACT)
                                rcot = IEC_COT_DEACTCON;
                            else
                                rcot = IEC_COT_ACTCON;
                        }
                        IEC104_Echo_I(pt104, rcot, false);
#endif
                    }
                    else
                    {
                        IEC104_Echo_I(pt104, IEC_COT_UN_COT | IEC_COT_PN, false);
                    }
                    break;

                case FOS_PAR_READ_ONE:     // 南网佛山局 读取单个参数
                case FOS_PAR_READ_MUL:     // 南网 读取多个参数
                case FOS_PAR_SET_ONE:      // 南网佛山局 设置单个参数
                case FOS_PAR_SET_MUL:      // 南网 设置多数参数
                case FOS_PAR_READ_ONE_EXT: // 南网佛山局 读取单个参数
                case FOS_PAR_READ_MUL_EXT: // 南网 读取多个参数
                case FOS_PAR_SET_ONE_EXT:  // 南网佛山局 设置单个参数
                case FOS_PAR_SET_MUL_EXT:  // 南网 设置多数参数

                    // 检查COT
                    if (cot != IEC_COT_ACT && cot != IEC_COT_DEACT)
                    {
                        rt_printf("COT检查未通过....\n\r");
                        IEC104_Echo_I(pt104, IEC_COT_UN_COT | IEC_COT_PN, false);
                    }
                    else
                    {
                        rt_printf("\r\n进入读/写定值处理流程....\n\r");
                        IEC104_ParCtrl(pt104, &pd[0]);
                    }
                    break;

                case 210: // 文件传输
                {
                    pt104->tf.vsq = pd[5];
                    if (cot == IEC_COT_ACT || cot == IEC_COT_REQ)
                    {
                        int ret;
                        ret = iec_file_app((void *)pt104, &pt104->arrRecvBuf[15], cot, pt104->arrRecvBuf[1] - 14, true); // 从操作标识开始
                        if (ret != 0)                                                                                    // 文件处理错误
                        {
                            BYTE rcot = IEC_COT_UN_OA;
                            if (ret == -2)
                                rcot = IEC_COT_UN_COT;
                            IEC104_Echo_I(pt104, rcot, false);
                        }
                    }
                    else
                    {
                        IEC104_Echo_I(pt104, IEC_COT_UN_COT | IEC_COT_PN, false);
                    }
                }
                break;

                case 211: // 软件升级
                {
                    if (cot == IEC_COT_ACT || cot == IEC_COT_DEACT)
                    {
                        int ret;
                        ret = iec_pro_update((void *)pt104, cot, pd[13], true); // 从操作标识开始
                        if (ret != 0)                                           // 文件处理错误
                        {
                            BYTE rcot = IEC_COT_UN_OA;
                            IEC104_Echo_I(pt104, rcot, false);
                        }
                    }
                    else
                    {
                        IEC104_Echo_I(pt104, IEC_COT_UN_COT | IEC_COT_PN, false);
                    }
                }
                break;

                default:
                    // 对不支持的类型标识，返回原报文，并将COT设置为44(未知类型标识).
                    IEC104_Echo_I(pt104, IEC_COT_UN_TI | IEC_COT_PN, false);
                    break;
                }
                break;

            // S格式
            case 0x01:
                // 得到ACK
                pd[2] &= 0xfe;
                CopySwap(Num.tt, &pd[2], 2, false);

                pt104->AckNum.ss = Num.ss;

                // 如果是STOPPED状态，不允许接收S帧
                if (pt104->state == IEC104_ST_STOPPED)
                {
                    char log_info[128];

                    IEC104_printf("IEC104(%d) Reset: STOPPED状态接收到S帧(AckNum=%d)!\r\n", pt104->chnl, Num.ss);
                    IEC104_ActiveClose(pt104);
                    pt104->bRecvOk = false;

                    sprintf(log_info, "IEC104(%d):The STOPPED state receives the S frame(AckNum=%d)", pt104->chnl + 1, Num.ss);
                    load_hs_log_rcd(TYPE_COMM_ERR, true, NULL, log_info, 1);
                    log_flag.com_err[pt104->chnl] = true;

                    return;
                }
                else
                {
                    // 如果不是STOPPED状态，需确认发送数据
                    if (IEC104_Ack(pt104) != 0)
                    {
                        IEC104_ActiveClose(pt104);
                        pt104->bRecvOk = false;
                        return;
                    }

                    // 如果是PENDING状态，检查所有发送数据是否已确认，如果确认，进入STOPPED状态
                    if (pt104->state == IEC104_ST_PENDING)
                    {
                        if (pt104->SendNum.ss == pt104->AckNum.ss)
                        {
                            IEC104_Echo_US(pt104, FRAME_U_STOP_ACK);

                            IEC104_printf("IEC104(%d) state: S帧(%d => %d)!\r\n", pt104->chnl, pt104->state, IEC104_ST_STOPPED);
                            pt104->state = IEC104_ST_STOPPED;
                        }
                    }
                }
                break;

            // U格式
            case 0x03:
                // 特殊命令，打开维护工具端口
                if (pd[1] == 0x55 && pd[2] == 0xaa && pd[3] == 0xff)
                {
                    net_maintain_init();
                }
                // Test有效
                else if ((*pd) & 0x40)
                {
                    // 104标准规约要求，在三种状态下都应回应测试帧，
                    // 但如果规约进入连接断开状态后,TCP连接没有真正断开(串口104有可能出现此现象)，
                    // 此时不应应答测试帧，让主站由于收不到测试帧应答，主动断开TCP连接，否则，主站旧连接持续存在，
                    // 规约层由于没有收到STARTED命令，不能发送数据，将导致数据不能主动上送。
                    // 目前，由于在IEC104_IsCurFrame会拦截不符合要求的报文，所以此处条件可以删除
                    // 170802:恢复IEC104_ST_STARTED条件，以免链路异常复位后主站重连不发STARTDT,通过测试帧保持连接。
                    if (pt104->state == IEC104_ST_STARTED)
                    {
                        IEC104_Echo_US(pt104, FRAME_U_TEST_ACK);
                    }
                }
                // StopDT有效
                else if ((*pd) & 0x10)
                {
                    if (pt104->SendNum.ss == pt104->AckNum.ss)
                    {
                        IEC104_Echo_US(pt104, FRAME_U_STOP_ACK);

                        IEC104_printf("IEC104(%d) state: StopDT(%d => %d)!\r\n", pt104->chnl, pt104->state, IEC104_ST_STOPPED);
                        pt104->state = IEC104_ST_STOPPED;
                    }
                    else
                    {
                        IEC104_printf("IEC104(%d) state: StopDT(%d => %d)!\r\n", pt104->chnl, pt104->state, IEC104_ST_PENDING);
                        pt104->state = IEC104_ST_PENDING;
                    }
                }
                // StartDT有效
                else if ((*pd) & 0x04)
                {
                    // 104标准规约要求，发送、接收序号在连接建立后设置为0，
                    // 在STARTDT/STOPDT切换过程中不修改，发送和接收计数器继续运行。
                    // 但使用串口104时，没有办法得到连接建立和断开状态，所以在此处建立连接。
                    if (pt104->type == IEC104_TYPE_RS)
                    {
                        IEC104_Reset(pt104);

                        IEC104_printf("IEC104(%d) state: 串口连接(%d => %d)!\r\n", pt104->chnl, pt104->state, IEC104_ST_STOPPED);
                        pt104->state = IEC104_ST_STOPPED;
                    }

                    IEC104_Echo_US(pt104, FRAME_U_SATRT_ACK);

                    // 南瑞主站一次连接过程中会多次发送STARTDT，并清零发送接收序号，与标准不符
                    // pt104->SendNum.ss=0;
                    // pt104->RecvNum.ss=0;

                    // 连接之后，首次进入IEC104_ST_STARTED，发送初始化结束帧和老的SOE
                    IEC104_printf("IEC104(%d) state: StartDT(%d => %d)!\r\n", pt104->chnl, pt104->state, IEC104_ST_STARTED);
                    if (pt104->state != IEC104_ST_STARTED)
                    {
                        pt104->state = IEC104_ST_STARTED;
                        g_comm_link_status |= (1 << pt104->chnl);

                        {
                            char buf[64];
                            char log_info[128];
                            if (pt104->type == IEC104_TYPE_NET)
                            {
                                sprintf(buf, "104主站连接(%sIP=%d.%d.%d.%d)!\r\n", get_comm_name(pt104->chnl + 1), pt104->ip[0], pt104->ip[1], pt104->ip[2], pt104->ip[3]);
                            }
                            else
                            {
                                sprintf(buf, "104主站连接(%s)!\r\n", get_comm_name(pt104->chnl + 1));
                            }

                            log_str_time(LOG_OPERATE, buf, 0, 1);

                            sprintf(log_info, "IEC104(%d):104 main station connection", pt104->chnl + 1);
                            load_hs_log_rcd(TYPE_CHNL_LINK, true, NULL, log_info, 1);

                            if (log_flag.com_err[pt104->chnl] == true)
                            {
                                memset(log_info, 0, sizeof(log_info));
                                sprintf(log_info, "IEC104(%d):Communication process anomaly return", pt104->chnl + 1);
                                load_hs_log_rcd(TYPE_COMM_ERR, true, NULL, log_info, 0);
                                log_flag.com_err[pt104->chnl] = false;
                            }
                        }

                        // 在2006版104规约中，初始化结束帧在规约上是可选的，且明确要求在FRAME_U_SATRT_ACK后。
                        // 2006版之前的规约没有明确此帧和FRAME_U_SATRT_ACK帧的先后关系，采用2006版标准。
                        IEC104_InitOK(pt104);

                        // "重新连接后，总召前，发送完所有老的SOE,不发送COS"
                        IEC104_SendEvent(pt104, 0);
                    }
                }
                pt104->bClientStart = true;
                break;
            default:
                break;
            }

            // 清Test计数器
            pt104->us0_test = ustimer_get_origin();
            pt104->bStartTest = false;
        }

        pt104->bRecvOk = false;
    }

#if 0 // 湖南104为客户端模式，并且在连接到主站后，要首先发送启动帧
	if(tRunPara.b104Client&&(net_104_is_connect(pt104->cNetIndex)))
	{
		if(!pt104->bClientStart)
		{
			if(ustimer_get_duration(pt104->us0_client) > 2*USTIMER_SEC)
			{
				IEC104_Echo_US(pt104,FRAME_U_SATRT);
				pt104->us0_client= ustimer_get_origin();
			}			
		}
	}
#endif
    // 如果连接没有建立，直接返回
    if (pt104->state == 0)
    {
        return;
    }
#ifdef YPARA_LINK_S
    if (tRunPara.b_ypar_slave)
        IEC104_lnk_set_up(pt104);
#endif

    // 如果TCP连接已断开，复位返回
    if (pt104->type != IEC104_TYPE_RS)
    {
        if (!net_104_is_connect(pt104->cNetIndex))
        {
            IEC104_printf("IEC104_App:连接已断开.\r\n");
            IEC104_Reset(pt104);
            if (soe_check(EV_COMM1_ERR + pt104->chnl) == false && get_104_link_status(pt104->chnl - CFG_UART_NUM_MAX))
            {
                soe_record_ev(EV_COMM1_ERR + pt104->chnl, 1, 0, 0, 0); // 记录该端口通信状态
            }
            cls_104_link_status(pt104->chnl - CFG_UART_NUM_MAX);
            return;
        }
    }
    // 104  超过W值，应答 S帧
    if (pt104->RecvNum.ss > pt104->AckRecvNum)
    {
        if ((pt104->RecvNum.ss - pt104->AckRecvNum) >= tRunPara.w104W)
        {
            IEC104_Echo_US(pt104, FRAME_S);
        }
    }
    // 104发送处理
    IEC104_Send_Polling(pt104);

    // 处理加密遥控报文标志超时返回
    if (pRunSet->bTT_SM2)
    {
        if (ustimer_get_duration(pt104->us0_SM2Over) > 60 * USTIMER_SEC)
        {
            pt104->bRmtSM2 = false;
        }
    }

    // 根据遥测上送间隔查询遥测值
    cnt = rt_round(tRunPara.fYcTime * USTIMER_SEC);
    if (ustimer_get_duration(pt104->us0_yc) > cnt)
    {
        IEC104_SendYC(pt104);

        pt104->us0_yc += cnt;
    }

    // 定时任务
    IEC104_Timer(pt104);

    // 1秒处理
    if (ustimer_get_duration(pt104->us0_sec) > USTIMER_SEC)
    {
        pt104->us0_sec += USTIMER_SEC;
        pt104->secs++;
    }

    return;
}

int IEC104_Ether_App(void)
{
    int net;

    for (net = 0; net < CFG_ETH_MAX_LOGIC; net++)
    {
        IEC104_App(&g_t104[net]);
    }

    return 0;
}

void IEC104_Info_Printf_One(IEC104_DEF *p)
{
    iec_tbuf_t *pt;

    rt_printf("\r\n通道属性:type=%d,chnl=%d,cNetIndex=%d\r\n", p->type, p->chnl, p->cNetIndex);
    if (p->state == 0)
    {
        return;
    }
    rt_printf("  连接计数:net=%d,app=%d,recv=%d\r\n", p->LinkCountNet, p->LinkCountApp, p->LinkCountRecv);
    rt_printf("  规约状态:state=%d,bSendChange=%d\r\n", p->state, p->bSendChange);
    rt_printf("  序号记录:SendNum=%d,RecvNum=%d,AckNum=%d\r\n", p->SendNum.ss, p->RecvNum.ss, p->AckNum.ss);
    rt_printf("帧接收处理:bRecvOk=%d,cTypeCounter=%d,cRecvLenth=%d,cRecvCnt=%d\r\n", p->bRecvOk, p->cTypeCounter, p->cRecvLenth, p->cRecvCnt);
    rt_printf("      计时:us0_yc=0x%x,us0_sec=0x%x,secs=%d\r\n", p->us0_yc, p->us0_sec, p->secs);
    rt_printf("测试帧发送:bStartTest=%d,us0_test_wait=%d,us0_test=%d\r\n", p->bStartTest, p->us0_test_wait, p->us0_test);
    pt = &p->TxBuf[0];
    rt_printf("发送BUF[0]:head=%d,tail_send=%d,tail_ack=%d\r\n", pt->tb_head, pt->tb_tail_send, pt->tb_tail_ack);
    pt = &p->TxBuf[1];
    rt_printf("发送BUF[1]:head=%d,tail_send=%d,tail_ack=%d\r\n", pt->tb_head, pt->tb_tail_send, pt->tb_tail_ack);
    rt_printf("SOE通讯BUF:head=%d,tail_send=%d,tail_ack=%d\r\n", g_soe_queue.head.n, g_soe_queue.tail_send[p->chnl].n, g_soe_queue.tail_ack[p->chnl].n);
    rt_printf("SOE事件BUF:head=%d,tail_send=%d\r\n",
              g_soe_queue.head.n, g_soe_queue.tail_eep.n);

    return;
}

int IEC104_Info_Printf(void)
{
    int i;
    IEC104_DEF *p;

    // 网络104
    rt_printf("\r\n网络104:");
    for (i = 0; i < CFG_ETH_MAX_LOGIC; i++)
    {
        p = &g_t104[i];
        IEC104_Info_Printf_One(p);
    }

    // 串口104
    rt_printf("\r\n串口104:");
    for (i = 0; i < CFG_UART_NUM_MAX; i++)
    {
        if (tRunPara.tUartPara[i].wProtocol != PROTOCOL_104)
        {
            rt_printf("\r\n通道属性:非104通道(chnl=%d)\r\n", i);
            continue;
        }

        p = (IEC104_DEF *)g_tRsComm[i].ptBuf;
        IEC104_Info_Printf_One(p);
    }

    return 0;
}

void IEC104_AddFrame(IEC104_DEF *pt104, BYTE *dat, int len, BYTE vsq, BYTE cot, BYTE type) //
{
    BYTE *pd = &pt104->arrSendBuf[6];
    *pd++ = type;
    *pd++ = vsq;
    *pd++ = cot; // 传送原因
    *pd++ = 0;
    *pd++ = (BYTE)tRunPara.byAddr;        // 应用服务数据单元地址
    *pd++ = (BYTE)(tRunPara.byAddr >> 8); // 应用服务数据单元地址 6
    memcpy(pd, dat, len);
    IEC104_Send(pt104, FRAME_I_PRIOR_LOW, len + 6);
}

void IEC104_AddFrame_dz(IEC104_DEF *pt104, BYTE *dat, int len, BYTE vsq, BYTE cot, BYTE type, bool addone)
{
    BYTE *pd = &pt104->arrSendBuf[6];
    BYTE dat_tmp[256];
    int i, j = 0, k = 0;
    *pd++ = type;
    *pd++ = vsq;
    *pd++ = cot; // 传送原因
    *pd++ = 0;
    *pd++ = (BYTE)tRunPara.byAddr;        // 应用服务数据单元地址
    *pd++ = (BYTE)(tRunPara.byAddr >> 8); // 应用服务数据单元地址 6
    if (addone)
    { /*主站通过104遥调时，因管理机与级联间仍为101通讯，管理机对级联报文处理回给主站时，
      因级联给管理机的报文为2位地址位+4位数据位，管理机需自行增加1位地址位，即3位地址位+4位数据位以满足104报文要求*/
        for (i = 0; i < (len + vsq); i++)
        {
            if ((type == FOS_PAR_READ_MUL) || (type == FOS_PAR_READ_ONE))
            {
                if (2 == i % 7)
                {
                    dat_tmp[j++] = 0;
                }
                else
                {
                    dat_tmp[j++] = dat[k++];
                }
            }
            else if ((type == FOS_PAR_SET_MUL) || (type == FOS_PAR_SET_ONE))
            {
                if (2 == i % 8)
                {
                    dat_tmp[j++] = 0;
                }
                else
                {
                    dat_tmp[j++] = dat[k++];
                }
            }
        }

        memcpy(pd, dat_tmp, len + vsq);
        len += vsq;
    }
    else
    {
        memcpy(pd, dat, len);
    }
    IEC104_Send(pt104, FRAME_I_PRIOR_LOW, len + 6);
}

/************************************************下面是远方修改定值代码******************************************************/

void IEC104_RmtSet_Echo(IEC104_DEF *pt104, BYTE *dat, BYTE cot, int len) //
{

    BYTE *pd = &pt104->arrSendBuf[6]; // 从第7个字节开始
    int i;

    *pd++ = dat[0]; // 总召唤确认帧	  1   1
    *pd++ = dat[1]; // 可变结构限定词  2
    *pd++ = cot;    // 传送原因： 否定应答
    *pd++ = 0;      // 传送原因：               4
    *pd++ = dat[4]; // 应用服务数据单元地址 5
    *pd++ = dat[5]; // 应用服务数据单元地址 6
    *pd++ = dat[6]; // 信息体地址L  7
    *pd++ = dat[7]; // 信息体地址H  8
    *pd++ = dat[8]; // 信息体地址H  9
    for (i = 0; i < len; i++)
    {
        *pd++ = dat[9 + i]; // 信息值
    }

    IEC104_Send(pt104, FRAME_I, 9 + len); // 应答
}

void IEC104_setion_chg_msg(IEC104_DEF *pt104, u8 *ps)
{
#ifdef YPARA_LINK
    WORD section;
    msg_data_struct *msg_data = &temp_par;
    msg_oper_setion_struct *setion_msg = &msg_data->setion_msg;

    section = ps[0] + (ps[1] << 8); // 定值区号
    msg_data->sport = pt104->chnl;
    msg_data->dport = 0x1F; // 进行广播
    msg_data->type = settion_swht;

    setion_msg->section_p = section;
    mananger_msg_ypara_s(msg_data, msg_data->sport, msg_data->dport);
#endif
}

void IEC104_SectionWrite(IEC104_DEF *pt104, u8 *ps) // 确认帧
{
    BYTE *pd = &pt104->arrSendBuf[6]; // 从第7个字节开始
    BYTE cot;                         // 定值区为0，肯定应答，其他否定应答
    int num = 0;
    WORD section;
    if (pRunSet->wEquTypeManager)
        IEC104_setion_chg_msg(pt104, ps);
    section = ps[0] + (ps[1] << 8); // 定值区号
    cot = 0x47;
    if (section < SEC_NUMBER)
    {
        m_dstsection = section;
        if (mmd_changesection(section) == M_JUMP0)
            cot = 0x07;
    }
    pd[num++] = 200;                          // 总召唤确认帧	  1   1
    pd[num++] = 1;                            // 可变结构限定词  2
    pd[num++] = cot;                          // 传送原因： 否定应答
    pd[num++] = 0;                            // 传送原因：
    pd[num++] = (BYTE)tRunPara.byAddr;        // 应用服务数据单元地址
    pd[num++] = (BYTE)(tRunPara.byAddr >> 8); // 应用服务数据单元地址 6
    pd[num++] = 0;                            // 信息体地址L  7
    pd[num++] = 0;                            // 信息体地址H  8
    pd[num++] = 0;                            // 信息体地址H  9
    pd[num++] = ps[0];                        // 当前定值区
    pd[num++] = ps[1];                        // 当前定值区
    IEC104_Send(pt104, FRAME_I, num);         // 应答
}

void IEC104_SectionRead(IEC104_DEF *pt104) // 读定值区
{

    BYTE *pd = &pt104->arrSendBuf[6]; // 从第7个字节开始
    BYTE cot = IEC_COT_ACTCON;        // 定值区为0，肯定应答，其他否定应答
    int num = 0;
    pd[num++] = 201;                          // 总召唤确认帧	  1   1
    pd[num++] = 1;                            // 可变结构限定词  2
    pd[num++] = cot;                          // 传送原因： 否定应答
    pd[num++] = 0;                            // 传送原因：
    pd[num++] = (BYTE)tRunPara.byAddr;        // 应用服务数据单元地址
    pd[num++] = (BYTE)(tRunPara.byAddr >> 8); // 应用服务数据单元地址 6
    pd[num++] = 0;                            // 信息体地址L  7
    pd[num++] = 0;                            // 信息体地址H  8
    pd[num++] = 0;                            // 信息体地址H  9
    pd[num++] = (u8)m_runsection;             // 当前定值区
    pd[num++] = (u8)(m_runsection >> 8);      // 当前定值区
    pd[num++] = 0;                            // 最小定值区
    pd[num++] = 0;                            // 最小定值区
    pd[num++] = SEC_NUMBER - 1;               // 最大定值区1
    pd[num++] = 0;                            // 最大定值区2

    IEC104_Send(pt104, FRAME_I, num); // 应答
}

/**************************************************远方修改定值结束*****************************************************/

/***********************************************下面是104规约文件传输部分代码2016-8-10**************************************************/

/**************************************************************************
函数名称：IEC104_Direct_Echo
函数版本：1.00
作者：
创建日期：2007.9.1
函数功能说明：104规约目录响应
输出参数：pt104缓冲区地址，COT 传送原因
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/

static void IEC104_Direct_Echo(IEC104_DEF *pt104, DWORD InfoAddr)
{
    BYTE *pd = &pt104->arrSendBuf[6]; // 从第7个字节开始
    BYTE vsq = 0;
    int i;
    int filenum;
    struct dir_file_struct *pdir, *pdirfree;
    // 根据信息体地址，判断读读哪个目录，获取目录信息

    *pd++ = 126; // 总召唤确认帧	  1   1
    *pd++ = vsq; // 可变结构限定词  2
    *pd++ = 5;   // 传送原因：               3
    *pd++ = 0;   // 传送原因：               4

    *pd++ = (BYTE)tRunPara.byAddr;        // 应用服务数据单元地址 5
    *pd++ = (BYTE)(tRunPara.byAddr >> 8); // 应用服务数据单元地址 6

    *pd++ = (BYTE)InfoAddr;         // 信息体地址L  7
    *pd++ = (BYTE)(InfoAddr >> 8);  // 信息体地址H  8
    *pd++ = (BYTE)(InfoAddr >> 16); // 信息体地址H  9

    pdir = hf_get_dir_file(IEC_Getdir(InfoAddr), &filenum);
    if (pdir == NULL)
    {
        IEC104_Send(pt104, FRAME_I, 9); // 无文件应答
        return;
    }
    pdirfree = pdir;
    for (i = 0; i < filenum; i++)
    {
        struct rtc_time_t rtc;
        /*文件名称*/
        *pd++ = (BYTE)(pdir->file_name);
        *pd++ = (BYTE)(pdir->file_name >> 8);

        /*文件长度*/
        *pd++ = (BYTE)(pdir->file_size);
        *pd++ = (BYTE)(pdir->file_size >> 8);
        *pd++ = (BYTE)(pdir->file_size >> 16);

        /*文件的状态SOF*/
        *pd++ = 0;

        /*日历时钟*/
        timespec_to_rtc(pdir->file_time, &rtc, 1);
        *pd++ = (BYTE)(rtc.ms);
        *pd++ = (BYTE)(rtc.ms >> 8);
        *pd++ = (BYTE)(rtc.min);
        *pd++ = (BYTE)(rtc.hour);
        *pd++ = (BYTE)(rtc.day);
        *pd++ = (BYTE)(rtc.month);
        *pd++ = (BYTE)(rtc.year);
        vsq++;
        if ((vsq >= 15) && i < (filenum - 1)) // 目录超出一帧上送范围，分帧，VSQ置后续标准位
        {
            pt104->arrSendBuf[7] = vsq | 0x80;
            IEC104_Send(pt104, FRAME_I, 9 + vsq * 13); // 有文件应答
            vsq = 0;
            pd = &pt104->arrSendBuf[15];
        }
        pdir++;
    }
    rt_free(pdirfree);
    if (vsq > 0)
    {
        pt104->arrSendBuf[7] = vsq;
        if (vsq > 1)
        {
            pt104->arrSendBuf[7] |= 0x80;
        }
        IEC104_Send(pt104, FRAME_I, 9 + vsq * 13); // 有文件应答
    }
    else
    {
        IEC104_Send(pt104, FRAME_I, 9); // 无文件应答
    }
}

/**************************************************************************
函数名称：IEC104_EchoFileReady
函数版本：1.00
作者：
创建日期：2007.9.1
函数功能说明：应答文件准备好
输出参数：pt104缓冲区地址，filename 文件名
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/

static void IEC104_EchoFileReady(IEC104_DEF *pt104, DWORD InfoAddr, WORD filename)
{
    BYTE *pd = &pt104->arrSendBuf[6]; // 从第7个字节开始
    int filelenth, sectionnum;
    // 根据信息体地址，判断读读哪个目录，获取目录信息

    filelenth = hf_get_file_inf(IEC_Getdir(InfoAddr), filename, &sectionnum);
    *pd++ = 120;                          // 总召唤确认帧	  1   1
    *pd++ = 1;                            // 可变结构限定词  2
    *pd++ = 13;                           // 传送原因：13               3
    *pd++ = 0;                            // 传送原因：               4
    *pd++ = (BYTE)tRunPara.byAddr;        // 应用服务数据单元地址 5
    *pd++ = (BYTE)(tRunPara.byAddr >> 8); // 应用服务数据单元地址 6

    *pd++ = (BYTE)InfoAddr;         // 信息体地址L  7
    *pd++ = (BYTE)(InfoAddr >> 8);  // 信息体地址H  8
    *pd++ = (BYTE)(InfoAddr >> 16); // 信息体地址H  9
    /*文件名称*/
    *pd++ = (BYTE)(filename);      // 10
    *pd++ = (BYTE)(filename >> 8); // 11

    *pd++ = (BYTE)filelenth;         // 文件长度
    *pd++ = (BYTE)(filelenth >> 8);  // 文件长度
    *pd++ = (BYTE)(filelenth >> 16); // 文件长度
    if (filelenth > 0)
    {
        *pd++ = 0; /*FRQ=0肯定认可*/
    }
    else
    {
        *pd++ = 0x80; /*FRQ=0否定定认可*/
    }
    pt104->tfile.filelenth = filelenth;
    pt104->tfile.setctionnum = sectionnum;
    pt104->tfile.filename = filename;
    pt104->tfile.InfoAddr = InfoAddr;
    pt104->tfile.filechecksum = 0;
    IEC104_Send(pt104, FRAME_I, 15); // 应答
}

/**************************************************************************
函数名称：IEC104_EchoSectionReady
函数版本：1.00
作者：
创建日期：2007.9.1
函数功能说明：应答节准备好
输出参数：pt104缓冲区地址，filename 文件名
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/

static void IEC104_EchoSectionReady(IEC104_DEF *pt104, DWORD InfoAddr, WORD filename, BYTE section)
{
    BYTE *pd = &pt104->arrSendBuf[6]; // 从第7个字节开始
    int setctionlenth;
    char *pdat = NULL;

    IEC104_FreeFile(pt104);

    *pd++ = 121;                          // 总召唤确认帧	  1   1
    *pd++ = 1;                            // 可变结构限定词  2
    *pd++ = 13;                           // 传送原因：13               3
    *pd++ = 0;                            // 传送原因：               4
    *pd++ = (BYTE)tRunPara.byAddr;        // 应用服务数据单元地址 5
    *pd++ = (BYTE)(tRunPara.byAddr >> 8); // 应用服务数据单元地址 6
    *pd++ = (BYTE)InfoAddr;               // 信息体地址L  7
    *pd++ = (BYTE)(InfoAddr >> 8);        // 信息体地址H  8
    *pd++ = (BYTE)(InfoAddr >> 16);       // 信息体地址H  9
    /*文件名称*/
    *pd++ = (BYTE)(filename);                                                                                          // 10
    *pd++ = (BYTE)(filename >> 8);                                                                                     // 11
    if (pt104->tfile.InfoAddr == InfoAddr && pt104->tfile.filename == filename && section <= pt104->tfile.setctionnum) // 文件名相同文件有效
    {
        pdat = hf_get_file_part(IEC_Getdir(InfoAddr), filename, section, &setctionlenth);
    }

    *pd++ = section; // 节名
    /*节长度长度*/
    *pd++ = (BYTE)(setctionlenth);       // 12
    *pd++ = (BYTE)(setctionlenth >> 8);  // 13
    *pd++ = (BYTE)(setctionlenth >> 16); // 14
    if (pdat == NULL || setctionlenth == 0)
    {
        *pd++ = 0x80; /*FRQ=0否定定认可*/
    }
    else
    {
        *pd++ = 0x0; /*FRQ=0 肯定认可*/ // 15
        pt104->tfile.pdat = pdat;       // 保存节内容地址，后续需要释放
        pt104->tfile.sectionlenth = setctionlenth;
        pt104->tfile.transsection = section;
        pt104->tfile.bFiletransing = true;
        pt104->tfile.bSegtransing = false;
        pt104->tfile.us0_file_trans = ustimer_get_origin();
        pt104->tfile.transBytes = 0;
        pt104->tfile.sectionchecksum = 0;
    }
    IEC104_Send(pt104, FRAME_I, 16); // 应答
}

/**************************************************************************
函数名称：IEC104_SegmentSend
函数版本：1.00
作者：
创建日期：2007.9.1
函数功能说明：应答节传输中段的数据
输出参数：pt104缓冲区地址，filename 文件名,section 节名
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/

static void IEC104_SegmentSend(IEC104_DEF *pt104, DWORD InfoAddr, WORD filename, BYTE section)
{
    BYTE *pd = &pt104->arrSendBuf[6]; // 从第7个字节开始
    BYTE sectionchecksum = 0;         // 节校验和
    BYTE segmentbytes, cot;
    int i;

    cot = 13;
    segmentbytes = 0;
    if (pt104->tfile.bFiletransing && pt104->tfile.InfoAddr == InfoAddr && pt104->tfile.filename == filename && section == pt104->tfile.transsection) // 文件名相同 节相同
    {
        if (pt104->tfile.transBytes + FILE_SEGMENT_BYTES >= pt104->tfile.sectionlenth)
        {
            segmentbytes = pt104->tfile.sectionlenth % FILE_SEGMENT_BYTES; // 最后的段的字节数
        }
        else
        {
            segmentbytes = FILE_SEGMENT_BYTES;
        }

        pt104->tfile.sectionchecksum = sectionchecksum;
        pt104->tfile.us0_file_trans = ustimer_get_origin();
        pt104->tfile.bSegtransing = true;
    }
    else
    {
        cot |= 0x40;
        IEC104_FreeFile(pt104);
    }
    *pd++ = 125;                          // 总召唤确认帧	  1   1
    *pd++ = 1;                            // 可变结构限定词  2
    *pd++ = cot;                          // 传送原因：13               3
    *pd++ = 0;                            // 传送原因：               4
    *pd++ = (BYTE)tRunPara.byAddr;        // 应用服务数据单元地址 5
    *pd++ = (BYTE)(tRunPara.byAddr >> 8); // 应用服务数据单元地址 6
    *pd++ = (BYTE)InfoAddr;               // 信息体地址L  7
    *pd++ = (BYTE)(InfoAddr >> 8);        // 信息体地址H  8
    *pd++ = (BYTE)(InfoAddr >> 16);       // 信息体地址H  9
    /*文件名称*/
    *pd++ = (BYTE)(filename);      // 10
    *pd++ = (BYTE)(filename >> 8); // 11
    *pd++ = section;               // 节名  12
    *pd++ = segmentbytes;          // 段的长度 13
    for (i = 0; i < segmentbytes; i++)
    {
        *pd = pt104->tfile.pdat[pt104->tfile.transBytes++];
        sectionchecksum += *pd++;
    }
    IEC104_Send(pt104, FRAME_I, 13 + segmentbytes); // 应答
}

/**************************************************************************
函数名称：IEC104_EchoLastSection
函数版本：1.00
作者：
创建日期：2007.9.1
函数功能说明：应答最后的节或段
输出参数：pt104缓冲区地址，filename 文件名,section 节名,LSQ限定词
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/

static void IEC104_EchoLastSection(IEC104_DEF *pt104, WORD filename, BYTE section, BYTE LSQ)
{
    BYTE *pd = &pt104->arrSendBuf[6];            // 从第7个字节开始
    *pd++ = 123;                                 // 总召唤确认帧	  1   1
    *pd++ = 1;                                   // 可变结构限定词  2
    *pd++ = 13;                                  // 传送原因：13               3
    *pd++ = 0;                                   // 传送原因：               4
    *pd++ = (BYTE)tRunPara.byAddr;               // 应用服务数据单元地址 5
    *pd++ = (BYTE)(tRunPara.byAddr >> 8);        // 应用服务数据单元地址 6
    *pd++ = (BYTE)pt104->tfile.InfoAddr;         // 信息体地址L  7
    *pd++ = (BYTE)(pt104->tfile.InfoAddr >> 8);  // 信息体地址H  8
    *pd++ = (BYTE)(pt104->tfile.InfoAddr >> 16); // 信息体地址H  9
    /*文件名称*/
    *pd++ = (BYTE)(filename);      // 10
    *pd++ = (BYTE)(filename >> 8); // 11
    *pd++ = section;               // 节名  12

    switch (LSQ)
    {
    case 1:
        *pd++ = 1;                         // LSQ=1：不带停止激活文件传输13
        *pd++ = pt104->tfile.filechecksum; // 文件校验和 14

        break;
    case 3:
        *pd++ = 3;                            // LSQ=3：不带停止激活的节传输
        *pd++ = pt104->tfile.sectionchecksum; // 节校验和
        break;
    }

    IEC104_Send(pt104, FRAME_I, 14); // 应答
}

/**************************************************************************
函数名称：IEC104_SegmentContinue
函数版本：1.00
作者：
创建日期：2007.9.1
函数功能说明：主循环中继续发送节中剩余的段
输出参数：pt104缓冲区地址，filename 文件名,section 节名
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/
bool dddd = false;

void IEC104_SegmentContinue(IEC104_DEF *pt104)
{
    BYTE *pd = &pt104->arrSendBuf[6]; // 从第7个字节开始
    BYTE sectionchecksum = 0;         // 节校验和
    BYTE segmentbytes;
    int i;

    if (dddd)
    {
        IEC104_Direct_Echo(pt104, 0x0cea);
        dddd = false;
    }

    if (!pt104->tfile.bSegtransing)
        return;

    if (IEC104_BufFree(&pt104->TxBuf[1]) < (IEC_TBUF_NUM >> 2))
    {
        return;
    }
    if (pt104->tfile.transBytes < pt104->tfile.sectionlenth) // 段还未传输完毕
    {
        if (pt104->tfile.transBytes + FILE_SEGMENT_BYTES >= pt104->tfile.sectionlenth)
        {
            segmentbytes = pt104->tfile.sectionlenth % FILE_SEGMENT_BYTES; // 最后的段的字节数
        }
        else
        {
            segmentbytes = FILE_SEGMENT_BYTES;
        }
        *pd++ = 125;                                 // 总召唤确认帧	  1   1
        *pd++ = 1;                                   // 可变结构限定词  2
        *pd++ = 13;                                  // 传送原因：13               3
        *pd++ = 0;                                   // 传送原因：               4
        *pd++ = (BYTE)tRunPara.byAddr;               // 应用服务数据单元地址 5
        *pd++ = (BYTE)(tRunPara.byAddr >> 8);        // 应用服务数据单元地址 6
        *pd++ = (BYTE)pt104->tfile.InfoAddr;         // 信息体地址L  7
        *pd++ = (BYTE)(pt104->tfile.InfoAddr >> 8);  // 信息体地址H  8
        *pd++ = (BYTE)(pt104->tfile.InfoAddr >> 16); // 信息体地址H  9
        /*文件名称*/
        *pd++ = (BYTE)(pt104->tfile.filename);      // 10
        *pd++ = (BYTE)(pt104->tfile.filename >> 8); // 11
        *pd++ = pt104->tfile.transsection;          // 节名  12

        *pd++ = segmentbytes; // 段的长度 13

        for (i = 0; i < segmentbytes; i++)
        {
            *pd = pt104->tfile.pdat[pt104->tfile.transBytes++];
            sectionchecksum += *pd++;
        }
        pt104->tfile.sectionchecksum += sectionchecksum;
        pt104->tfile.us0_file_trans = ustimer_get_origin();
        IEC104_Send(pt104, FRAME_I, 13 + segmentbytes); // 应答
    }
    else
    {
        IEC104_EchoLastSection(pt104, pt104->tfile.filename, pt104->tfile.transsection, 3);
        IEC104_FreeFile(pt104);
    }
}

void IEC104_File_Respone(IEC104_DEF *pt104, BYTE *dat, BYTE cot, BYTE SCAFQ) //
{

    BYTE *pd = &pt104->arrSendBuf[6]; // 从第7个字节开始

    *pd++ = dat[0]; // 总召唤确认帧	  1   1
    *pd++ = dat[1]; // 可变结构限定词  2
    *pd++ = cot;    // 传送原因： 否定应答
    *pd++ = 0;      // 传送原因：               4
    *pd++ = dat[4]; // 应用服务数据单元地址 5
    *pd++ = dat[5]; // 应用服务数据单元地址 6
    *pd++ = dat[6]; // 信息体地址L  7
    *pd++ = dat[7]; // 信息体地址H  8
    *pd++ = dat[8]; // 信息体地址H  9

    *pd++ = dat[9];                  // 10
    *pd++ = dat[10];                 // 11
    *pd++ = dat[11];                 // 节名  12
    *pd++ = SCAFQ;                   // 限定词
    IEC104_Send(pt104, FRAME_I, 13); // 应答
}

/**************************************************************************
函数名称：IEC104_File_Echo
函数版本：1.00
作者：
创建日期：2007.9.1
函数功能说明：对文件召唤的应答处理
输出参数：pt104缓冲区地址，dat报文缓冲区地址从报文的帧类型开始
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/

void IEC104_File_Echo(IEC104_DEF *pt104, BYTE *dat) // dat 从报文的帧类型开始
{
    BYTE COT, SCQ;          // 传送原因
    WORD filename, section; // 文件名 节名
    DWORD InfoAddr;         // 信息体地址

    COT = dat[2];
    InfoAddr = dat[6] + (dat[7] << 8) + (dat[8] << 16);
    filename = dat[9] + (dat[10] << 8); // 文件名
    section = dat[11];                  // 节名
    SCQ = dat[12];                      // 选择和召唤限定词

    // rt_printf("\r\n COT=%d addr=%4x filename=%d,section=%d,SCQ=%d",COT,InfoAddr,filename,section,SCQ);

    if (IEC_Getdir(InfoAddr) == NULL)
    {
        IEC104_File_Respone(pt104, dat, (47 | 0x40), SCQ); // 否定应答，未知的信息体地址
        return;
    }

    if (COT == 5) /*请求目录 */
    {
        IEC104_Direct_Echo(pt104, InfoAddr); /*目录响应 cot =5代表召唤目录*/
    }
    else if (COT == 13)
    {
        switch (SCQ)
        {
        case 1: /*选择文件*/
            IEC104_EchoFileReady(pt104, InfoAddr, filename);
            break;
        case 2:                                                          /*请求文件*/
            IEC104_EchoSectionReady(pt104, InfoAddr, filename, section); // 节准备好报文
            break;
        case 6:                                                     /*请求节*/
            IEC104_SegmentSend(pt104, InfoAddr, filename, section); // 发送本节中所有的段
            break;
        default:
            IEC104_File_Respone(pt104, dat, COT, SCQ | 0x30); // 否定应答，非所希望的通信服务
            break;
        }
    }
    else
    {
        IEC104_File_Respone(pt104, dat, (45 | 0x40), SCQ); // 否定应答，未知的传送原因
    }
}

/**************************************************************************
函数名称：IEC104_File_Sure
函数版本：1.00
作者：
创建日期：2007.9.1
函数功能说明：对文件处理的确认应答
输出参数：pt缓冲区地址，dat报文缓冲区地址从报文的帧类型开始
返回值：

更新信息：
更新日志1：
日期：
修改者：
修改内容：
修改原因：
***************************************************************************/

void IEC104_File_Sure(IEC104_DEF *pt104, BYTE *dat) // dat 从报文的帧类型开始
{

    BYTE COT, AFQ;          // 传送原因
    WORD filename, section; // 文件名 节名
    DWORD InfoAddr;         // 信息体地址

    COT = dat[2];
    InfoAddr = dat[6] + (dat[7] << 8) + (dat[8] << 16);
    filename = dat[9] + (dat[10] << 8); // 文件名
    section = dat[11];                  // 节名
    AFQ = dat[12];                      // 选择和召唤限定词

    if (IEC_Getdir(InfoAddr) == NULL)
    {
        IEC104_File_Respone(pt104, dat, (47 | 0x40), AFQ); // 否定应答，未知的信息体地址
        return;
    }
    if (COT != 13)
    {
        IEC104_File_Respone(pt104, dat, (45 | 0x40), AFQ); // 否定应答，未知的传送原因
    }

    switch (AFQ) /*AFQ文件确认或节确认*/
    {
    case 1: // 文件传输的正确认可
        IEC104_FreeFile(pt104);
        IEC104_File_Respone(pt104, dat, COT, AFQ); // 需商讨，文件传输完毕后，对文件的确认，需要上送什么信息合适，以前是上送更新后的目录 sunxi
        break;
    case 2: // 文件传输的否定认可
        IEC104_FreeFile(pt104);
        IEC104_File_Respone(pt104, dat, COT, AFQ); // 需商讨，文件传输完毕后，对文件的确认，需要上送什么信息合适，以前是上送更新后的目录 sunxi
        break;
    case 3: // 节传输的正确认可

        IEC104_FreeFile(pt104);
        if (pt104->tfile.transsection < pt104->tfile.setctionnum - 1) // 不是最后的节
        {
            pt104->tfile.filechecksum += pt104->tfile.sectionchecksum; // 文件校验和
            section += 1;
            IEC104_EchoSectionReady(pt104, InfoAddr, filename, section); // 下一节准备好
        }
        else if (section >= pt104->tfile.setctionnum - 1) // 最后的节
        {
            IEC104_EchoLastSection(pt104, filename, section, 1); // LSQ = 3;      最后的段
        }
        break;
    case 4: // 节传输的否定认可
        IEC104_FreeFile(pt104);
        IEC104_EchoSectionReady(pt104, InfoAddr, filename, section); // 节准备好报文
        break;
    default:
        break;
    }
}

void IEC104_FreeFile(IEC104_DEF *pt104)
{
    if (pt104->tfile.bFiletransing)
    {
        pt104->tfile.bFiletransing = false;
        pt104->tfile.bSegtransing = false;
        if (!pt104->tfile.pdat)
        {
            rt_free(pt104->tfile.pdat);
            pt104->tfile.pdat = NULL;
        }
        rt_printf("\r\nIEC104文件节传输完毕，释放内存，文件:%d 节:%d\r\n", pt104->tfile.filename, pt104->tfile.transsection);
    }
}