/******************************************************************** 版权所有： 文件版本： V1.00 文件名称： IEC104.c 生成日期： 2007年04月26日 作 者：xxxxxx 使用范围： 功 能： IEC104规约处理 更新信息： 更新日志1： 修改者: 修改日期: 修改内容: 修改原因: *********************************************************************/ #include "head.h" #ifdef LINUX_KERNEL_APP #include #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长度，L3chnl); // 统计接收帧数 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, §ionnum); *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); } }