/******************************************************************** 版权所有： 文件版本： V1.00 文件名称： IEC101.c 生成日期： 2010年04月26日 作 者：hhw 使用范围： 功 能： IEC101规约处理 更新信息： 更新日志1 修改者: 修改日期: 修改内容: 修改原因: *********************************************************************/ #include "head.h" u32 IEC101_SendEvent(IEC101_DEF *pt, int is_send_cos); void IEC101_Info_Printf_One(IEC101_DEF *p); extern int gprs_vs_write(const unsigned char *buf, int count); GPRS_INF_DEF tGprsInf; static void IEC101_State(IEC101_DEF *pt101, int state) { if (pt101->st101 != state) { char buf[64]; char log_info[128]; rt_printf_time("IEC101(%d) state: %d => %d!\r\n", pt101->chnl, pt101->st101, state); pt101->st101 = state; if (state == IEC101_ST_DATA) { sprintf(buf, "101主站连接(%s)!\r\n", get_comm_name(pt101->chnl + 1)); log_str_time(LOG_OPERATE, buf, 0, 1); sprintf(log_info, "IEC101(%d):101 main station connection", pt101->chnl + 1); load_hs_log_rcd(TYPE_CHNL_LINK, true, NULL, log_info, 1); if (log_flag.com_err[pt101->chnl] == true) { memset(log_info, 0, sizeof(log_info)); sprintf(log_info, "IEC101(%d):Communication process anomaly return", pt101->chnl + 1); load_hs_log_rcd(TYPE_COMM_ERR, true, NULL, log_info, 0); log_flag.com_err[pt101->chnl] = false; } // SOE发送缓冲区复位，发送指针回到ACK的位置 if (pRunSet->bTT_SoeResumeComm) { #ifdef SOE_RELINK_DISCOS if (!g_soe_queue.bSoeRelink[pt101->chnl]) { // g_soe_queue.relink_tail_bak[pt101->chnl].n = g_soe_queue.tail_send[pt101->chnl].n; g_soe_queue.relink_tail_bak[pt101->chnl].n = g_soe_queue.tail_eep.n; } g_soe_queue.bSoeRelink[pt101->chnl] = true; #endif // pt101->bSoeRelink = true; g_soe_queue.tail_send[pt101->chnl].n = g_soe_queue.tail_ack[pt101->chnl].n; } } else if (state == IEC101_ST_NONE) { sprintf(buf, "101主站断开(%s)!\r\n", get_comm_name(pt101->chnl + 1)); log_str_time(LOG_OPERATE, buf, 0, 0); sprintf(log_info, "IEC101(%d):101 main station disconnection", pt101->chnl + 1); load_hs_log_rcd(TYPE_CHNL_LINK, true, NULL, log_info, 0); } } return; } static void IEC101_ResetTxBuf(IEC101_DEF *pt101) { pt101->btx_buf_m = false; pt101->btx_buf_s = false; memset(&pt101->tx_buf, 0, sizeof(pt101->tx_buf)); } static void IEC101_Reset(IEC101_DEF *pt101) { // 通道属性、连接计数不允许复位 // 规约状态复位 g_comm_link_status &= ~(1 << pt101->chnl); IEC101_State(pt101, IEC101_ST_NONE); pt101->bSendChange = false; // 计时 pt101->us0_sec = ustimer_get_origin(); pt101->secs = 0; pt101->us0_sendpiece = ustimer_get_origin(); // 对时 pt101->us0_frame = 0; pt101->ms_delay = 0; // 1级、2级数据发送 pt101->bFirstFCV = 1; pt101->tb_index = -1; pt101->FCBSave = 0; // 遥测发送处理 pt101->bycsend = FALSE; pt101->ycno = 0; pt101->us0_yc = ustimer_get_origin(); memset(pt101->yc_save, 0, sizeof(pt101->yc_save)); // 其它状态复位 pt101->bRmtSM2 = false; pt101->dValidTime = 0; pt101->bMSend = false; pt101->bDIR = true; pt101->bResetProcess = false; pt101->tm.us0_callall = dTCounter; // 不能用微妙定时器，最多支持13分钟 pt101->tm.bAppEcho = false; // pt101->bSoeRelink = false; pt101->bTimeSyn = false; #if 0 // SOE发送缓冲区复位，发送指针回到ACK的位置 if(pRunSet->bTT_SoeResumeComm) { #ifdef SOE_RELINK_DISCOS if(!g_soe_queue.bSoeRelink[pt101->chnl]) { //g_soe_queue.relink_tail_bak[pt101->chnl].n = g_soe_queue.tail_send[pt101->chnl].n; g_soe_queue.relink_tail_bak[pt101->chnl].n = g_soe_queue.tail_eep.n; } g_soe_queue.bSoeRelink[pt101->chnl] = true; #endif //pt101->bSoeRelink = true; g_soe_queue.tail_send[pt101->chnl].n=g_soe_queue.tail_ack[pt101->chnl].n; } #endif // 遥控信息复位 ResetRctrl(MASTER_101 + pt101->chnl); // 发送缓冲区复位 IEC101_ResetTxBuf(pt101); RS_Recv_Enable(pt101->chnl); #ifdef RCD_STRAN_S rt_printf_time("-> Link Reset, Clear File Cache\r\n"); iec_freefile(&pt101->tf); pt101->tf.bTransing = false; pt101->tf.bdatTraned = false; #endif } void IEC101_Init(IEC101_DEF *pt, u8 chnl) { // 接收帧间隔为重发间隔时间的一半 g_tRsComm[chnl].us_recv_timeout = pRunSet->dT101Resend * USTIMER_SEC / 2; memset(pt, 0, sizeof(IEC101_DEF)); pt->type = IEC101_CHN; pt->chnl = chnl; pt->bMaintainComm = false; if (tRunPara.tUartPara[chnl].wProtocol == PROTOCOL_MAINTAIN) { pt->bMaintainComm = true; } // 初始化接收buf结构 pt->rx_buf.chn = pt->chnl; pt->rx_buf.buf = pt->recvbuf; rt_fifo_init(&pt->recv_fifo, pt->recv_fifo_buf, IEC101_FIFO_SIZE); #ifdef RCD_STRAN_S queue_init(&pt->rcd_qt.queue, NEWRCD_COUNT, &pt->rcd_qt.data, NEWRCD_SIZE); #endif IEC101_Reset(pt); } /************************************************************************** 函数名称：IEC101_Send 函数版本：1.00 作者： 创建日期：2008.9.1 函数功能说明：启动485口的数据发送 输入参数： 输出参数： 返回值： 更新信息： 更新日志1： 日期： 修改者： 修改内容： 修改原因： ***************************************************************************/ void IEC101_SSend(IEC101_DEF *pt) { u8 *sb = g_tRsComm[pt->chnl].sendbuf; // 如果链路层没有数据，直接返回 if (pt->btx_buf_s == false) { return; } // 有数据，复制到真正的发送BUF并清标志 memcpy(sb, pt->tx_buf_s, pt->tx_buf_s[0] + 1); pt->btx_buf_s = false; // 置发送标志 RS_Send_Enable(pt->chnl); g_tRsComm[pt->chnl].nSendCnt = 1; // 发送缓冲区的第一个字节为发送长度 pt->bSend = true; if (!g_bCommLed) g_bCommLed = true; if (UART_CHANNEL[pt->chnl] == CFG_UART_GPRS_IN) { // gprs_vs_write(&sb[1], sb[0]); pt->bSend = false; s_stat_tx((int)pt->chnl, sb[0]); } #ifdef FUN_FUXI_ESAM if (UART_CHANNEL[pt->chnl] == CFG_UART_CHIP_S1) { write_chip_s1(&sb[1], sb[0]); pt->bSend = false; } #endif if (g_print_101 && (g_print_port & (1 << pt->chnl))) { rt_printf("TX_S101_%d:", pt->chnl); print_msg("", &sb[1], sb[0]); } // 统计发送帧数 s_stat_tx_frame((int)pt->chnl); } /************************************************************************** 函数名称：IEC101_MSend 函数版本：1.00 作者： 创建日期：2008.9.1 函数功能说明：平衡101，作为主站发送 输入参数： 输出参数： 返回值： 更新信息： 更新日志1： 日期： 修改者： 修改内容： 修改原因： ***************************************************************************/ static void IEC101_MSend(IEC101_DEF *pt) { u8 *sb = g_tRsComm[pt->chnl].sendbuf; // 如果链路层没有数据，直接返回 if (pt->btx_buf_m == false) { return; } // 有数据，复制到真正的发送BUF并清标志 memcpy(sb, pt->tx_buf_m, pt->tx_buf_m[0] + 1); pt->btx_buf_m = false; // 置发送标志 RS_Send_Enable(pt->chnl); g_tRsComm[pt->chnl].nSendCnt = 1; pt->bSend = true; if (!g_bCommLed) g_bCommLed = true; if (UART_CHANNEL[pt->chnl] == CFG_UART_GPRS_IN) { // gprs_vs_write(&sb[1], sb[0]); pt->bSend = false; s_stat_tx((int)pt->chnl, sb[0]); } #ifdef FUN_FUXI_ESAM if (UART_CHANNEL[pt->chnl] == CFG_UART_CHIP_S1) { write_chip_s1(&sb[1], sb[0]); pt->bSend = false; } #endif if (g_print_101 && (g_print_port & (1 << pt->chnl))) { rt_printf("TX_M101_%d:", pt->chnl); print_msg("", &sb[1], sb[0]); } // 统计发送帧数 s_stat_tx_frame((int)pt->chnl); } static void IEC101_ext_send(IEC101_DEF *pt, u8 *buf, u16 len) { #ifdef FUNC_ENCRY_IN_ONE_SERIAL if ((tRunPara.tUartPara[0].wProtocol == PROTOCOL_WED_ENC) && pt->chnl == 1) { // 投入纬德规约时，串口通道1/3/4的待发数据统一由串口通道0发送处理 u8 *sb = g_tRsComm[0].extsendbuf_1; memcpy(sb, buf, len); g_tRsComm[0].extsendcnt_1 = 0; g_tRsComm[0].extsendlen_1 = len; g_tRsComm[0].bextsend_1 = true; } else if ((tRunPara.tUartPara[0].wProtocol == PROTOCOL_WED_ENC) && pt->chnl == 3) { // 投入纬德规约时，串口通道1/3/4的待发数据统一由串口通道0发送处理 u8 *sb = g_tRsComm[0].extsendbuf_2; memcpy(sb, buf, len); g_tRsComm[0].extsendcnt_2 = 0; g_tRsComm[0].extsendlen_2 = len; g_tRsComm[0].bextsend_2 = true; } else if ((tRunPara.tUartPara[0].wProtocol == PROTOCOL_WED_ENC) && pt->chnl == 4) { // 投入纬德规约时，串口通道1/3/4的待发数据统一由串口通道0发送处理 u8 *sb = g_tRsComm[0].extsendbuf_3; memcpy(sb, buf, len); g_tRsComm[0].extsendcnt_3 = 0; g_tRsComm[0].extsendlen_3 = len; g_tRsComm[0].bextsend_3 = true; } else #endif { u8 *sb = g_tRsComm[pt->chnl].extsendbuf; memcpy(sb, buf, len); g_tRsComm[pt->chnl].extsendcnt = 0; g_tRsComm[pt->chnl].extsendlen = len; g_tRsComm[pt->chnl].bextsend = true; } } static void IEC101_Send_Polling(IEC101_DEF *pt) { #ifdef FUNC_ENCRY_IN_ONE_SERIAL int i = 0, j = 0, crc_sum = 0; #endif u8 *buf; #ifdef FUNC_ENCRY_IN_ONE_SERIAL memset(&g_tRsComm[pt->chnl].enc_sendbuf, 0, sizeof(&g_tRsComm[pt->chnl].enc_sendbuf)); #endif // 如果串口忙，不能发送数据 if (g_tRsComm[pt->chnl].bextsend #ifdef FUNC_ENCRY_IN_ONE_SERIAL || g_tRsComm[0].bextsend_1 || g_tRsComm[0].bextsend_2 || g_tRsComm[0].bextsend_3 #endif ) { pt->us0_sendpiece = ustimer_get_origin(); return; } if (pt->bSend) // 有数据要发送了 { int len = g_tRsComm[pt->chnl].sendbuf[0]; #ifdef FUNC_ENCRY_IN_ONE_SERIAL if (tRunPara.tUartPara[0].wProtocol == PROTOCOL_WED_ENC) { // 纬德规约内容组包 g_tRsComm[pt->chnl].enc_sendbuf[i++] = 0xAA; g_tRsComm[pt->chnl].enc_sendbuf[i++] = (u8)(len); // 数据报文长度 g_tRsComm[pt->chnl].enc_sendbuf[i++] = (u8)((len) >> 8); g_tRsComm[pt->chnl].enc_sendbuf[i++] = pt->enc_tunnel; memcpy(&g_tRsComm[pt->chnl].enc_sendbuf[i], &g_tRsComm[pt->chnl].sendbuf[1], len); i = i + len; for (j = 1; j < i; j++) { crc_sum = crc_sum + g_tRsComm[pt->chnl].enc_sendbuf[j]; } g_tRsComm[pt->chnl].enc_sendbuf[i++] = (u8)crc_sum; g_tRsComm[pt->chnl].enc_sendbuf[i++] = 0x55; buf = &g_tRsComm[pt->chnl].enc_sendbuf[0]; len = i; } else #endif { buf = &g_tRsComm[pt->chnl].sendbuf[1]; } if (pRunSet->bTT_ESAM && (!pt->bMaintainComm)) { u8 ti, cot, se; u8 *out; iec_GetMsgInfo(buf, len, &ti, &cot, &se, true); len = sec_encrpt_iec(ti, cot, se, buf, len, &out); if (len > 0) { IEC101_ext_send(pt, out, len); } } else { IEC101_ext_send(pt, buf, len); } pt->bSend = false; return; } if (ustimer_get_duration(pt->us0_sendpiece) < USTIMER_MS * 5) // 发送帧之间间隔5ms { return; } // 如果有从动站数据，发送 if (pt->btx_buf_s) { IEC101_SSend(pt); pt->us0_sendpiece = ustimer_get_origin(); } // 如果有启动站数据，发送 else if (pt->btx_buf_m) { IEC101_MSend(pt); pt->us0_sendpiece = ustimer_get_origin(); } else if (pt->bEchosecmd5) { u8 md5buf[24]; u16 len; len = sec_md5_echo(md5buf); IEC101_ext_send(pt, md5buf, len); pt->bEchosecmd5 = false; } } /************************************************************************** 函数名称：IEC101_GetOneBuf 函数版本：1.00 作者： 创建日期：2008.9.1 函数功能说明：将数据添加到一级数据缓冲区 输入参数：pt 各通道101结构定义首地址，ps源数据地址 输出参数： 返回值： 更新信息： 更新日志1： 日期： 修改者： 修改内容： 修改原因： ***************************************************************************/ static int IEC101_BufFreeNum(iec_tbuf_t *pt) { return (pt->tb_tail_ack - pt->tb_head - 1) & (IEC_TBUF_NUM - 1); } static u16 IEC101_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) { rt_printf_time("IEC101: IEC101_GetOneBuf error:head=%d,send=%d,ack=%d.\r\n", pt->tb_head, pt->tb_tail_send, pt->tb_tail_ack); } return head; } /************************************************************************** 函数名称：IEC101_FrameEcho 函数版本：1.00 作者： 创建日期：2008.9.1 函数功能说明：应答短帧报文 输入参数：pt 各通道101结构定义首地址，ZoneByte短政控制域 输出参数： 返回值： 更新信息： 更新日志1： 日期： 修改者： 修改内容： 修改原因： ***************************************************************************/ static void IEC101_FrameEcho(IEC101_DEF *pt, unsigned char ZoneByte) { u8 *pd = pt->tx_buf_s; // 如果此时正在发送数据，说明逻辑不对 if (pt->btx_buf_s) { rt_printf("IEC101_FrameEcho(%d) err:链路层BUF已有数据\r\n", pt->chnl); } // 更新ACD或DIR位 if (tRunPara.tUartPara[pt->chnl].b101PH) { // 平衡101，DIR置1 if (!pt->bDIR) { IEC101_SETDIR(ZoneByte); } } else { // 目前所有数据都当成一级数据，等新标准正式颁布后再分一、二级数据。 // 非平衡101， 如果还有一级数据，设置ACD位 if ((pt->tx_buf[0].tb_head != pt->tx_buf[0].tb_tail_send) || (pt->tx_buf[1].tb_head != pt->tx_buf[1].tb_tail_send) || (pt->tx_buf[2].tb_head != pt->tx_buf[2].tb_tail_send)) { IEC101_SETACD(ZoneByte); } } // 形成报文 if (!tRunPara.b101Addr2Byte) { pd[0] = 5; pd[1] = 0x10; pd[2] = ZoneByte; pd[3] = (u8)tRunPara.byAddr; pd[4] = pd[2] + pd[3]; pd[5] = 0x16; } else { pd[0] = 6; pd[1] = 0x10; pd[2] = ZoneByte; pd[3] = (u8)tRunPara.byAddr; pd[4] = (u8)(tRunPara.byAddr >> 8); pd[5] = pd[2] + pd[3] + pd[4]; pd[6] = 0x16; } } /************************************************************************** 函数名称：IEC101_GetClassOne 函数版本：1.00 作者： 创建日期：2008.9.1 函数功能说明：从一级数据缓冲区里读取数据 输入参数： 输出参数： 返回值： 更新信息： 更新日志1： 日期： 修改者： 修改内容： 修改原因： ***************************************************************************/ static void IEC101_UpdateCOS(u8 *pd) { u8 sq, num, i, ti; u16 cp; u8 addr = 0; // 传送原因双字节 u8 SIQ; if (tRunPara.b101Cot2Byte) addr++; if (tRunPara.b101App2Byte) addr++; ti = pd[0]; sq = pd[1] & 0x80; num = pd[1] & 0x7f; cp = pd[4 + addr] | (pd[5 + addr] << 8); pd += (6 + addr); 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 += 2; } else { cp++; } } } // 101可变帧长中信息体相对于帧头的地址。 u32 IEC101_InfoAddr(void) { u32 addr; // 10 = 68 L L 68 CTRL LADDR TYPE VSQ COT PADDR addr = 10; if (tRunPara.b101Addr2Byte) addr++; if (tRunPara.b101App2Byte) addr++; if (tRunPara.b101Cot2Byte) addr++; return addr; } static bool IEC101_SendOneBuf(IEC101_DEF *pt101) { u16 i, len, frm_attr, cnt; u8 *pd, cs, tb_send; iec_tbuf_t *pt; // 还有上帧数据没有发送完，直接返回。逻辑上不应该有这种现象出现 if (tRunPara.tUartPara[pt101->chnl].b101PH ? pt101->btx_buf_m : pt101->btx_buf_s) { RT_PRINTF_POSITION(); return false; } // 运行到这，如果有数据就无条件发送 for (i = 0; i < 3; i++) { pt = &pt101->tx_buf[i]; if (pt->tb_head == pt->tb_tail_send) { continue; } // 更新发送尾指针,保留老指针备用。 // 由于系统设计时保证发送BUF队列不会溢出，所以指针先加也是没有问题的。 tb_send = pt->tb_tail_send; pt->tb_tail_send++; // 拷贝数据并设置控制域 len = pt->tb_data[tb_send][0]; if (tRunPara.tUartPara[pt101->chnl].b101PH) { u8 zone; // 获取数据 pd = pt101->tx_buf_m; memcpy(pd, pt->tb_data[tb_send], len + 1); // 平衡101，将控制域修改，原来一级数据缓冲区中为8，现在需要变为3 zone = IEC101_CALL_DATA; // 合纵FTU现场，测试长帧，功能码需回2，不能是3 (原来为3，不合理) if (pd[7 + tRunPara.b101Addr2Byte] == 104) // 长帧测试帧 { zone = IEC101_CALL_TESTLINK; pt101->bTestFrameL = true; } // 梅州FTU，101主站总召前，通讯续传不回确认帧 if ((pd[7 + tRunPara.b101Addr2Byte] == 0x1e) && (pt101->bSendChange == 0)) // SOE { pt101->bSoeResume = true; } IEC101_SETFCV(zone); // FCV位有效 IEC101_SETPRM(zone); if (!pt101->bDIR) IEC101_SETDIR(zone); if (pt101->bMFCB) { IEC101_SETFCB(zone); } else { IEC101_CLRFCB(zone); } pd[5] = zone; } else { // 获取数据 pd = pt101->tx_buf_s; memcpy(pd, pt->tb_data[tb_send], len + 1); // 目前所有数据都当成一级数据，等新标准正式颁布后再分一、二级数据。 // 非平衡101，如果还有一级数据，设置ACD位 if ((pt101->tx_buf[0].tb_head != pt101->tx_buf[0].tb_tail_send) || (pt101->tx_buf[1].tb_head != pt101->tx_buf[1].tb_tail_send) || (pt101->tx_buf[2].tb_head != pt101->tx_buf[2].tb_tail_send)) { IEC101_SETACD(pd[5]); } } // 更新低优先级的COS frm_attr = pt->tb_info[tb_send].frm_attr; if ((frm_attr & (FRAME_I_PRIOR_LOW | FRAME_I_COS)) == (FRAME_I_PRIOR_LOW | FRAME_I_COS)) { IEC101_UpdateCOS(pd + 7 + tRunPara.b101Addr2Byte); } // 如果是延时获取帧，校验和计算前计算延时 if (frm_attr & FRAME_I_106) { u16 ms; u8 *info_addr; info_addr = pd + 1 + IEC101_InfoAddr(); ms = info_addr[2] + (info_addr[3] << 8); ms += ustimer_get_duration(pt101->us0_frame) / USTIMER_MS; info_addr[0] = 0; info_addr[1] = 0; info_addr[2] = ms; info_addr[3] = ms >> 8; } // 计算校验和 cs = 0; len = pd[2]; pd = &pd[5]; for (cnt = 0; cnt < len; cnt++) // 标示拷贝 { cs += *pd++; } *pd++ = cs; // 保留发送的索引，供确认的时候用 pt101->tb_index = i; // 设置安全报文发送标志 if (frm_attr & FRAME_I_ENCRYPT) { pt101->bMSend_encrypt = true; } return true; } return false; } static void IEC101_AckOneBuf(IEC101_DEF *pt101) // 调整一级数据缓冲区，已发送数据清除 { iec_tbuf_t *pt; char log_info[128] = {0}; // 如果最后发送的遥测帧，确认遥测帧 if (pt101->bycsend) { pt101->bycsend = FALSE; return; } // 如果没有发送报文，不需要确认 if (pt101->tb_index < 0) { return; } // 如果没有需要确认的帧，返回，但这不是正常流程 pt = &pt101->tx_buf[pt101->tb_index]; pt101->tb_index = -1; if (pt->tb_tail_ack == pt->tb_tail_send) { rt_printf_time("IEC101_AckOneBuf error!\r\n"); IEC101_Info_Printf_One(pt101); sprintf(log_info, "IEC101(%d):IEC101_AckOneBuf error!", pt101->chnl + 1); load_hs_log_rcd(TYPE_COMM_ERR, true, NULL, log_info, 1); log_flag.com_err[pt101->chnl] = true; return; } // 如果是SOE报文，需确认SOE缓冲池中SOE. if (pt->tb_info[pt->tb_tail_ack].frm_attr & FRAME_I_SOE) { soe_ack(pt101->chnl, pt->tb_info[pt->tb_tail_ack].soe_tail_send); } pt->tb_tail_ack++; } /************************************************************************** 函数名称： IEC101_Asdu_Yc 函数版本：1.00 作者： 创建日期：2008.9.1 函数功能说明：通用分类数据的链路直接响应 输入参数：pt 缓冲区地址，pdat报文数据，len报文长度 vsq,inf,cot ,rii,IEC101规约要求的内容 输出参数： 返回值： 更新信息： 更新日志1： 日期： 修改者： 修改内容： 修改原因： ***************************************************************************/ static void IEC101_Asdu_Yc(IEC101_DEF *pt, u8 *pdat, u8 len, u8 vsq, u8 cot) { u8 *pd, *pdata; u8 cnt, checksum, sum; u8 AddByte = 0; sum = 0; if (tRunPara.tUartPara[pt->chnl].b101PH) { pdata = pt->tx_buf_m; } else { pdata = pt->tx_buf_s; } if (tRunPara.b101Addr2Byte) AddByte = 1; pd = &pdata[7 + AddByte]; if (tRunPara.bYcBDH) // 标度化值 { pd[sum++] = 11; // 类型标示 } else if (tRunPara.bYcFloat) // 浮点值 { pd[sum++] = 13; // 类型标示浮点数 } else { pd[sum++] = 9; // 类型标示 } pd[sum++] = vsq; // VSQ pd[sum++] = cot; // 传送原因 if (tRunPara.b101Cot2Byte) pd[sum++] = 0; // 传送原因 pd[sum++] = (u8)tRunPara.byAddr; // 应用服务单元地址 if (tRunPara.b101App2Byte) pd[sum++] = (u8)(tRunPara.byAddr >> 8); // 应用服务单元地址 for (cnt = 0; cnt < len; cnt++) // 标示拷贝 { pd[sum++] = *pdat++; } pdata[0] = (sum + 2 + 6 + AddByte); // 报文长度 +2=控制域、地址 +6=报文头（4字节）校验和、结束符 pdata[1] = 0x68; // 报文头 pdata[2] = sum + 2 + AddByte; // 数据长度 pdata[3] = sum + 2 + AddByte; pdata[4] = 0x68; if (tRunPara.tUartPara[pt->chnl].b101PH) { pdata[5] = IEC101_CALL_DATA; IEC101_SETFCV(pdata[5]); // FCV位有效 IEC101_SETPRM(pdata[5]); if (!pt->bDIR) IEC101_SETDIR(pdata[5]); if (pt->bMFCB) { IEC101_SETFCB(pdata[5]); } else { IEC101_CLRFCB(pdata[5]); } } else { pdata[5] = IEC101_ECHO_DATA; // 类型标示 } pdata[6] = (u8)tRunPara.byAddr; // 链路地址 if (tRunPara.b101Addr2Byte) pdata[7] = (u8)(tRunPara.byAddr >> 8); // 链路地址 checksum = 0; pd = &pdata[5]; for (cnt = 0; cnt < pdata[2]; cnt++) // 标示拷贝 { checksum += *pd++; } *pd++ = checksum; *pd++ = 0x16; } /************************************************************************** 函数名称：IEC101_GetYc 函数版本：1.00 作者： 创建日期：2008.9.1 函数功能说明：响应遥测帧 输入参数： 输出参数： 返回值： 更新信息： 更新日志1： 日期： 修改者： 修改内容： 修改原因： ***************************************************************************/ static bool IEC101_GetYc(IEC101_DEF *pt) { bool bContinue = false; // 是否保存当前判断的遥测位置 u8 *pd; u8 vsq; int i, num; WORD cp = 0; int ycvalue; union { float ff; u8 tt[4]; } ff; // 主动上送遥测条件: // 1、总查询结束后可送 // 2、没有在处理加密遥控报文 // 3、不是复位进程状态 // 4、主动上送遥测投入 if ((!pt->bSendChange) || pt->bRmtSM2 || pt->bResetProcess || (!tRunPara.bAutoSendYc)) { return false; } // 平衡101，主动发送不能小于发送间隔时间 if (tRunPara.tUartPara[pt->chnl].b101PH) { if ((ustimer_get_duration(pt->us0_yc) < (DWORD)rt_round(tRunPara.fYcTime * USTIMER_SEC)) || byc_filter) // { return false; } } #if defined IEC_JXYB_DEAL if (g_run_stu.bjx) return false; #endif // 得到一遥测帧 pd = g_arrIECBuf; vsq = 0; num = 0; for (i = pt->ycno; i < g_table_head->ac_num; i++) { u8 QDS = 0; // 品质描述， 默认为零 u8 no = g_ac_table[i].indexno; long lmeaval; bool bsend = false; if (g_ac_table[i].dead_value == 0 || g_ac_table[i].normal == 0) continue; // 死区或额定为零，不主动上送 if (no > 0) { DWORD dwMax = 0; DWORD dwDeadVal = 0; float rate; float f_65536 = 65536.0; u8 link_qds = 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(pt->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; // 遥测溢出 } } } #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 - pt->yc_save[i]) >= dwDeadVal))) #else if (bsend || ((i < MAX_YC_NUMBER) && (_AbsL(lmeaval - pt->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) pt->yc_save[i] = lmeaval; pd[num++] = (u8)cp; // 信息体地址L pd[num++] = (u8)(cp >> 8); // 信息体地址H if (tRunPara.bYcFloat) // 浮点值上送 { num += CopySwap(&pd[num], ff.tt, sizeof(ff.tt), true); } else { pd[num++] = (u8)(ycvalue); // 无符号整数 pd[num++] = (u8)(ycvalue >> 8); // 无符号整数 } if (g_run_stu.bjx) { QDS |= 0x80; // 带品质描述，有效 <1>：=无效 } #ifdef IEC_QDS_HAVE QDS |= link_qds; #endif pd[num++] = QDS; vsq++; } if (num > MAX_101_FRAME_LENTH) { bContinue = true; break; } } } // 更新下一帧的遥测序号 pt->ycno = bContinue ? (i + 1) : 0; // 发送遥测帧 if (num > 0) { IEC101_Asdu_Yc(pt, g_arrIECBuf, num, vsq, 3); pt->us0_yc = ustimer_get_origin(); return true; } return false; } static void IEC101_LinkInf(IEC101_DEF *pt) { // 68 bc bc 68 28 01 f0 08 14 01 01 40 00 00 00 00 00 00 00 00 00 00 00 00 00 遥测帧 // vsq cot appaddr u8 *pd, *pdata; u8 checksum, sum; int i; WORD cp; u8 num; WORD count = 0; pdata = pt->tx_buf_s; sum = 0; pd = &pdata[5]; pd[sum++] = IEC101_ECHO_DATA; // 类型标示 pd[sum++] = (u8)tRunPara.byAddr; // 链路地址 pd[sum++] = 250; // 类型标示 pd[sum++] = 8; // 长度 pd[sum++] = 14; // 传送原因 pd[sum++] = 1; // KOD pd[sum++] = 0; // 统计遥测遥信个数 cp = g_di_table[0].cp; num = 0; for (i = 0; i < g_table_head->di_num; i++) // 遥信个数统计 { if (g_di_table[i].cp == (cp + num)) { num++; } else { pd[sum++] = 1; // 遥信类型 pd[sum++] = num; pd[sum++] = (u8)cp; // 遥信个数 pd[sum++] = (u8)(cp >> 8); // 遥信个数 count++; cp = g_di_table[i].cp; num = 1; } } if (num) { pd[sum++] = 1; // 遥信类型 pd[sum++] = num; pd[sum++] = (u8)cp; // 遥信点号 pd[sum++] = (u8)(cp >> 8); // 遥信点号 count++; } cp = g_ac_table[0].cp; num = 0; for (i = 0; i < g_table_head->ac_num; i++) // 遥测个数统计 { if (g_ac_table[i].cp == (cp + num)) { num++; } else { pd[sum++] = 2; // 遥测类型 pd[sum++] = num; pd[sum++] = (u8)cp; // 遥测个数 pd[sum++] = (u8)(cp >> 8); // 遥测个数 count++; cp = g_ac_table[i].cp; num = 1; } } if (num) { pd[sum++] = 2; // 遥测类型 pd[sum++] = num; pd[sum++] = (u8)cp; // 遥测个数 pd[sum++] = (u8)(cp >> 8); // 遥测个数 count++; } pdata[0] = sum + 6; // 报文长度 +2=控制域、地址 +6=报文头（4字节）校验和、结束符 pdata[1] = 0x68; // 报文头 pdata[2] = sum; // 数据长度 pdata[3] = sum; pdata[4] = 0x68; pdata[11] = count; checksum = 0; pd = &pdata[5]; for (i = 0; i < sum; i++) // 标示拷贝 { checksum += *pd++; } *pd++ = checksum; *pd++ = 0x16; } /************************************************************************** 函数名称：IEC101_Asdu_Add 函数版本：1.00 作者： 创建日期：2008.9.1 函数功能说明：将通用分类数据添加到一级数据缓冲区中 输入参数：pt 缓冲区地址，pdat报文数据，len报文长度 vsq,inf,cot ,rii,IEC101规约要求的内容 输出参数： 返回值： 更新信息： 更新日志1： 日期： 修改者： 修改内容： 修改原因： ***************************************************************************/ static void IEC101_Asdu_Add_sts(IEC101_DEF *pt, u8 *pdat, u8 len, u8 vsq, u8 cot, u8 type, u16 attr, u16 soe_tail_send) { u8 *pd; u8 cnt, L; u16 head; iec_tbuf_t *ptb; // 获取BUF ptb = &pt->tx_buf[1]; if (attr & FRAME_I_PRIOR_HIGH) ptb = &pt->tx_buf[0]; else if (attr & FRAME_I_PRIOR_LOW) ptb = &pt->tx_buf[2]; head = IEC101_GetOneBuf(ptb); // 保存数据 ptb->tb_info[head].frm_attr = attr; ptb->tb_info[head].soe_tail_send = g_soe_queue.tail_send[pt->chnl].n; L = IEC101_InfoAddr() + len - 4; // 报文生成 pd = ptb->tb_data[head]; *pd++ = L + 6; // 报文长度 +2=控制域、地址 +6=报文头（4字节）校验和、结束符 *pd++ = 0x68; // 报文头 *pd++ = L; // 数据长度 *pd++ = L; *pd++ = 0x68; *pd++ = IEC101_ECHO_DATA; // 非平衡功能码，平衡通道发送时再修改 *pd++ = (u8)tRunPara.byAddr; // 链路地址1 if (tRunPara.b101Addr2Byte) { *pd++ = (u8)(tRunPara.byAddr >> 8); // 链路地址2 } *pd++ = type; // 类型标示 *pd++ = vsq; // VSQ *pd++ = cot; // 传送原因1 if (tRunPara.b101Cot2Byte) { *pd++ = 0; // 传送原因2 } *pd++ = (u8)tRunPara.byAddr; // 应用服务单元地址1 if (tRunPara.b101App2Byte) { *pd++ = (u8)(tRunPara.byAddr >> 8); // 应用服务单元地址2 } for (cnt = 0; cnt < len; cnt++) { *pd++ = *pdat++; // 信息体 } *pd++ = 0; // 校验和，推迟计算 *pd++ = 0x16; // 结束字符 return; } void IEC101_Asdu_Add(IEC101_DEF *pt, u8 *pdat, u8 len, u8 vsq, u8 cot, u8 type, u16 attr) { IEC101_Asdu_Add_sts(pt, pdat, len, vsq, cot, type, attr, 0); } /************************************************************************** 函数名称：IEC101_TimeSet 函数版本：1.00 作者： 创建日期：2008.9.1 函数功能说明：时间同步，并应答 输入参数： 输出参数： 返回值： 更新信息： 更新日志1： 日期： 修改者： 修改内容： 修改原因： ***************************************************************************/ static void IEC101_TimeSetEcho(IEC101_DEF *pt101, u8 *ps, u8 scot) // 确认帧 { u8 *pd; int num; int check_time = false; u8 cot; TIME ct; struct timespec ts; u8 week; // 对时 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) { u32 ms; // 计算延时，传输延时T2和发送该报文的传输耗时T3 ms = ustimer_get_duration(pt101->us0_frame) / USTIMER_MS; // rt_printf("时间设置:T2=%dms,T3=%dms.\r\n",pt101->ms_delay,ms); ms += pt101->ms_delay; // 修正时间 ct.ms += ms; if (ct.ms >= 60000) { ct.ms -= 60000; sys_time_change(&ct); } // 设置时间 sys_time_set_rmt(&ct); } } clk_time_get(&ts); timespec_to_rtc(ts, &ct, 1); // 得到星期 rtc_to_timespec(&ct, &ts); week = WEEK_DAY(ts.tv_sec); // 组织报文，以最新时间返回 pd = g_arrIECBuf; num = 0; #if defined GD_AREA_ZHONGSHAN || defined GD_AREA_ZHONGSHAN_2020 pd[num++] = 0; // 信息序号=0时钟同步 pd[num++] = 0; // 信息序号=0时钟同步 if (scot == IEC_COT_ACT) { pd[num++] = ps[0]; // MsL pd[num++] = ps[1]; // MsH pd[num++] = ps[2]; // Min pd[num++] = ps[3]; // hour pd[num++] = ps[4]; // Day pd[num++] = ps[5]; // month pd[num++] = ps[6]; // year } else { pd[num++] = (u8)ct.ms; // MsL pd[num++] = (u8)(ct.ms >> 8); // MsH pd[num++] = ct.min; // Min pd[num++] = ct.hour; // hour pd[num++] = ct.day; // Day pd[num++] = ct.month; // month pd[num++] = ct.year; // year } #else pd[num++] = 0; // 信息序号=0时钟同步 pd[num++] = 0; // 信息序号=0时钟同步 pd[num++] = (u8)ct.ms; // MsL pd[num++] = (u8)(ct.ms >> 8); // MsH pd[num++] = ct.min; // Min pd[num++] = ct.hour; // hour pd[num++] = ((week << 5) | ct.day); // Day pd[num++] = ct.month; // month pd[num++] = ct.year; // year #endif if (scot == IEC_COT_REQ) { cot = 0x05; } else { cot = check_time ? 0x07 : 0x47; // 对时内容非法，即将传送原因的P/N位置为1 } IEC101_Asdu_Add(pt101, g_arrIECBuf, num, 1, cot, 103, FRAME_I); // } static void IEC101_TestFrame(IEC101_DEF *pt101, u8 *ps) // 测试确认帧 { u8 *pd; int num; // 组织报文 pd = g_arrIECBuf; num = 0; pd[num++] = 0; // 信息体地址 pd[num++] = 0; // pd[num++] = ps[0]; // pd[num++]=0xAA; //测试码 pd[num++] = ps[1]; // pd[num++]=0x55; //测试码 IEC101_Asdu_Add(pt101, g_arrIECBuf, num, 1, 7, 104, FRAME_I | FRAME_I_PRIOR_LOW); // } /************************************************************************** 函数名称：IEC101_InitOK 函数版本：1.00 作者： 创建日期：2007.9.1 函数功能说明：子站初始化完毕 输入参数： 输出参数： 返回值： 更新信息： 更新日志1： 日期： 修改者： 修改内容： 修改原因： ***************************************************************************/ static void IEC101_InitOK(IEC101_DEF *pt101) { u8 *pd; int num; u8 cot; // 组织报文 pd = g_arrIECBuf; num = 0; pd[num++] = 0; pd[num++] = 0; if (pt101->bInitCot) { pd[num++] = 2; // 远方复位 } else { pd[num++] = 0; // 当地电源合上 } pt101->bInitCot = true; cot = pRunSet->bTT_101Cot03 ? 3 : 4; IEC101_Asdu_Add(pt101, g_arrIECBuf, num, 1, cot, 70, FRAME_I); // 70 初始化结束帧 } // 复位进程 static void IEC101_ResetProcess(IEC101_DEF *pt101, u8 qrp) { u8 *pd; int num; // 组织报文 pd = g_arrIECBuf; num = 0; pd[num++] = 0; pd[num++] = 0; pd[num++] = qrp; IEC101_Asdu_Add(pt101, g_arrIECBuf, num, 1, 7, 105, FRAME_I); } /************************************************************************** 函数名称：IEC101_CallAll 函数版本：1.00 作者： 创建日期：2008.9.1 函数功能说明：通用范围总查询响应 输入参数： 输出参数： 返回值： 更新信息： 更新日志1： 日期： 修改者： 修改内容： 修改原因： ***************************************************************************/ static void IEC101_CallAll(IEC101_DEF *pt, u8 QOI) // 确认帧 { u8 *pd, *pdata; u8 vsq; // 通用分类数据集数目 u16 cp = 0, attr; int i, num, begin, end; pdata = g_arrIECBuf; pt->ycno = 0; attr = pt->bSendChange ? FRAME_I_PRIOR_LOW : FRAME_I; //| FRAME_I_PRIOR_HIGH // 总召唤确认帧 num = 0; pd = pdata; pd[num++] = 0; pd[num++] = 0; pd[num++] = QOI; IEC101_Asdu_Add(pt, pdata, num, 1, 7, 100, FRAME_I); // 遥测帧 if ((QOI == IEC_QOI_CALL_ALL_GROUP) | ((QOI >= IEC_QOI_CALL_YC_BEGIN && QOI <= IEC_QOI_CALL_YC_END))) { int ycvalue; u8 ti; union { float ff; u8 tt[4]; } ff; long lmeaval; // 类型标识 if (tRunPara.bYcBDH) { ti = 11; // 标度化值 } else if (tRunPara.bYcFloat) { ti = 13; // 浮点值 } else { ti = 9; // 归一化值 } // 确认起止点号 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; } } // 得到第一点的通讯点号，必须检查g_ac_table，否则有可能系统崩溃 if (g_ac_table) { cp = g_ac_table[begin].cp; } // 初始数据 pd = pdata; vsq = 0; num = 0; // 如果点号连续，保存第一点点号 if (pRunSet->bDIContinue) { pd[num++] = (u8)cp; pd[num++] = (u8)(cp >> 8); } // 发送begin到end之间的所有遥测值 for (i = begin; i < end; i++) { u8 QDS = 0; // 品质描述， 默认为零 u8 link_qds = 0; u8 no = g_ac_table[i].indexno; // 得到遥测值 if (no > 0) { DWORD dwMax = 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(pt->yc_save[i]); if (dwMax == 0) // 防止额定或者前一次保存值为0 dwMax = 1; lmeaval = GetRmtMeaVal(g_ac_table[i].owner, no, &link_qds); if (dwMax == 0) f_65536 = 1.0; 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 { lmeaval = 0; ycvalue = 0; ff.ff = 0; if (!pRunSet->bDIContinue) continue; // 点号不连续上送，可不送备用点 } // 如果在测试模式下，置无效状态 if (g_run_stu.bToolRmtTest || g_run_stu.bHmiRmtTest) { if (pRunSet->bTT_RmtTest) QDS |= 0x80; // 带品质描述，有效 <1>：=无效 } #if !defined FUNC_JX_YC_SIQ00 if (g_run_stu.bjx) { QDS |= 0x80; // 带品质描述，有效 <1>：=无效 } #endif #ifdef IEC_QDS_HAVE QDS |= link_qds; #endif // 保存遥测值，供主动遥测上送比较用 if (i < MAX_YC_NUMBER) pt->yc_save[i] = lmeaval; // 如果点号不连续，上送每个点的点号 if (!pRunSet->bDIContinue) { cp = g_ac_table[i].cp; pd[num++] = (u8)cp; pd[num++] = (u8)(cp >> 8); } // 上送值 if (tRunPara.bYcFloat) { // 浮点值上送 num += CopySwap(&pd[num], ff.tt, sizeof(ff.tt), true); } else { // 整型 pd[num++] = (u8)(ycvalue); pd[num++] = (u8)(ycvalue >> 8); } pd[num++] = QDS; vsq++; // 发送一帧 if (num > MAX_101_FRAME_LENTH && (i < g_table_head->ac_num - 1)) { u8 vsq1 = vsq; if (pRunSet->bDIContinue) { vsq1 |= 0x80; } IEC101_Asdu_Add(pt, pdata, num, (vsq1), QOI, ti, attr); num = 0; pd = pdata; if (pRunSet->bDIContinue) { pd[num++] = (u8)(cp + vsq); pd[num++] = (u8)((cp + vsq) >> 8); cp += vsq; } vsq = 0; } } if (num > 2) { u8 vsq1 = vsq; if (pRunSet->bDIContinue) { vsq1 |= 0x80; } IEC101_Asdu_Add(pt, pdata, num, (vsq1), QOI, ti, attr); } pt->us0_yc = ustimer_get_origin(); } // 事件帧 if ((QOI == IEC_QOI_CALL_ALL_GROUP) || (QOI >= IEC_QOI_CALL_YX_BEGIN && QOI <= IEC_QOI_CALL_YX_END)) { u8 ti; u8 yxtype = 0; // 确定类型标识，单点(1)或双点(3) ti = 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; } } // 初始数据 pd = pdata; vsq = 0; num = 0; // 得到第一点的通讯点号，必须检查g_di_table，否则有可能系统崩溃 if (g_di_table) { cp = g_di_table[begin].cp; yxtype = tbl_get_dpi(begin); } // 如果点号连续，保存第一点点号 if (pRunSet->bDIContinue) { pd[num++] = (u8)cp; pd[num++] = (u8)(cp >> 8); } // 发送begin到end之间的所有遥信值 for (i = begin; i < end; i++) { u8 SIQ; // 得到遥信值 if (tRunPara.bSDPI) // 单双点分别上送 { u8 type = tbl_get_dpi(i); if (yxtype != type && num > 2) { u8 vsq2 = vsq; u8 ti2 = yxtype ? 3 : 1; yxtype = type; if (pRunSet->bDIContinue) { vsq2 |= 0x80; } IEC101_Asdu_Add(pt, pdata, num, (vsq2), QOI, ti2, attr | FRAME_I_COS); // cot=9总查询 num = 0; pd = pdata; if (pRunSet->bDIContinue) { pd[num++] = (u8)(cp + vsq); pd[num++] = (u8)((cp + vsq) >> 8); cp += vsq; } vsq = 0; yxtype = type; } SIQ = tbl_get_yx(i, type); ti = type ? 3 : 1; } else { SIQ = tbl_get_yx(i, tRunPara.bDPI); } #if !defined FUNC_JX_YX_BEFORE if (g_run_stu.bjx) { SIQ |= 0x80; // 带品质描述，有效 <1>：=无效 } #endif if (g_run_stu.bToolRmtTest || g_run_stu.bHmiRmtTest) // 测试模式，遥信置为无效 { if (pRunSet->bTT_RmtTest) SIQ |= 0x80; } // 点号 if (!pRunSet->bDIContinue) { cp = g_di_table[i].cp; pd[num++] = (u8)cp; pd[num++] = (u8)(cp >> 8); } pd[num++] = SIQ; vsq++; if (((vsq > 120) || (num > MAX_101_FRAME_LENTH)) && (i < g_table_head->di_num - 1)) // ngd不能超过128，因个数最高位为连续标示位 { u8 vsq1 = vsq; if (pRunSet->bDIContinue) { vsq1 |= 0x80; } IEC101_Asdu_Add(pt, pdata, num, (vsq1), QOI, ti, attr | FRAME_I_COS); // cot=9总查询 num = 0; pd = pdata; if (pRunSet->bDIContinue) { pd[num++] = (u8)(cp + vsq); pd[num++] = (u8)((cp + vsq) >> 8); cp += vsq; } vsq = 0; } } if (num > 2) { u8 vsq1 = vsq; if (pRunSet->bDIContinue) { vsq1 |= 0x80; } IEC101_Asdu_Add(pt, pdata, num, (vsq1), QOI, ti, attr | FRAME_I_COS); // cot=9总查询 } } // 总召唤结束帧 num = 0; pd = pdata; pd[num++] = 0; pd[num++] = 0; pd[num++] = QOI; IEC101_Asdu_Add(pt, pdata, num, 1, 10, 100, attr); // 不允许通讯续传的情况下，第一次总召先清SOE队列，保证上传事件是总召后产生的，后续总召不清SOE队列 if ((pRunSet->bTT_SoeResumeComm == 0) && (!pt->bSendChange)) { g_soe_queue.tail_send[pt->chnl].n = g_soe_queue.head.n; g_soe_queue.tail_ack[pt->chnl].n = g_soe_queue.tail_send[pt->chnl].n; } #ifdef FUN_SOE_DELAY_TIME if (pt->bSendChange == false) { pt->DTSendChange = dTCounter; pt->bfirst_call = true; } #endif // 置总召标志 pt->bSendChange = true; } static void IEC101_DDAll(IEC101_DEF *pt, u8 QCC) // 确认帧 { u8 *pd, *pdata; u8 vsq, cot; // 通用分类数据集数目 u16 cp; int i, num; pdata = g_arrIECBuf; num = 0; // 总召唤确认帧 pd = pdata; pd[num++] = 0; pd[num++] = 0; pd[num++] = QCC; IEC101_Asdu_Add(pt, pdata, num, 1, 7, 101, FRAME_I); // 电度值 if ((QCC == 1) || (QCC == 5)) { // 初始数据 pd = pdata; vsq = 0; num = 0; cp = g_dd_table[0].cp; if (QCC == 5) cot = 37; // 总召 else cot = QCC + 37; // 召某一组 pd[num++] = (u8)cp; pd[num++] = (u8)(cp >> 8); 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; } num += CopySwap(&pd[num], ff.tt, sizeof(ff.tt), true); pd[num++] = 0; vsq++; // 发送一帧 if ((num > MAX_101_FRAME_LENTH) || (i == g_table_head->dd_num - 1)) { IEC101_Asdu_Add(pt, pdata, num, (vsq | 0x80), cot, 206, FRAME_I_PRIOR_LOW); cp += vsq; pd = pdata; num = 0; vsq = 0; pd[num++] = (u8)cp; pd[num++] = (u8)(cp >> 8); } } } if (QCC == 0x45) // 主站扩展瞬时冻结电度命令 { // rand_file_info.b_frz=true; } // 总召唤结束帧 num = 0; pd = pdata; pd[num++] = 0; pd[num++] = 0; pd[num++] = QCC; IEC101_Asdu_Add(pt, pdata, num, 1, 10, 101, FRAME_I_PRIOR_LOW); } /************************************************************************** 函数名称：IEC101_RmtCtrl 函数版本：1.00 作者： 创建日期：2007.9.1 函数功能说明：遥控处理 输入参数： 点号开始21 0b 00 82 （10-13） 输出参数： 返回值： 更新信息： 更新日志1： 日期： 修改者： 修改内容： 修改原因： ***************************************************************************/ void IEC101_Echo_YK(IEC101_DEF *pt, u16 cp, u8 ti, u8 cot, u8 v) { u8 *pd, *pdata; int num; pdata = g_arrIECBuf; pd = pdata; num = 0; pd[num++] = (u8)cp; pd[num++] = (u8)(cp >> 8); pd[num++] = v; IEC101_Asdu_Add(pt, pdata, num, 1, cot, ti, FRAME_I | FRAME_I_PRIOR_HIGH); // cot=9总查询 pt->bRmtSM2 = false; // 遥控执行完成，清除SM2标志，开放事件上传 } void IEC101_Echo_PAR(IEC101_DEF *pt, u16 cp, u8 ti, u8 cot, BYTE *buf, u8 len, u8 vsq) { u8 *pd, *pdata; int num; pdata = g_arrIECBuf; pd = pdata; num = 0; // pd[num++]=(u8)cp; // pd[num++]=(u8)(cp>>8); memcpy(&pd[num], buf, len); num += len; // pd[num++]=v; IEC101_Asdu_Add(pt, pdata, num, vsq, cot, ti, FRAME_I); // cot=9总查询 } int get_yk_info_cp(u8 cp) { int i; for (i = 0; i < g_table_head->do_num; i++) { // rt_printf("cp=%X link_ch=%x cp=%x \r\n",cp,(g_do_table[i].link_ch&0x0f),g_do_table[i].link_cp); if ((g_do_table[i].link_ch & 0x01f) == cp) { return (u8)i; } } return -1; } u8 get_par_link_101_to_104(BYTE *out, BYTE *in, BYTE parNum, u8 ti) { int size = 0, i = 0, j = 0; int no = 0; if ((ti == FOS_PAR_SET_MUL) || (ti == FOS_PAR_SET_ONE)) size = (parNum * (sizeof(float) + 2 + 1)); // 写定值时需多一位QOS位 else if (ti == FOS_PAR_READ_MUL || ti == FOS_PAR_READ_ONE) size = (parNum * (sizeof(float) + 2)); rt_printf("size=%d,parNum=%d\n\r", size, parNum); for (no = 0; no < parNum; no++) { if ((ti == FOS_PAR_READ_MUL) || (ti == FOS_PAR_READ_ONE)) { out[j++] = in[i++]; // 地址 out[j++] = in[i++]; // 地址 out[j++] = 0; out[j++] = in[i++]; // 值 out[j++] = in[i++]; // 值 out[j++] = in[i++]; // 值 out[j++] = in[i++]; // 值 } else if ((ti == FOS_PAR_SET_MUL) || (ti == FOS_PAR_SET_ONE)) { out[j++] = in[i++]; // 地址 out[j++] = in[i++]; // 地址 out[j++] = 0; out[j++] = in[i++]; // 值 out[j++] = in[i++]; // 值 out[j++] = in[i++]; // 值 out[j++] = in[i++]; // 值 out[j++] = in[i++]; // QOS } } return (size + parNum); } u8 get_par_link_data(BYTE *out, BYTE *in, BYTE parNum, u8 ti) { int size; if (ti == FOS_PAR_SET_MUL) // 写带品质描述，长度+1 size = (parNum * (sizeof(float) + 2 + 1)); // 4 else size = (parNum * (sizeof(float) + 2)); memcpy(out, in, size); // 拷贝遥参点表地址=2 && 参数值=size return (size); } u8 get_par_link_104_to_104(BYTE *out, BYTE *in, BYTE parNum, u8 ti) { int size; if (ti == FOS_PAR_SET_MUL) // 写带品质描述，长度+1 size = (parNum * (sizeof(float) + 3 + 1)); // 4 else size = (parNum * (sizeof(float) + 3)); memcpy(out, in, size); // 拷贝遥参点表地址=2 && 参数值=size return (size); } u8 get_par_link_data_dz(BYTE *out, BYTE *in, BYTE parNum, u8 ti) { int size = 0, i, j = 0; if ((ti == FOS_PAR_SET_MUL) || (ti == FOS_PAR_SET_ONE)) size = (parNum * (sizeof(float) + 3 + 1)); // 写定值时需多一位QOS位 else if (ti == FOS_PAR_READ_MUL || ti == FOS_PAR_READ_ONE) size = (parNum * (sizeof(float) + 3)); rt_printf("size=%d,parNum=%d\n\r", size, parNum); for (i = 0; i < size; i++) { // 104遥调时，因管理机与级联间仍为101通讯，故管理机转发给级联的报文应去掉1位地址位（104为3位地址位，101为2位地址位） if ((ti == FOS_PAR_READ_MUL) || (ti == FOS_PAR_READ_ONE)) { if (2 == i % 7) // 读定值时3位地址位+4位数据位共7位 continue; // 跳过地址位第3位 else { out[j++] = in[i]; } } else if ((ti == FOS_PAR_SET_MUL) || (ti == FOS_PAR_SET_ONE)) { if (2 == i % 8) // 写定值时3位地址位+4位数据位+1位QOS位 continue; // 跳过地址位第3位 else { out[j++] = in[i]; } } } return (size - parNum); } // 获取通道信息 bool get_par_ch_info(WORD parAddr, struct do_table *parTab) { WORD Addr = 0; int ykCp = 0; // 判断遥参ID是否合法 if (parAddr < FOS_PAR_STATR_ADDR) return false; Addr = parAddr - FOS_PAR_STATR_ADDR; #ifdef YC_QUANTITY parTab->link_cp = (Addr / pRunSet->dYC_num) + 1; // 转发通信地址 #else parTab->link_cp = (Addr / FOS_PAR_SW_NUM) + 1; // 转发通信地址 #endif // 通过遥控的级联地址去判断遥参是否合法 ykCp = get_yk_info_cp(parTab->link_cp); if (ykCp < 0) { rt_printf("定值参数未找到Yk对应的级联地址=%X link_ch=%x \r\n", parAddr, parTab->link_cp); return false; } memcpy(parTab, &g_do_table[ykCp], sizeof(g_do_table[0])); // 将遥控配置的转发信息赋到遥参 #if 0 parTab->cp = Addr%FOS_PAR_SW_NUM + FOS_PAR_STATR_ADDR; //转发点号 #endif parTab->link_cp = parTab->cp = parAddr; // 转发通信地址 #ifdef YC_QUANTITY rt_printf("\n parAddr=%x link_cp=%x cp=%x link_ch=0X%X ykCp=%d linkAddr=%x\r\n", parAddr, parTab->link_cp, parTab->link_ch, parTab->cp, ykCp, Addr % pRunSet->dYC_num); #else rt_printf("\n parAddr=%x link_cp=%x cp=%x link_ch=0X%X ykCp=%d linkAddr=%x\r\n", parAddr, parTab->link_cp, parTab->link_ch, parTab->cp, ykCp, Addr % FOS_PAR_SW_NUM); #endif return true; } #ifdef FUNC_MORE_PRESET YT_BUF PresetData101[256]; YT_BUF SetData101[256]; int WrongCount101[256]; int g_CountPreset101 = 0, g_CountSet101 = 0; bool gb_101_yt = false; #endif static void IEC101_ParCtrl(IEC101_DEF *pt, u8 *pdat) // ps从传送原因开始 { u8 cot, ykcot, ykvalue; WORD parNum = 1; WORD ykno = 0; WORD yksave = 0; WORD parAddr = 0; u8 AppByte = 0; u8 CotByte = 0; u8 *ps = &pdat[2]; u8 ti = pdat[0]; // 类型标示 struct do_table parTab; BYTE buf[256]; BYTE len = 0; BYTE addrStart = 0; WORD sw = 1; static DWORD ctrlParTime = 0; // 系统定时器 static bool bSetParaDisable = false; if (tRunPara.b101App2Byte) // 应用单元双字节地址 { AppByte = 1; } if (tRunPara.b101Cot2Byte) // 双字节传送原因 { CotByte = 1; } ykcot = (ps[0] & 0x01f); parNum = (pdat[1] & 0xff); // 遥参数量,支持遥调大于30个定值 ykno = ps[2 + AppByte + CotByte] + (WORD)ps[3 + AppByte + CotByte] * 256; addrStart = 2 + AppByte + CotByte; yksave = ykno; cot = IEC_COT_UN_OA | IEC_COT_PN; parAddr = (ps[addrStart + 1] << 8) + ps[addrStart]; // 遥参通信地址 len = get_par_link_data(&buf[0], &ps[addrStart], parNum, ti); // 2+(parNum*4);//2:点号 4:参数值 ykvalue = ps[AppByte + CotByte + 2 - 1 + 7]; // rt_printf("ti=%d parAddr=%x parNum= %d recDataLen=%d addrStart=%d ykvalue=%x ykcot=%02x\r\n", ti, parAddr, parNum, len, addrStart, ykvalue, ykcot); if (pRunSet->wEquTypeManager) // 通信管理机模式，转发 { #ifdef YC_QUANTITY if (!get_par_ch_info(parAddr, &parTab) || parNum > pRunSet->dYC_num) #else if (!get_par_ch_info(parAddr, &parTab) || parNum > FOS_PAR_SW_NUM) #endif { cot = IEC_COT_ACTCON | IEC_COT_PN; // 否定应答 // refresh_co_file(true,ti,yktype,ykno,cot,yk_cmd); return; } // parTab.vsq = parNum; if (lnk_master_par(&parTab, ti, ps[0], len, &buf[0], parNum) == 0) { #ifdef FUNC_MORE_PREREAD /*级联遥参方式:0开关,1队列*/ pt->lnk_par_send_flag |= (1 << g_link_par_cnt); rt_printf("-------lnk_par_send_flag=%x,g_link_par_cnt=%d\r\n", pt->lnk_par_send_flag, g_link_par_cnt); g_link_par_cnt = (g_link_par_cnt + 1) % SWITCH_NUM_EXT_PUB; #else pt->lnk_par_send_flag |= (1 << parTab.owner); #endif pt->us0_lnk_par = ustimer_get_origin(); } } else if (pRunSet->wEquTypeDFTU) // 测控装置遥参交互 { WORD parCount; WORD addLenParLen; #ifdef FUNC_MORE_PRESET int n; #endif cot = IEC_COT_ACTCON; // ykvalue = (ti==FOS_PAR_SET_ONE) ? (ykvalue|0x80) :ykvalue; #ifndef FUNC_MORE_PRESET bfirst_sel = false; #endif #ifdef FUNC_MORE_PRESET if ((dTCounter - ctrlParTime) > tRunPara.dYKTime) { // 超时清零预置/执行/出错数据存储区 memset(SetData101, 0, sizeof(SetData101)); g_CountSet101 = 0; memset(PresetData101, 0, sizeof(PresetData101)); g_CountPreset101 = 0; memset(WrongCount101, 0, sizeof(WrongCount101)); rt_printf("超时清除101报文缓存区\r\n"); } #endif if (ti == FOS_PAR_SET_ONE || ti == FOS_PAR_SET_MUL) { if (ykvalue & 0x80) { #ifdef FUNC_MORE_PRESET memcpy(&PresetData101[g_CountPreset101++].yc_data, &ps[addrStart], parNum * 7); rt_printf_time("101预置报文[第%d帧]：", g_CountPreset101); for (n = 0; n < parNum * 7; n++) { rt_printf("%02x ", PresetData101[g_CountPreset101 - 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 } #ifdef FUNC_MORE_PRESET else { memcpy(&SetData101[g_CountSet101++].yc_data, &ps[addrStart], parNum * 7); rt_printf_time("101固化报文[第%d帧]：", g_CountSet101); for (n = 0; n < parNum * 7; n++) { rt_printf("%02x ", SetData101[g_CountSet101 - 1].yc_data[n]); } } #endif } for (parCount = 0; parCount < parNum; parCount++) // 多参数处理 { #ifdef FUNC_MORE_PRESET gb_101_yt = true; #endif if (ti == FOS_PAR_SET_MUL) // 读取参数带品质描述 addLenParLen = (parCount) * (2 + 4 + 1); // ID=2,PAR=4,QDS=1 else addLenParLen = (parCount) * (2 + 4); // ID=2,PAR=4 #ifdef YC_QUANTITY parAddr = (ps[addrStart + 1 + addLenParLen] << 8) + ps[addrStart + addLenParLen] - ((tRunPara.byAddr - 1) * pRunSet->dYC_num); #else parAddr = (ps[addrStart + 1 + addLenParLen] << 8) + ps[addrStart + addLenParLen] - ((tRunPara.byAddr - 1) * FOS_PAR_SW_NUM); #endif // parAddr = (ps[addrStart+1]<<8)+ps[addrStart];//遥参通信地址 #ifdef YC_QUANTITY if (((ps[addrStart + 1 + addLenParLen] << 8) + ps[addrStart + addLenParLen]) >= FOS_PAR_STATR_ADDR && ((ps[addrStart + 1 + addLenParLen] << 8) + ps[addrStart + addLenParLen]) < (FOS_PAR_STATR_ADDR + pRunSet->dYC_num)) #else if (((ps[addrStart + 1 + addLenParLen] << 8) + ps[addrStart + addLenParLen]) >= FOS_PAR_STATR_ADDR && ((ps[addrStart + 1 + addLenParLen] << 8) + ps[addrStart + addLenParLen]) < (FOS_PAR_STATR_ADDR + FOS_PAR_SW_NUM)) #endif { parAddr = (ps[addrStart + 1 + addLenParLen] << 8) + ps[addrStart + addLenParLen]; } rt_printf("parAddr=%x addr2=%X %x addrStart=%x\r\n", parAddr, (ps[addrStart + 1] << 8) + ps[addrStart], addLenParLen, addrStart); if (ti == FOS_PAR_READ_ONE || ti == FOS_PAR_READ_MUL) { rt_printf("读取遥参激活 parAddr=%x\r\n", parAddr); if (!readRunParId(sw, parAddr, &ps[addrStart + 2 + addLenParLen])) // 暂默认为0开关 cot = IEC_COT_ACTCON | IEC_COT_PN; // 否定应答// memcpy(&ps[addrStart+2],"1234",sizeof(float));//2:参数点表地址 } else { #ifdef FUNC_FIT_QOS if (ykcot == IEC_COT_DEACT) { cot = IEC_COT_DEACTCON; // 预置取消确认 bSetParaDisable = true; // 取消预置时置1 rt_printf("QOS(101)=%02x,取消遥参预置...\r\n", ykvalue); break; } #endif if (ykvalue & 0x80) { ctrlParTime = dTCounter; // 系统时间戳 if (!selectRunParId(sw, parAddr, &ps[addrStart + 2 + addLenParLen])) { cot = IEC_COT_ACTCON | IEC_COT_PN; #ifdef FUNC_MORE_PRESET WrongCount101[g_CountPreset101 - 1] = g_CountPreset101; #else bSetParaDisable = true; // 预置报文出错时置1，禁止固化定值 #endif break; } else { bSetParaDisable = false; // 重新预置时清0 } } else { #ifdef FUNC_MORE_PRESET int s_stop; s_stop = WrongCount101[g_CountSet101 - 1]; #endif #if defined FUNC_MORE_PRESET if (ykcot == IEC_COT_DEACT) { cot = IEC_COT_DEACTCON; // 预置取消确认 bSetParaDisable = true; // 取消预置时置1 rt_printf("取消遥参预置...\r\n"); break; } else if (dTCounter - ctrlParTime > tRunPara.dYKTime || (0 != s_stop) || bSetParaDisable || !wirteRunParId(sw, parAddr, &ps[addrStart + 2 + addLenParLen], ti)) // 暂默认为0开关 #elif defined FUNC_FIT_QOS if (dTCounter - ctrlParTime > tRunPara.dYKTime || bSetParaDisable || !wirteRunParId(sw, parAddr, &ps[addrStart + 2 + addLenParLen], ti)) // 暂默认为0开关 #else if (ykcot == IEC_COT_DEACT) { cot = IEC_COT_DEACTCON; // 预置取消确认 bSetParaDisable = true; // 取消预置时置1 rt_printf("取消遥参预置...\r\n"); break; } else if (dTCounter - ctrlParTime > tRunPara.dYKTime || bSetParaDisable || !wirteRunParId(sw, parAddr, &ps[addrStart + 2 + addLenParLen], ti)) // 暂默认为0开关 #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帧]101预置报文出错,请检查...\r\n", s_stop); } #endif else if (bSetParaDisable) { #ifdef FUNC_MORE_PRESET rt_printf("取消预置,禁止固化定值\r\n"); #else rt_printf("预置报文出错或取消预置,禁止固化定值\r\n"); #endif } cot = IEC_COT_ACTCON | IEC_COT_PN; // 否定应答 // 屏蔽break语句，除出错定值外均可修改，与104遥调统一做法 // break; } } } } #ifdef FUNC_MORE_PRESET gb_101_yt = false; #endif // parTab.vsq = parNum; // if (cot & IEC_COT_PN) rt_printf("设置&&读取 遥参失败 parAddr=%x\r\n", parAddr); else rt_printf("设置&&读取 遥参OK parAddr=%x\r\n", parAddr); #ifndef FUNC_MORE_PRESET if ((!(ykvalue & 0x80) && ti == FOS_PAR_SET_MUL) #ifdef FUNC_FIT_QOS || (ykcot == IEC_COT_DEACT) #endif ) ctrlParTime = 0; #endif IEC101_Echo_PAR(pt, yksave, ti, cot, &ps[addrStart], len, parNum); #ifndef FUNC_MORE_PRESET if ((!(ykvalue & 0x80)) #ifdef FUNC_FIT_QOS || (ykcot == IEC_COT_DEACT) #endif ) { memset(buf_forCompare, 0, sizeof(buf_forCompare)); i_forCompare = 0; j_forCompare = 0; } #endif return; } cot = (ykcot == IEC_COT_ACT) ? IEC_COT_ACTCON : IEC_COT_DEACTCON; cot |= IEC_COT_PN; // rt_printf("设置遥参 error parAddr=%x\r\n",parAddr); // IEC101_Echo_PAR(pt,yksave,ti,cot,&ps[addrStart],len); } static void IEC101_RmtCtrl(IEC101_DEF *pt, u8 *pdat) // ps从传送原因开始 { u8 cot, ykcot, ykvalue, yktype, ykThz, v; WORD ykno; WORD yksave; u8 AppByte = 0; u8 CotByte = 0; int i, ret; bool bValidYk = false; u8 *ps = &pdat[2]; u8 ti = pdat[0]; // 类型标示 u8 yk_cmd; yktype = 0; if (tRunPara.b101App2Byte) // 应用单元双字节地址 { AppByte = 1; } if (tRunPara.b101Cot2Byte) // 双字节传送原因 { CotByte = 1; } ykcot = (ps[0] & 0x01f); ykvalue = ps[4 + AppByte + CotByte]; yk_cmd = ykvalue & 0x03; ykno = ps[2 + AppByte + CotByte] + (WORD)ps[3 + AppByte + CotByte] * 256; yksave = ykno; cot = IEC_COT_UN_OA | IEC_COT_PN; v = ykvalue; if (ti == 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], ti, ps[0], v) == 0) { pt->lnk_yk_send_flag |= (1 << g_do_table[i].owner); pt->us0_lnk_yk = ustimer_get_origin(); } else { cot = (ykcot == IEC_COT_ACT) ? IEC_COT_ACTCON : IEC_COT_DEACTCON; cot |= IEC_COT_PN; IEC101_Echo_YK(pt, yksave, ti, cot, v); } if (ykvalue & 0x80) { yktype = YK_TYPE_SEL; } else { yktype = YK_TYPE_EXE; } refresh_co_file(true, ti, yktype, ykno, cot, yk_cmd); return; } // 本装置遥控 { cot = IEC_COT_ACTCON; bValidYk = true; if (ykvalue & 0x80) { yktype = YK_TYPE_SEL; } else { yktype = YK_TYPE_EXE; } if (ykcot == 8) // 遥控撤销 { 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_101 + pt->chnl); if (ret != 0) { cot = IEC_COT_ACTCON | IEC_COT_PN; // 否定应答 } // 接收到主站的遥控信息:选择,执行,撤销 refresh_co_file(true, ti, yktype, ykno, cot, yk_cmd); break; } } // 没有找到对应遥控点 if (i == g_table_head->do_num) { char buf[128]; char log_info[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); sprintf(log_info, "IEC101(%d):Remote control:Corresponding di is not in the iectable(ykno=0x%04x,yktype=%d,ykvalue=%d)", pt->chnl + 1, ykno, yktype, ykvalue); load_hs_log_rcd(TYPE_COMM_ERR, true, NULL, log_info, 1); log_flag.com_err[pt->chnl] = true; } pt->bRmtSM2 = false; IEC101_Echo_YK(pt, yksave, ti, cot, v); // 必须有对应点号 if (i != g_table_head->do_num) { // 终端发出遥控信息:选择确认，执行确认 refresh_co_file(false, ti, yktype, ykno, cot, yk_cmd); } if ((yktype == YK_TYPE_EXE) && (cot == IEC_COT_ACTCON)) { IEC101_Echo_YK(pt, yksave, ti, 10, v); refresh_co_file(false, ti, yktype, ykno, IEC_COT_ACTTERM, yk_cmd); } } /************************************************************************** 函数名称：IEC101_MFrameCall 函数版本：1.00 作者： 创建日期：2008.9.1 函数功能说明：应答短帧报文 输入参数：平衡方式下，发送帧 输出参数： 返回值： 更新信息： 更新日志1： 日期： 修改者： 修改内容： 修改原因： ***************************************************************************/ static void IEC101_MFrameCall(IEC101_DEF *pt, unsigned char ZoneByte) { u8 *pd = pt->tx_buf_m; IEC101_SETPRM(ZoneByte); if (!pt->bDIR) IEC101_SETDIR(ZoneByte); if (!tRunPara.b101Addr2Byte) { pd[0] = 5; pd[1] = 0x10; pd[2] = ZoneByte; pd[3] = (u8)tRunPara.byAddr; pd[4] = pd[2] + pd[3]; pd[5] = 0x16; } else { pd[0] = 6; pd[1] = 0x10; pd[2] = ZoneByte; pd[3] = (u8)tRunPara.byAddr; pd[4] = (u8)(tRunPara.byAddr >> 8); pd[5] = pd[2] + pd[3] + pd[4]; pd[6] = 0x16; } } static void IEC101_CallGprsInf(IEC101_DEF *pt) { u8 *pd = pt->tx_buf_s; pd[0] = 9; pd[1] = 0x55; pd[2] = 0xAA; pd[3] = 0x55; pd[4] = 0xAA; pd[5] = 0x1A; pd[6] = 0x00; pd[7] = 0x00; pd[8] = 0x9A; pd[9] = 0x7C; } /************************************************************************** 函数名称：IEC101_link_par 函数版本：1.00 作者： 创建日期：2019.4.19 函数功能说明：101规约遥参级联处理 输入参数： 输出参数： 返回值： 更新信息： 更新日志1： 日期： 修改者： 修改内容： 修改原因： ***************************************************************************/ void IEC101_link_par(IEC101_DEF *pt) { int i; LINKPAR_DEF *par; LINK_PARDATA *yd; if (pt->lnk_par_send_flag == 0) { return; } for (i = 0; i < SWITCH_NUM_EXT_PUB; i++) { if (pt->lnk_par_send_flag & (1 << i)) { par = &g_link_par[i]; // 遥控应答帧 if (par->flag[IECLINK_YK_ACK]) { yd = &par->data[IECLINK_YK_ACK]; IEC101_Echo_PAR(pt, par->cp_m, yd->ti, yd->cot, &yd->buf[0], yd->len, yd->vsq); par->flag[IECLINK_YK_ACK] = 0; rt_printf("参数应答帧\r\n"); } // 遥控结束帧 if (par->flag[IECLINK_YK_END]) { yd = &par->data[IECLINK_YK_END]; IEC101_Echo_PAR(pt, par->cp_m, yd->ti, yd->cot, &yd->buf[0], yd->len, yd->vsq); par->flag[IECLINK_YK_END] = 0; pt->lnk_par_send_flag &= ~(1 << i); rt_printf("参数结束帧\r\n"); } // 遥控超时，复位 if (ustimer_get_duration(pt->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; pt->lnk_par_send_flag &= ~(1 << i); } } } } /************************************************************************** 函数名称：IEC101_Applay 函数版本：1.00 作者： 创建日期：2008.9.1 函数功能说明：101规约链路数据处理 输入参数： 输出参数： 返回值： 更新信息： 更新日志1： 日期： 修改者： 修改内容： 修改原因： ***************************************************************************/ void IEC101_lnk_yk(IEC101_DEF *pt) { int i; LINKYK_DEF *yk; LINK_YKDATA *yd; if (pt->lnk_yk_send_flag == 0) { return; } for (i = 0; i < SWITCH_NUM_EXT_PUB; i++) { if (pt->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]; IEC101_Echo_YK(pt, yk->cp_m, yd->ti, yd->cot, yd->v); yk->flag[IECLINK_YK_ACK] = 0; } // 遥控结束帧 if (yk->flag[IECLINK_YK_END]) { yd = &yk->data[IECLINK_YK_END]; IEC101_Echo_YK(pt, yk->cp_m, yd->ti, yd->cot, yd->v); yk->flag[IECLINK_YK_END] = 0; pt->lnk_yk_send_flag &= ~(1 << i); } // 遥控超时，复位 if (ustimer_get_duration(pt->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); pt->lnk_yk_send_flag &= ~(1 << i); } if (yk_hs) { 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 IEC101_lnk_msg_ypara(IEC101_DEF *pt101) { u8 *pd; int num = 0; u8 pdi = 0, cot = 0, ti = 0, vsq = 0; int index = 0, i = 0; msg_data_struct *msg_data = &pt101->msg_ypara_recv; pd = g_arrIECBuf; #if 0 /*遥参是否超时*/ if(!pt101->msg_ypara_send.flag) return; /*没有下发遥参不返回*/ if(ustimer_get_duration(pt101->us0_msg_ypara) > tRunPara.dSM2Time*USTIMER_SEC) { pt101->msg_ypara_send.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 = &pt101->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[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++] = 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++; } IEC101_Asdu_Add(pt101, pd, num, vsq, cot, ti, FRAME_I); } } void IEC101_Rmt_msg_ypara_write(IEC101_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 += 2; 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 int IEC101_TransFile(IEC101_DEF *pt, unsigned char *buf, int len); int IEC101_Maintain(IEC101_DEF *pt, unsigned char *buf, int len); #ifdef RCD_STRAN_S static void IEC101_Rcd_Ack(IEC101_DEF *pt101) // 发送新录波文件名 { u8 *pd; int num; u8 rcd_num = 0; char tmp[128] = {0}; char note[100]; // 组织报文 pd = g_arrIECBuf; num = 0; if (get_queue_count(&pt101->rcd_qt.queue) > 0) /*有新录波*/ { check_data_queque(&pt101->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++] = 1; /*文件数量*/ pd[num++] = strlen(tmp); /*文件名长度*/ memcpy(&pd[num], tmp, strlen(tmp)); num += strlen(tmp); } else { pd[num++] = 0; // 信息体地址 pd[num++] = 0; // pd[num++] = rcd_num; } IEC101_Asdu_Add(pt101, g_arrIECBuf, num, 1, 7, RCD_TYPE, FRAME_I | FRAME_I_PRIOR_LOW); // } #endif void IEC101_Applay(IEC101_DEF *pt) { u8 *pd; u8 AddByte = 0; u8 CotByte = 0; // 传送原因双字节 u8 AppByte = 0; // 应用单元地址双字节 u8 ti, vsq, cot, L, *info_addr, info_len; bool bLFrame = false; // 短帧标志 #ifdef FUNC_ENCRY_IN_ONE_SERIAL if (tRunPara.tUartPara[0].wProtocol == PROTOCOL_WED_ENC) { if ((pt->chnl != 1) && (pt->chnl != 3) && (pt->chnl != 4)) // 投入海南加密时，固定串口2、4、5用于加密数据处理，不允许接收串口数据 { // 接收报文 IEC101_Recv_App(pt); if (pt->chnl == 0) { return; } } } else #endif { // 接收报文 IEC101_Recv_App(pt); } #ifdef IEC_NOLINK_NO_CALLYX if (g_link_comm.link_flag == false) return; #endif // 主动SOE处理，放在报文处理之前，使时间同步报文之前的SOE报文在时间报文应答前发送 IEC101_SendEvent(pt, tRunPara.bAutoCos); // 处理级联遥控 IEC101_lnk_yk(pt); // 处理级联遥参 IEC101_link_par(pt); #ifdef YPARA_LINK IEC101_lnk_msg_ypara(pt); #endif // 处理接收的加密报文 // 先处理加密报文，再处理普通报文，保证同一报文一个循环处理完 if (pt->bSM2Data) { if (pRunSet->bTT_SM2) // 加密功能投入 { #ifdef ENCRYPT_SM2 IEC101_SM2(pt); #endif } pt->bSM2Data = false; } // 处理接收的普通报文 else if (pt->bData) { // 如果从动站buf有数据，说明至少有2帧报文还没有发送完， // 在gprs网络，同时收到多帧报文后连续应答处理时会出现这种情况。 // 为了保证过程的完整性,待数据发送完后再处理接收的报文。 if (pt->btx_buf_s) { return; } // 报文长度调整变量赋值 if (tRunPara.b101Addr2Byte) AddByte = 1; if (tRunPara.b101Cot2Byte) CotByte = 1; if (tRunPara.b101App2Byte) AppByte = 1; // 打印接收的报文 if (g_print_101 && (g_print_port & (1 << pt->chnl))) { if (pt->recvbuf[0] == 0x10) { rt_printf("RX_S101_%d:", pt->chnl); print_msg("", pt->recvbuf, (5 + AddByte)); } else { rt_printf("RX_L101_%d:", pt->chnl); print_msg("", pt->recvbuf, pt->recvbuf[1] + 6); } } // 由于101在本函数开始处接收数据，所以可以在此处复位接收标志 pt->bData = false; // 检查帧标志并跳过固定报文头 if (pt->recvbuf[0] == 0x10) { pd = &pt->recvbuf[1]; // 短帧 L = 2; } else if (pt->recvbuf[0] == 0x68) { pd = &pt->recvbuf[4]; // 长帧 L = pt->recvbuf[1]; bLFrame = true; } else { return; } // 检查是否是GPRS维护信息 if (pd[0] == 0x05) { memcpy(tGprsInf.data, &pd[1], 64); tGprsInf.bInf = true; return; } // 检查地址 if (tRunPara.b101Addr2Byte) // 双字节地址 { WORD addr; addr = pd[1] + (pd[2] << 8); if (addr != tRunPara.byAddr && addr != 0xffff) return; // 不是发给本装置的数据 } else { if (pd[1] != (u8)tRunPara.byAddr && pd[1] != 0xff) return; // 不是发给本装置的数据 } // 通道空闲时间复位 pt->dValidTime = 0; // 私有101文件传输协议 if ((((pd[0] & 0x0f) == 3) || ((pd[0] & 0x0f) == 4)) && (pd[2 + AddByte] == 137)) { IEC101_TransFile(pt, &pd[2 + AddByte], pt->recvbuf[1] - (2 + AddByte)); pt->btx_buf_s = true; return; } // 私有维护工具软件接口 if ((((pd[0] & 0x0f) == 3) || ((pd[0] & 0x0f) == 4)) && (pd[2 + AddByte] == 138)) { IEC101_Maintain(pt, &pd[2 + AddByte], pt->recvbuf[1] - (2 + AddByte)); pt->btx_buf_s = true; return; } // 主站主动发送数据PRM=1 master if (pd[0] & 0x40) { if (pd[0] & 0x80) { pt->bDIR = true; } else { pt->bDIR = false; } // 非重复报文 if (!pRunSet->bTT_101FCB || (((pd[0] & 0x10) && pt->FCBSave != (pd[0] & 0x20)) // FCV位有效，FCB位变位 || (!(pd[0] & 0x10)) // FCV位无效 || pt->bFirstFCV)) // 该标志有效，不判断FCB位 { // FCB位 if (pd[0] & 0x10) { // 如果不是第一个FCB位且和以前FCB不同，确认发送BUF if ((pt->bFirstFCV == 0) && (pt->FCBSave != (pd[0] & 0x20))) { IEC101_AckOneBuf(pt); } pt->FCBSave = pd[0] & 0x20; // 保存帧记数位 pt->bFirstFCV = 0; // 如果FCV位有效，标志清0 } switch ((pd[0] & 0x0f)) { // 只有非平衡101才会请求一二级数据 case 10: // 请求/响应(一级数据） case 11: // 请求/响应(二级数据) // 如果不是数据状态，不应收到2、3、4、10、11，不进行任何应答，让主站超时复位 if (pt->st101 != IEC101_ST_DATA) { return; } if (!IEC101_SendOneBuf(pt)) { if (pt->tfile.bSegtransing) // 文件传输，放入一级数据缓冲区 { IEC101_SegmentContinue(pt); } else if (pt->tf.bTransing) { iec_readfile_send(pt, false); } if (!IEC101_SendOneBuf(pt)) { pt->bycsend = IEC101_GetYc(pt); if (!pt->bycsend) // add by sunxi { IEC101_FrameEcho(pt, IEC101_ECHO_NO_DATA); } } } break; case 9: // 请求链路状态 IEC101_FrameEcho(pt, IEC101_ECHO_LINK_OK); break; case 3: // 请求/确认 case 4: // 请求/无应答 // 如果不是数据状态，不应收到2、3、4、10、11，不进行任何应答，让主站超时复位 // 如果是复位进程状态，不应答主站发送应用层报文 if (pt->st101 != IEC101_ST_DATA || pt->bResetProcess) { return; } ti = pd[2 + AddByte]; vsq = pd[3 + AddByte]; cot = pd[4 + AddByte]; info_addr = pt->recvbuf + IEC101_InfoAddr(); info_len = L + 4 - IEC101_InfoAddr(); switch (ti) // 类型标识判断 { case 250: // 级联报文数据上送 IEC101_LinkInf(pt); break; case 106: if (cot == 6) // 延时获得 { // 此处不修改报文，真正发送的时候再计算修改 IEC101_Asdu_Add(pt, info_addr, info_len, vsq, IEC_COT_ACTCON, ti, FRAME_I | FRAME_I_106); } else if (cot == 3) // 延时传递 { // 保存主站下发的传输延时 pt->ms_delay = info_addr[2] + (info_addr[3] << 8); } else { IEC101_Asdu_Add(pt, info_addr, info_len, vsq, IEC_COT_UN_COT | IEC_COT_PN, ti, FRAME_I); } IEC101_FrameEcho(pt, IEC101_ECHO_SURE); // 链路应答确认 break; case 103: // 0xFF: //set time ,BroadCast Command // 检查COT if (cot == IEC_COT_REQ || cot == IEC_COT_ACT) { IEC101_TimeSetEcho(pt, &pd[8 + AddByte + AppByte + CotByte], cot); // Addbyte 链路地址和应用单元地址多了2个字节，传送原因多1个字节 } else { IEC101_Asdu_Add(pt, info_addr, info_len, vsq, IEC_COT_UN_COT | IEC_COT_PN, ti, FRAME_I); } pt->bTimeSyn = true; IEC101_FrameEcho(pt, IEC101_ECHO_SURE); // 链路应答确认 break; case 100: // 总查询 // 检查COT if (cot != IEC_COT_ACT) { IEC101_Asdu_Add(pt, info_addr, info_len, vsq, IEC_COT_UN_COT | IEC_COT_PN, ti, FRAME_I); } else { IEC101_CallAll(pt, pd[8 + AddByte + AppByte + CotByte]); // Addbyte 链路地址和应用单元地址多了2个字节，传送原因多1个字节 lnk_call_all(); } IEC101_FrameEcho(pt, IEC101_ECHO_SURE); // 链路应答确认 break; case 101: // 电度总召 // 检查COT if (cot != IEC_COT_ACT) { IEC101_Asdu_Add(pt, info_addr, info_len, vsq, IEC_COT_UN_COT | IEC_COT_PN, ti, FRAME_I); } else { IEC101_DDAll(pt, pd[8 + AddByte + AppByte + CotByte]); // Addbyte 链路地址和应用单元地址多了2个字节，传送原因多1个字节 } IEC101_FrameEcho(pt, IEC101_ECHO_SURE); // 链路应答确认 break; case 104: // 测试帧 IEC101_TestFrame(pt, &pd[8 + AddByte + AppByte + CotByte]); IEC101_FrameEcho(pt, IEC101_ECHO_SURE); break; case 105: // 检查COT if (cot != IEC_COT_ACT) { IEC101_Asdu_Add(pt, info_addr, info_len, vsq, IEC_COT_UN_COT | IEC_COT_PN, ti, FRAME_I); } else { u8 qrp; qrp = pd[8 + AddByte + AppByte + CotByte]; #ifdef FUNC_RESET_EQU gb_ResetEqu = true; #endif switch (qrp) // 复位进程命令限定词 QRP { // 进程的总复位 case 1: rt_printf_time("IEC101(%d) Reset: 进程的总复位!\r\n", pt->chnl); IEC101_ResetTxBuf(pt); // 记录复位计时起点和设置复位进程标志 pt->us0_ResetProcess = ustimer_get_origin(); pt->bResetProcess = true; break; // 复位事件缓冲区等待处理的带时标信息 case 2: rt_printf_time("IEC101(%d) Reset: 复位事件缓冲区!\r\n", pt->chnl); g_soe_queue.tail_send[pt->chnl].n = g_soe_queue.head.n; g_soe_queue.tail_ack[pt->chnl].n = g_soe_queue.tail_send[pt->chnl].n; break; } IEC101_ResetProcess(pt, qrp); } IEC101_FrameEcho(pt, IEC101_ECHO_SURE); break; case 45: // 单点遥控 case 46: // 双点遥控 // 检查单双点是否和参数设置相符 if ((ti == 45 && tRunPara.YKtype == 1) || (ti == 46 && tRunPara.YKtype == 0)) { // 对不支持的类型标识，否定应答 IEC101_FrameEcho(pt, IEC101_ECHO_DENY); rt_printf("101遥控类型不符(ti=%d,YKtype=%d)\r\n", ti, tRunPara.YKtype); break; } // 检查COT if (cot != IEC_COT_ACT && cot != IEC_COT_DEACT) { IEC101_Asdu_Add(pt, info_addr, info_len, vsq, IEC_COT_UN_COT | IEC_COT_PN, ti, FRAME_I | FRAME_I_PRIOR_HIGH); } else { IEC101_RmtCtrl(pt, &pd[2 + AddByte]); } IEC101_FrameEcho(pt, IEC101_ECHO_SURE); // 链路应答确认 break; case 122: // 召目录，选择文件，召唤文件，召唤节 IEC101_File_Echo(pt, &pd[2 + AddByte]); // 响应文件召唤 IEC101_FrameEcho(pt, IEC101_ECHO_SURE); // 链路应答确认 break; case 124: // 确认文件，确认节的应答 IEC101_File_Sure(pt, &pd[2 + AddByte]); // 对文件操作确认 IEC101_FrameEcho(pt, IEC101_ECHO_SURE); // 链路应答确认 break; case 176: // 本装置复归 ResetHzLed(0); SignalReset(0, false); IEC101_FrameEcho(pt, IEC101_ECHO_SURE); // 链路应答确认 break; #ifdef RCD_STRAN_S case RCD_TYPE: // 本装置复归 IEC101_Rcd_Ack(pt); IEC101_FrameEcho(pt, IEC101_ECHO_SURE); // 链路应答确认 break; #endif case 200: // 切换定值区 if (cot == IEC_COT_ACT) { IEC101_SectionWrite(pt, &pd[8 + AddByte + AppByte + CotByte]); // Addbyte 链路地址和应用单元地址多了2个字节，传送原因多1个字节 } else { IEC101_Asdu_Add(pt, info_addr, info_len, vsq, IEC_COT_UN_COT | IEC_COT_PN, ti, FRAME_I); } IEC101_FrameEcho(pt, IEC101_ECHO_SURE); // 链路应答确认 break; case 201: // 读取当前定值区号 if (cot == IEC_COT_ACT) { IEC101_SectionRead(pt); // Addbyte 链路地址和应用单元地址多了2个字节，传送原因多1个字节 } else { IEC101_Asdu_Add(pt, info_addr, info_len, vsq, IEC_COT_UN_COT | IEC_COT_PN, ti, FRAME_I); } IEC101_FrameEcho(pt, IEC101_ECHO_SURE); // 链路应答确认 break; break; case FOS_PAR_READ_ONE: // 南网佛山局 读取单个参数 case FOS_PAR_READ_MUL: // 南网 读取多个参数 case FOS_PAR_SET_ONE: // 南网佛山局 设置单个参数 case FOS_PAR_SET_MUL: // 南网 设置多数参数 // 检查COT if (cot != IEC_COT_ACT && cot != IEC_COT_DEACT) { IEC101_Asdu_Add(pt, info_addr, info_len, vsq, IEC_COT_UN_COT | IEC_COT_PN, ti, FRAME_I); } else { IEC101_ParCtrl(pt, &pd[2 + AddByte]); } IEC101_FrameEcho(pt, IEC101_ECHO_SURE); // 链路应答确认 break; case 202: // 读参数 if (cot == IEC_COT_ACT) { int ret; #ifdef YPARA_LINK ret = iec_setread_mananger((void *)pt, &pd[6 + AddByte + AppByte + CotByte], vsq, false); #else ret = iec_setread((void *)pt, &pd[6 + AddByte + AppByte + CotByte], vsq, false); // vsq为需读参数的个数，0，代表读全部参数，参数为从定值区开始的数据 #endif if (ret != 0) // 读定值出错，否定应答 { IEC101_Asdu_Add(pt, info_addr, info_len, vsq, IEC_COT_UN_OA, ti, FRAME_I); } } else { IEC101_Asdu_Add(pt, info_addr, info_len, vsq, IEC_COT_UN_COT | IEC_COT_PN, ti, FRAME_I); } IEC101_FrameEcho(pt, IEC101_ECHO_SURE); // 链路应答确认 break; case 203: // 修改参数 if (cot == IEC_COT_ACT || cot == IEC_COT_DEACT) { int ret; #ifdef YPARA_LINK int link_ch; link_ch = get_ypara_linkch_write((void *)pt, &pd[6 + AddByte + AppByte + CotByte], vsq, false); if (link_ch == 0) { rt_printf("101------写本地定值\r\n"); ret = iec_setwrite((void *)pt, &pd[6 + AddByte + AppByte + CotByte], cot, vsq, false); // vsq为需读参数的个数，0，代表固化参数，参数为从定值区开始的数据 if (ret != 0) // 写定值出错，否定应答 { BYTE rcot = IEC_COT_ACTCON | IEC_COT_PN; if (cot == IEC_COT_DEACT) rcot = IEC_COT_DEACTCON | IEC_COT_PN; IEC101_Asdu_Add(pt, info_addr, info_len, vsq, rcot, ti, FRAME_I); } else { BYTE rcot = IEC_COT_ACTCON; if (cot == IEC_COT_DEACT) rcot = IEC_COT_DEACTCON; IEC101_Asdu_Add(pt, info_addr, info_len, vsq, rcot, ti, FRAME_I); } } else { rt_printf("101------写级联定值\r\n"); IEC101_Rmt_msg_ypara_write((void *)pt, &pd[6 + AddByte + AppByte + CotByte], vsq, link_ch); if ((link_ch & 0x1f) == 0x1f) /*广播写直接返回确认*/ { BYTE rcot = IEC_COT_ACTCON; if (cot == IEC_COT_DEACT) rcot = IEC_COT_DEACTCON; IEC101_Asdu_Add(pt, info_addr, info_len, vsq, rcot, ti, FRAME_I); } } #else ret = iec_setwrite((void *)pt, &pd[6 + AddByte + AppByte + CotByte], cot, vsq, false); // vsq为需读参数的个数，0，代表固化参数，参数为从定值区开始的数据 if (ret != 0) // 写定值出错，否定应答 { BYTE rcot = IEC_COT_ACTCON | IEC_COT_PN; if (cot == IEC_COT_DEACT) rcot = IEC_COT_DEACTCON | IEC_COT_PN; IEC101_Asdu_Add(pt, info_addr, info_len, vsq, rcot, ti, FRAME_I); } else { BYTE rcot = IEC_COT_ACTCON; if (cot == IEC_COT_DEACT) rcot = IEC_COT_DEACTCON; IEC101_Asdu_Add(pt, info_addr, info_len, vsq, rcot, ti, FRAME_I); } #endif } else { IEC101_Asdu_Add(pt, info_addr, info_len, vsq, IEC_COT_UN_COT | IEC_COT_PN, ti, FRAME_I); } IEC101_FrameEcho(pt, IEC101_ECHO_SURE); // 链路应答确认 break; case 210: // 文件传输 { pt->tf.vsq = vsq; if (cot == IEC_COT_ACT || cot == IEC_COT_REQ) { int ret; ret = iec_file_app((void *)pt, &pt->recvbuf[12 + AddByte + AppByte + CotByte], cot, pt->recvbuf[1] - (AddByte + CotByte + AppByte) - 9, false); // 从操作标识开始 if (ret != 0) // 文件处理错误 { BYTE rcot = IEC_COT_UN_OA; if (ret == -2) rcot = IEC_COT_UN_COT; IEC101_Asdu_Add(pt, info_addr, info_len, vsq, rcot, ti, FRAME_I); } } else { IEC101_Asdu_Add(pt, info_addr, info_len, vsq, IEC_COT_UN_COT | IEC_COT_PN, ti, FRAME_I); } IEC101_FrameEcho(pt, IEC101_ECHO_SURE); // 链路应答确认 } break; case 211: // 文件升级 { if (cot == IEC_COT_ACT || cot == IEC_COT_DEACT) { int ret; ret = iec_pro_update((void *)pt, cot, pd[8 + AddByte + CotByte + AppByte], false); // 从操作标识开始 if (ret != 0) // 文件处理错误 { BYTE rcot = IEC_COT_UN_OA; IEC101_Asdu_Add(pt, info_addr, info_len, vsq, rcot, ti, FRAME_I); } } else { IEC101_Asdu_Add(pt, info_addr, info_len, vsq, IEC_COT_UN_COT | IEC_COT_PN, ti, FRAME_I); } IEC101_FrameEcho(pt, IEC101_ECHO_SURE); // 链路应答确认 } break; default: IEC101_FrameEcho(pt, IEC101_ECHO_DENY); break; } break; case 0: // 复位通信单元 // 复位通道 IEC101_Reset(pt); if (pd[0] & 0x80) // add by sunxi 防止IEC101_Reset调用后，bDIR变为默认值，后续发送报文，标示出错 { pt->bDIR = true; } else { pt->bDIR = false; } g_comm_link_status |= (1 << pt->chnl); IEC101_State(pt, tRunPara.tUartPara[pt->chnl].b101PH ? IEC101_ST_LINK : IEC101_ST_DATA); pt->LinkCount++; // 应答报文 IEC101_InitOK(pt); IEC101_FrameEcho(pt, IEC101_ECHO_SURE); // "重新连接后，总召前，发送完所有老的SOE,不发送COS" IEC101_SendEvent(pt, 0); break; case 2: // 链路测试功能 // 如果不是数据状态，不应收到2、3、4、10、11，不进行任何应答，让主站超时复位 if (pt->st101 != IEC101_ST_DATA) { return; } // 南瑞主站，功能码是2，发送长帧测试帧 if (bLFrame) { ti = pd[2 + AddByte]; if (ti == 104) { IEC101_TestFrame(pt, &pd[8 + AddByte + AppByte + CotByte]); } } IEC101_FrameEcho(pt, IEC101_ECHO_SURE); break; default: IEC101_FrameEcho(pt, IEC101_ECHO_DENY); break; } // 类型判断结束 // 广播地址不用应答 if ((pd[1] != 0xff) || (tRunPara.b101Addr2Byte && (pd[2] != 0xff)) // 平衡101广播查询链路状态回本机地址，江西吉安博威主站要求 || (tRunPara.tUartPara[pt->chnl].b101PH && (pd[0] & 0x0f) == 9)) { pt->btx_buf_s = true; } } // FCV位有效，FCB没有变位，重发保存的确认帧。 else { // 重发数据 if (pt->st101 == IEC101_ST_DATA) { if (pt->btx_buf_s) { rt_printf_time("IEC101_Applay:,btx_buf_s==1.\r\n"); } pt->btx_buf_s = true; } } } // 平衡101 ，接收到主站回复的数据 else { if (!tRunPara.tUartPara[pt->chnl].b101PH) return; switch (pt->st101) { case IEC101_ST_LINK: { if ((pd[0] & 0x0f) == 11) // 应答链路状态 { IEC101_State(pt, IEC101_ST_RSTLINK); pt->bMSend = false; } break; } case IEC101_ST_RSTLINK: { if ((pd[0] & 0x0f) == 0) // 应答链路状态 { IEC101_State(pt, IEC101_ST_DATA); pt->bMSend = false; } break; } case IEC101_ST_DATA: { if ((pd[0] & 0x0f) == 0) // 确认应答，调整一级数据缓冲区 { IEC101_AckOneBuf(pt); pt->bMSend = false; } break; } } } } // 获取GPRS信息 else if (pt->bCallGprsInf) { if (g_tRsComm[pt->chnl].bextsend || pt->btx_buf_s || pt->btx_buf_m) return; // 正在发送数据，不处理 pt->bCallGprsInf = false; IEC101_CallGprsInf(pt); pt->btx_buf_s = true; } // 无有效数据接收，平衡式101处理自动发送数据 else { if (!tRunPara.tUartPara[pt->chnl].b101PH) return; // 如果启动了主站发送，必须先处理应答 if (pt->bMSend) { bool bRtn = true; // 20秒后，未收到应答报文 if (ustimer_get_duration(pt->us0_msend) > pRunSet->dT101Resend * USTIMER_SEC) { pt->us0_msend = ustimer_get_origin(); if (++pt->msend_retries > 2) // 重发三次后,重新初始化 { // rt_printf_time("IEC101(%d):启动帧重发错误!\r\n",pt->chnl); char log_info[128]; sprintf(log_info, "IEC101(%d):Restart the frame to make three errors", pt->chnl + 1); load_hs_log_rcd(TYPE_COMM_ERR, true, NULL, log_info, 1); log_flag.com_err[pt->chnl] = true; IEC101_Info_Printf_One(pt); IEC101_Reset(pt); } else { // 需重新组织发送 pt->btx_buf_m = true; } return; } #ifdef COMM_STATION_NR if (pt->tx_buf[0].tb_head != pt->tx_buf[0].tb_tail_send) // 有遥控报文要发送 { if (ustimer_get_duration(pt->us0_msend) > 2 * USTIMER_SEC) // 且上帧报文发送超过2秒,不等待应道报文，直接发送 { IEC101_AckOneBuf(pt); pt->bMSend = false; bRtn = false; } } if (pt->bTestFrameL || pt->bSoeResume || pt->bTimeSyn) // 总召前有SOE续传不需要主站确认 { pt->bTestFrameL = false; pt->bSoeResume = false; pt->bTimeSyn = false; IEC101_AckOneBuf(pt); pt->bMSend = false; bRtn = false; } #endif if (bRtn) { return; // 发送，未收到数据，返回 } } // 平衡101应答完成 // 先复位应答相关变量 pt->msend_retries = 0; pt->us0_msend = ustimer_get_origin(); // 开始主动发送流程 switch (pt->st101) { case IEC101_ST_LINK: { IEC101_MFrameCall(pt, IEC101_CALL_LINK); pt->bMFCB = false; pt->bMSend = true; break; } case IEC101_ST_RSTLINK: { IEC101_MFrameCall(pt, IEC101_CALL_RSTLINK); pt->bMFCB = false; pt->bMSend = true; break; } case IEC101_ST_DATA: { pt->bMSend = IEC101_SendOneBuf(pt); if (!pt->bMSend) // 无数据 判断 { if (pt->tfile.bSegtransing) // 文件传输，放入一级数据缓冲区 { IEC101_SegmentContinue(pt); } else if (pt->tf.bTransing) // 国网新标准文件传输 { iec_readfile_send(pt, false); } else { pt->bycsend = IEC101_GetYc(pt); if (pt->bycsend) pt->bMSend = TRUE; } } break; } } // 有数据要发送 if (pt->bMSend) { if (pt->btx_buf_m) { // rt_printf_time("IEC101_Applay:bMSend==1,btx_buf_m==1.\r\n"); } pt->bMFCB = !pt->bMFCB; pt->btx_buf_m = true; } } } /************************************************************************** 函数名称：IEC101_SendEvent 函数版本：1.00 作者： 创建日期：2008.9.1 函数功能说明：上送事件记录及变位信息,在RS485定时处理任务(IEC101_AutoTimer)中调用 输入参数： 输出参数： 返回值： 更新信息： 更新日志1： 日期： 修改者： 修改内容： 修改原因： ***************************************************************************/ EVENT_STRUCT event_p[64]; u32 IEC101_SendEvent(IEC101_DEF *pt, int is_send_cos) { u8 type; int vsq = 0, num_vsp; u8 arrCos[200], arrSoe[200]; u8 arrCos1[200], arrSoe1[200]; u16 head, cnt; u16 soe_no_s, soe_no_d, arg_index[64]; bool bFault; FAULT_PARA_BUF *tf = &pt->tfault; // 主动上送条件: // 1、是IEC101_ST_DATA状态 // 2、没有在处理加密遥控报文 // 3、不是复位进程状态 if ((pt->st101 != IEC101_ST_DATA) || pt->bRmtSM2 || pt->bResetProcess) { return 0; } // 不允许通讯续传的情况下，总召后才允许上送事件 if (pt->bSendChange == 0) // && pRunSet->bTT_SoeResumeComm == 0) { return 0; } #ifdef FUN_SOE_DELAY_TIME if ((pt->bfirst_call) && (dTCounter - pt->DTSendChange <= 15 * T_1s)) { return 0; } pt->bfirst_call = false; #endif // 一级缓冲区未空，不添加事件记录 if (pt->tx_buf[0].tb_head != pt->tx_buf[0].tb_tail_send) { // rt_printf("%s(0):tb_head=%d,tb_tail_send=%d\r\n",__func__,pt->tx_buf[0].tb_head,pt->tx_buf[0].tb_tail_send); return 0; } if (pt->tx_buf[1].tb_head != pt->tx_buf[1].tb_tail_send) { return 0; } #ifndef IEC_JXYB_DEAL if (g_run_stu.bjx) // 检修压板投入，不发送变化的事件记录 { g_soe_queue.tail_send[pt->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; IEC101_Asdu_Add_sts(pt, &tf->data[index][1], tf->data[index][0], 0, 3, 42, FRAME_I_PRIOR_LOW, 0); tf->tail++; return 0; } } // 等SOE保存后再发送，避免通讯确认没有保存的事件 head = g_soe_queue.tail_eep.n; // 一次调用，将事件池中所有事件发送完， // 已保证满足"重新连接后，总召前，发送完所有老的SOE,不发送COS"的需求。 cnt = 0; while (1) { u8 yxtype = 0; u8 pcosnum = 0, pcosnum1 = 0; // 检查发送队列空间,空间应大于1/4，防止发送缓冲区满 if (IEC101_BufFreeNum(&pt->tx_buf[0]) < (IEC_TBUF_NUM >> 2)) { rt_printf("IEC101_SendEvent:BufFreeNum=%d.\r\n", IEC101_BufFreeNum(&pt->tx_buf[0])); break; } // 获取一帧报文的事件 bFault = false; num_vsp = asdu_get_event(pt->chnl, head, arrCos, arrSoe, arrCos1, arrSoe1, &soe_no_s, &soe_no_d, 0, &bFault, &event_p[0], &arg_index[0], &yxtype, &pcosnum, &pcosnum1); if (num_vsp == 0) break; // rt_printf("%s:vsq_s=%d\r\n",__func__,vsq); if (pcosnum != 0) { // 发送COS if (is_send_cos && pt->bSendChange) { type = 1; IEC101_Asdu_Add(pt, arrCos, pcosnum * 3, pcosnum, 3, type, FRAME_I_COS); } } vsq = (u8)(num_vsp & 0xff); if (vsq != 0) { cnt += vsq; // 发送SOE type = 30; IEC101_Asdu_Add_sts(pt, arrSoe, vsq * 10, vsq, 3, type, FRAME_I_SOE, soe_no_s); } if (pcosnum1 != 0) { // 发送COS if (is_send_cos) { type = 3; IEC101_Asdu_Add(pt, arrCos1, pcosnum1 * 3, pcosnum1, 3, type, FRAME_I_COS); } } vsq = (u8)((num_vsp >> 8) & 0xff); // rt_printf("%s:vsq_d=%d\r\n",__func__,vsq); if (vsq != 0) { cnt += vsq; // 发送SOE type = 31; IEC101_Asdu_Add_sts(pt, arrSoe1, vsq * 10, vsq, 3, type, FRAME_I_SOE, soe_no_d); // rt_printf_time("IEC101_SendEvent:soe_no=%d.\r\n",soe_no); } vsq = (u8)((num_vsp >> 16) & 0xff); // rt_printf("%s:vsq_e=%d\r\n",__func__,vsq); if (vsq > 0 && tRunPara.bEvPara) // 上送故障信息 { int i; u16 no; u8 SIQ, week; struct rtc_time_t rt; for (i = 0; i < vsq; i++) { u8 *pd = g_arrIECBuf; u8 yc_num; no = soe_lp2cp(event_p[i].ev_type, event_p[i].ev_code, event_p[i].ev_arg[1]); SIQ = event_p[i].ev_value; if ((yxtype == 1)) { SIQ += 1; // 转为双点信息 } #if !defined FUNC_JX_YC_SIQ00 if (g_run_stu.bjx) { SIQ |= 0x80; // 带品质描述，有效 <1>：=无效 } #endif timespec_to_rtc(event_p[i].ts, &rt, 1); week = WEEK_DAY(event_p[i].ts.tv_sec); // if(pRunSet->bTT_faultparaDKY) //{ yc_num = asdu_get_event_yc(arrSoe, 0, arg_index[i]); // 101规约是6个字节 按照规约规定，101 及104 遥信信息体地址都是两个字节 //} // else //{ // vsq=asdu_get_event_yc(arrSoe,1,arg_index); // 101规约是6个字节 按照规约规定，101 及104 遥信信息体地址都是两个字节 //} *pd++ = 1; // 遥信个数 *pd++ = (yxtype == 1) ? 31 : 30; // 类型标识 *pd++ = (u8)no; // 信息体地址L *pd++ = (u8)(no >> 8); // 信息体地址H if (pRunSet->bTT_faultparaDKY) { *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; *pd++ = yc_num; // 遥 测个数 *pd++ = 13; // 类型标识 浮点值 // if(pRunSet->bTT_faultparaDKY) //{ memcpy(pd, arrSoe, yc_num * 6); // 标准规定，遥测点号是2个字节 IEC101_Asdu_Add_sts(pt, g_arrIECBuf, yc_num * 6 + (pd - g_arrIECBuf), 0, 3, 42, FRAME_I_PRIOR_LOW, 0); //} // else //{ // memcpy(pd,arrSoe,vsq*7); // 标准规定，遥测点号是3个字节 // IEC101_Asdu_Add_sts(pt,g_arrIECBuf,vsq*7+14,0,3,42,FRAME_I_PRIOR_LOW ,0); //} } } // pt->bSoeRelink=false; } return cnt; } /************************************************************************** 函数名称：IEC101_Recv_Rst 函数版本：1.00 作者： 创建日期：2008.9.1 函数功能说明：复归数据的接受 输入参数： 输出参数： 返回值： 更新信息： 更新日志1： 日期： 修改者： 修改内容： 修改原因： ***************************************************************************/ static void IEC101_Recv_Rst(IEC101_DEF *pt) { if (pt->nTypeCounter) { rt_printf_time("IEC101_Recv_Rst:state=%d,counter=%d\r\n", pt->nTypeCounter, pt->nRecvCounter); } pt->nTypeCounter = 0; pt->nRecvLenth = 0; pt->nRecvCounter = 0; } /************************************************************************** 函数名称：IEC101_AutoTimer 函数版本：1.00 作者： 创建日期：2008.9.1 函数功能说明：101规约链路内容定时处理部分,100毫秒调用1次 输入参数： 输出参数： 返回值： 更新信息： 更新日志1： 日期： 修改者： 修改内容： 修改原因： ***************************************************************************/ void IEC101_AutoTimer(IEC101_DEF *pt) { // 如果有数据就发送 IEC101_Send_Polling(pt); // 配电终端在发送复位进程确认命令后需等待3秒，然后重启进程 if (pt->bResetProcess && ustimer_get_duration(pt->us0_ResetProcess) > 3 * USTIMER_SEC) { IEC101_Reset(pt); #ifdef IEC_RESET_PROCESS rt_printf("装置重启\r\n"); watchdog_reset_cpu(2); // 装置复位 #endif } // 如果连接没有建立，不处理下面流程 if (pt->st101 == IEC101_ST_NONE) { return; } // 处理加密遥控报文标志超时返回 if (pRunSet->bTT_SM2) { if (ustimer_get_duration(pt->us0_SM2Over) > 60 * USTIMER_SEC) { pt->bRmtSM2 = false; } } // 1秒处理任务 if (ustimer_get_duration(pt->us0_sec) > USTIMER_SEC) { pt->us0_sec += USTIMER_SEC; pt->secs++; // 通道检查 默认10分钟没有收到数据，认为通道错误 if (pt->dValidTime++ > pRunSet->dT101Check) { char log_info[128]; rt_printf_time("IEC101(%d):通道超时\r\n", pt->chnl); sprintf(log_info, "IEC101(%d):Channel timeout", pt->chnl + 1); load_hs_log_rcd(TYPE_COMM_ERR, true, NULL, log_info, 1); log_flag.com_err[pt->chnl] = true; IEC101_Info_Printf_One(pt); IEC101_Reset(pt); } } if (pt->tf.bTransing || pt->tf.bdatTraned) // 文件启动了传输，在3次重发间隔内，未有文件内容传输更新，释放已申请的文件 { if (ustimer_get_duration(pt->tf.us0_file_trans) > (pRunSet->dT101Resend * USTIMER_SEC * 3)) { #ifdef RCD_STRAN_S log_str_time(LOG_OPERATE, "读文件传输超时!!!!!!!", 0, 1); #endif iec_freefile(&pt->tf); pt->tf.bTransing = false; pt->tf.bdatTraned = false; } } if (pt->tf.bdatwriting) // 文件启动了传输，在3次重发间隔内，未有文件内容传输更新，释放已申请的写文件内存 { if (ustimer_get_duration(pt->tf.us0_file_write) > (pRunSet->dT101Resend * USTIMER_SEC * 3)) { if (!pt->tf.writebuf) { rt_free(&pt->tf.writebuf); pt->tf.writebuf = NULL; } pt->tf.bdatwriting = false; } } if (pt->tf.bUpdateReset) // 文件启动了传输，在3次重发间隔内，未有文件内容传输更新，释放已申请的写文件内存 { if (ustimer_get_duration(pt->tf.us0_updatereset) > (USTIMER_SEC * 2)) { rt_printf("101远程升级，装置复位\r\n"); pt->tf.bUpdateReset = false; watchdog_reset_cpu(2); // 装置复位 } } if (pt->tr.bpreset) // 参数预置 { if (ustimer_get_duration(pt->tr.us0_preset) > (tRunPara.dSM2Time * USTIMER_SEC)) { int i; rt_printf("101预置参数超时清除\r\n"); pt->tr.bpreset = false; for (i = 0; i < RMT_SET_NUMBER; i++) { pt->tr.di[i] = 0; } } } } static bool IEC101_RmtCheck(IEC101_DEF *pt) // 判断是否是遥控报文 { u8 AddByte = 0; if (!pRunSet->bTT_SM2) return false; // 加密功能未投入 if (tRunPara.b101Addr2Byte) AddByte = 1; if ((pt->recvbuf[0] == 0x68) && (pt->recvbuf[4] & 0x40) && ((pt->recvbuf[6 + AddByte] == 45) || (pt->recvbuf[6 + AddByte] == 46))) // 遥控报文 { return true; } return false; } /************************************************************************** 函数名称：IEC101_Recv 函数版本：1.00 作者： 创建日期：2008.9.1 函数功能说明：101规约数据接受判断，只判断是否满足报文格式 输入参数： 输出参数：有完整帧接受，返回1，否则返回 0 返回值： 更新信息： 更新日志1： 日期： 修改者： 修改内容： 修改原因： ***************************************************************************/ static int IEC101_Recv(IEC101_DEF *pt, u8 byRevData) { #ifdef FUNC_ENCRY_IN_ONE_SERIAL IEC101_DEF *pt1; static int iCount = 0, enc_tunnel = 0; #endif // 帧内字符间隔超时检测 if (g_tRsComm[pt->chnl].b_recv_reset) { // 不能复位fifo rt_fifo_reset(&pt->recv_fifo); // IEC101_Recv_Rst(pt); g_tRsComm[pt->chnl].b_recv_reset = 0; } pt->recvbuf[pt->nRecvCounter++] = byRevData; pt->dTRecvPiece = dTCounter; // 接收字符时的时刻，在大循环中判断，是否需要复归 switch (pt->nTypeCounter) { case 0: // 统计接收帧数 s_stat_rx_frame(pt->chnl); if (byRevData == 0x68) { pt->nTypeCounter = 1; } else if (byRevData == 0x10) { if (!tRunPara.b101Addr2Byte) { pt->nRecvLenth = 2; } else { pt->nRecvLenth = 3; } pt->nTypeCounter = 6; pt->nRecvCnt = 0; pt->sum = 0; } else if (byRevData == 0x16) // SM2 报文 { pt->nTypeCounter = 20; pt->nRecvCounter = 256; pt->recvbuf[pt->nRecvCounter++] = byRevData; pt->recvbuf[0] = 0x68; // 恢复被0x16 覆盖的第一字节数据 if (!pRunSet->bTT_SM2) // 加密功能未投入 { IEC101_Recv_Rst(pt); // 统计接收错误帧数 s_stat_rx_errframe(pt->chnl); } } #ifdef FUNC_ENCRY_IN_ONE_SERIAL else if (byRevData == 0xAA) // 海南101规约报文 { pt->nTypeCounter = 26; pt->sum = 0; } #endif else { rt_printf_time("IEC101_Recv(%d):0x%02x.\r\n", pt->chnl, byRevData); IEC101_Recv_Rst(pt); // 统计接收错误帧数 s_stat_rx_errframe(pt->chnl); } break; case 1: pt->nTypeCounter = 2; pt->nRecvLenth = byRevData; // 长帧长度 if (pt->nRecvLenth > IEC101_RECVBUF_MAX) { IEC101_Recv_Rst(pt); // 统计接收错误帧数 s_stat_rx_errframe(pt->chnl); } break; case 2: if (pt->nRecvLenth == byRevData) { pt->nTypeCounter = 3; } else { IEC101_Recv_Rst(pt); // 统计接收错误帧数 s_stat_rx_errframe(pt->chnl); } break; case 3: if (byRevData == 0x68) { pt->nTypeCounter = 6; pt->nRecvCnt = 0; pt->sum = 0; } else { IEC101_Recv_Rst(pt); // 统计接收错误帧数 s_stat_rx_errframe(pt->chnl); } break; // case 4: //控制域 // pt->sum=byRevData; // pt->nTypeCounter=5; // break; // case 5: //目标地址 // pt->sum+=byRevData; // pt->nRecvCnt=0; // pt->nTypeCounter=6; // if(pt->nRecvLenth==2)//短帧 // pt->nTypeCounter=7; // break; case 6: // 有效数据 //有效数据 if (pt->recvbuf[4] == 0x05 && pt->recvbuf[0] == 0x68) // 映翰通 GPRS信息返回报文，同101不同，需特殊处理 { pt->nRecvLenth = 0x30 + 1; } if (++pt->nRecvCnt >= pt->nRecvLenth) { pt->nTypeCounter = 7; } pt->sum += byRevData; break; case 7: // 校验和 pt->recvsum = byRevData; pt->nTypeCounter = 8; break; case 8: // 结束符 pt->nTypeCounter = 0; IEC101_Recv_Rst(pt); if (byRevData == 0x16) // 校验结束字符,报文接收完毕， { if ((pt->sum != pt->recvsum) && (pt->recvbuf[4] != 0x05)) // 映翰通 GPRS信息返回报文，同101不同，需特殊处理 { s_stat_rx_errframe(pt->chnl); // 统计接收帧错误计数 } else if (IEC101_RmtCheck(pt)) // 是遥控报文 { pt->bData = false; // 应用层暂不处理，等解密完成后处理 if (pRunSet->bTT_SM2) { pt->bRmtSM2 = true; pt->us0_SM2Over = ustimer_get_origin(); } } else { pt->bData = true; if (uart_test_begin) { uart_test_flag[pt->chnl][1] = 1; } // 唤醒主循环 mainloop_wakeup(); return 1; } } break; case 20: // SM2报文 L2长度 pt->SM2L2 = byRevData; pt->nTypeCounter++; break; case 21: // SM2报文 L2长度 pt->nTypeCounter++; if (byRevData >= pt->SM2L2) // L2长度包含L3长度，L3chnl); IEC101_Recv_Rst(pt); } break; case 22: if (byRevData == 0x16) { pt->nTypeCounter++; pt->nRecvCnt = 0; } else { // 统计接收错误帧数 s_stat_rx_errframe(pt->chnl); IEC101_Recv_Rst(pt); } break; case 23: if (++pt->nRecvCnt >= pt->SM2L2) { pt->nTypeCounter++; } break; case 24: // 校验和 pt->nTypeCounter++; break; case 25: // 结束符 pt->nTypeCounter = 0; IEC101_Recv_Rst(pt); if (byRevData == 0x16) // 校验结束字符,报文接收完毕， { pt->bSM2Data = true; mainloop_wakeup(); return 1; } else { s_stat_rx_errframe(pt->chnl); } break; #ifdef FUNC_ENCRY_IN_ONE_SERIAL case 26: // 帧长低字节 pt->nTypeCounter++; pt->nRecvLenth = byRevData; pt->sum += byRevData; break; case 27: // 帧长高字节 pt->nTypeCounter++; pt->nRecvLenth = (byRevData << 8) | pt->nRecvLenth; pt->sum += byRevData; break; case 28: // 加密隧道编号 pt->nTypeCounter++; pt->enc_tunnel = byRevData; if (pt->enc_tunnel > 1) { enc_tunnel = pt->enc_tunnel + 1; } else { enc_tunnel = pt->enc_tunnel; } pt->sum += byRevData; pt->nRecvCnt = 0; break; case 29: // 数据 if (++pt->nRecvCnt >= pt->nRecvLenth) { pt->nTypeCounter++; } pt->sum += byRevData; if (tRunPara.tUartPara[0].wProtocol == PROTOCOL_WED_ENC) { pt1 = (IEC101_DEF *)g_tRsComm[enc_tunnel].ptBuf; pt1->recvbuf[iCount] = byRevData; pt1->enc_tunnel = pt->enc_tunnel; pt1->nRecvLenth = pt->nRecvLenth; iCount++; } break; case 30: // 校验和 pt->recvsum = byRevData; pt->nTypeCounter++; break; case 31: // 帧尾 pt->nTypeCounter = 0; IEC101_Recv_Rst(pt); iCount = 0; if (byRevData == 0x55) // 校验结束字符,报文接收完毕， { if (pt->sum != pt->recvsum) { s_stat_rx_errframe(pt->chnl); // 统计接收帧错误计数 } else { pt1 = (IEC101_DEF *)g_tRsComm[enc_tunnel].ptBuf; pt1->bData = true; enc_tunnel = 0; // 唤醒主循环 mainloop_wakeup(); return 1; } } break; #endif default: // 统计接收错误帧数 s_stat_rx_errframe(pt->chnl); IEC101_Recv_Rst(pt); break; } // 类型校验结束 return 0; } void IEC101_Recv_App(IEC101_DEF *pt) { u8 c; // 接收数据 while (pt->bSM2Data == false && pt->bData == false) { if (rt_fifo_get(&pt->recv_fifo, &c, 1) == 0) { if (g_tRsComm[pt->chnl].b_recv_reset) { IEC101_Recv_Rst(pt); g_tRsComm[pt->chnl].b_recv_reset = 0; } break; } if (pRunSet->bTT_ESAM && (!pt->bMaintainComm)) { int ret; ret = sec_recv(&pt->rx_buf, c, pt->extsendbuf, true); if (ret == SEC_FRAME_OK_APP) // 带规约的报文 { pt->bData = 1; } else if (ret == SEC_FRAME_OK_EXT) // 纯安全扩展报文 发送 { IEC101_ext_send(pt, pt->extsendbuf + 2, ((pt->extsendbuf[0] << 8) + pt->extsendbuf[1])); } } else { #ifdef FUNC_ENCRY_IN_ONE_SERIAL int ret; ret = IEC101_Recv(pt, c); if (ret == 1) break; #else IEC101_Recv(pt, c); #endif } } } void IEC101_Recv_Int(IEC101_DEF *pt, u8 byRevData) { // 记录每个不定长帧报文的接收时刻 if (!pRunSet->bTT_ESAM || pt->bMaintainComm) { if (byRevData == 0x68) { struct rt_fifo *f; f = &pt->recv_fifo; // 判断不定帧长报头 0x68 L L 0X68 if ((f->buffer[(f->in - 1) & (f->size - 1)]) == (f->buffer[(f->in - 2) & (f->size - 1)]) && (f->buffer[(f->in - 3) & (f->size - 1)]) == 0x68) { pt->us0_frame = ustimer_get_origin(); } } } rt_fifo_put(&pt->recv_fifo, &byRevData, 1); } int IEC101_PH_GprsInfo(void) { int i; for (i = 0; i < CFG_UART_NUM_MAX; i++) { if (UART_CHANNEL[i] < 0) { continue; } // 外部通信报文处理 if (tRunPara.tUartPara[i].wProtocol == PROTOCOL_101_PH) // 101规约 { IEC101_DEF *pt = (IEC101_DEF *)g_tRsComm[i].ptBuf; pt->bCallGprsInf = true; } } return 0; } void IEC101_Info_Printf_One(IEC101_DEF *p) { iec_tbuf_t *pt; rt_printf("\r\n 通道属性:type=%d,chnl=%d\r\n", p->type, p->chnl); if (p->st101 == 0) { return; } rt_printf(" 规约状态:state=%d,bSendChange=%d\r\n", p->st101, p->bSendChange); rt_printf(" 连接计时:LinkCount(%d):%d秒\r\n", p->LinkCount, p->secs); pt = &p->tx_buf[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->tx_buf[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); pt = &p->tx_buf[2]; 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 IEC101_Info_Printf(void) { int i; IEC101_DEF *p; // 串口101 rt_printf("\r\n串口101:"); for (i = 0; i < CFG_UART_NUM_MAX; i++) { // 如果串口不存在，跳过 if (UART_CHANNEL[i] < 0) { continue; } if (tRunPara.tUartPara[i].wProtocol != PROTOCOL_101 && tRunPara.tUartPara[i].wProtocol != PROTOCOL_101_PH && tRunPara.tUartPara[i].wProtocol != PROTOCOL_MAINTAIN) { rt_printf("\r\n通道属性:非104通道(chnl=%d)\r\n", i); continue; } p = (IEC101_DEF *)g_tRsComm[i].ptBuf; IEC101_Info_Printf_One(p); } return 0; } /************************************************下面是远方修改定值代码******************************************************/ void IEC101_setion_chg_msg(IEC101_DEF *pt101, 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 = pt101->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 IEC101_SectionWrite(IEC101_DEF *pt101, u8 *ps) // 确认帧 { u8 *pd; int num; u8 cot; WORD section; if (pRunSet->wEquTypeManager) IEC101_setion_chg_msg(pt101, 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 = g_arrIECBuf; num = 0; pd[num++] = 0; // 信息体地址 pd[num++] = 0; // 信息体地址 pd[num++] = ps[0]; // 当前定值区 pd[num++] = ps[1]; // 当前定值区 IEC101_Asdu_Add(pt101, g_arrIECBuf, num, 1, cot, 200, FRAME_I); // } void IEC101_SectionRead(IEC101_DEF *pt101) // 读定值区 { u8 *pd; int num; u8 cot; // 组织报文 pd = g_arrIECBuf; num = 0; pd[num++] = 0; // 信息体地址 pd[num++] = 0; // 信息体地址 pd[num++] = (u8)m_runsection; // 当前定值区 pd[num++] = (u8)(m_runsection >> 8); // 当前定值区 pd[num++] = 0; // 最小定值区 pd[num++] = 0; // 最小定值区 pd[num++] = SEC_NUMBER - 1; // 最大定值区 1 标准上是7个字节，暂时认为是2个字节 pd[num++] = 0; // 最大定值区 2 cot = IEC_COT_ACTCON; IEC101_Asdu_Add(pt101, g_arrIECBuf, num, 1, cot, 201, FRAME_I); // } /**************************************************远方修改定值结束*****************************************************/ /***********************************************下面是101规约文件传输部分代码2016-8-10**************************************************/ /************************************************************************** 函数名称：IEC101_Direct_Echo 函数版本：1.00 作者： 创建日期：2007.9.1 函数功能说明：101规约目录响应 输出参数：pt101缓冲区地址，COT 传送原因 返回值： 更新信息： 更新日志1： 日期： 修改者： 修改内容： 修改原因： ***************************************************************************/ void IEC101_Direct_Echo(IEC101_DEF *pt101, DWORD InfoAddr) { BYTE *pd = g_arrIECBuf; // 从第7个字节开始 BYTE vsq; int filenum; struct dir_file_struct *pdir, *pdirfree; int i; vsq = 0; pdir = hf_get_dir_file(IEC_Getdir(InfoAddr), &filenum); // 根据信息体地址，判断读读哪个目录，获取目录信息 if (pdir == NULL) { IEC101_Asdu_Add(pt101, g_arrIECBuf, 0, vsq, 5, 126, FRAME_I); // 无文件应答 return; } pdirfree = pdir; *pd++ = (BYTE)InfoAddr; *pd++ = (BYTE)(InfoAddr >> 8); 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 < (pdir->file_size - 1)) // 目录超出一帧上送范围，分帧，VSQ置后续标准位 { vsq |= 0x80; IEC101_Asdu_Add(pt101, g_arrIECBuf, (vsq & 0x7f) * 13 + 2, vsq, 5, 126, FRAME_I); // 无文件应答 vsq = 0; pd = g_arrIECBuf; } pdir++; } rt_free(pdirfree); if (vsq > 0) { if (vsq > 1) { vsq |= 0x80; } IEC101_Asdu_Add(pt101, g_arrIECBuf, (vsq & 0x7f) * 13, vsq, 5, 126, FRAME_I); // 无文件应答 } else { IEC101_Asdu_Add(pt101, g_arrIECBuf, 0, vsq, 5, 126, FRAME_I); // 无文件应答 } } /************************************************************************** 函数名称：IEC101_EchoFileReady 函数版本：1.00 作者： 创建日期：2007.9.1 函数功能说明：应答文件准备好 输出参数：pt101缓冲区地址，filename 文件名 返回值： 更新信息： 更新日志1： 日期： 修改者： 修改内容： 修改原因： ***************************************************************************/ static void IEC101_EchoFileReady(IEC101_DEF *pt101, DWORD InfoAddr, WORD filename) { BYTE *pd = g_arrIECBuf; // 从第7个字节开始 int filelenth, sectionnum; filelenth = hf_get_file_inf(IEC_Getdir(InfoAddr), filename, §ionnum); /*文件名称*/ *pd++ = (BYTE)InfoAddr; *pd++ = (BYTE)(InfoAddr >> 8); *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否定定认可*/ } pt101->tfile.filelenth = filelenth; pt101->tfile.setctionnum = sectionnum; pt101->tfile.filename = filename; pt101->tfile.InfoAddr = InfoAddr; pt101->tfile.filechecksum = 0; IEC101_Asdu_Add(pt101, g_arrIECBuf, 8, 1, 13, 120, FRAME_I); // 无文件应答 } /************************************************************************** 函数名称：IEC101_EchoSectionReady 函数版本：1.00 作者： 创建日期：2007.9.1 函数功能说明：应答节准备好 输出参数：pt101缓冲区地址，filename 文件名 返回值： 更新信息： 更新日志1： 日期： 修改者： 修改内容： 修改原因： ***************************************************************************/ static void IEC101_EchoSectionReady(IEC101_DEF *pt101, DWORD InfoAddr, WORD filename, BYTE section) { BYTE *pd = g_arrIECBuf; // 从第7个字节开始 int setctionlenth; char *pdat = NULL; IEC101_FreeFile(pt101); *pd++ = (BYTE)InfoAddr; *pd++ = (BYTE)(InfoAddr >> 8); /*文件名称*/ *pd++ = (BYTE)(filename); // 10 *pd++ = (BYTE)(filename >> 8); // 11 if (pt101->tfile.InfoAddr == InfoAddr && pt101->tfile.filename == filename && section <= pt101->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 pt101->tfile.pdat = pdat; // 保存节内容地址，后续需要释放 pt101->tfile.sectionlenth = setctionlenth; pt101->tfile.transsection = section; pt101->tfile.bFiletransing = true; pt101->tfile.bSegtransing = false; pt101->tfile.us0_file_trans = ustimer_get_origin(); pt101->tfile.transBytes = 0; pt101->tfile.sectionchecksum = 0; } IEC101_Asdu_Add(pt101, g_arrIECBuf, 9, 1, 13, 121, FRAME_I); // 无文件应答 } /************************************************************************** 函数名称：IEC101_SegmentSend 函数版本：1.00 作者： 创建日期：2007.9.1 函数功能说明：应答节传输中段的数据 输出参数：pt101缓冲区地址，filename 文件名,section 节名 返回值： 更新信息： 更新日志1： 日期： 修改者： 修改内容： 修改原因： ***************************************************************************/ static void IEC101_SegmentSend(IEC101_DEF *pt101, DWORD InfoAddr, WORD filename, BYTE section) { BYTE *pd = g_arrIECBuf; // 从第7个字节开始 BYTE sectionchecksum = 0; // 节校验和 BYTE segmentbytes; BYTE cot; int i; cot = 13; segmentbytes = 0; if (pt101->tfile.bFiletransing && pt101->tfile.InfoAddr == InfoAddr && pt101->tfile.filename == filename && section == pt101->tfile.transsection) // 文件名相同 节相同 { if (pt101->tfile.transBytes + FILE_SEGMENT_BYTES >= pt101->tfile.sectionlenth) { segmentbytes = pt101->tfile.sectionlenth % FILE_SEGMENT_BYTES; // 最后的段的字节数 } else { segmentbytes = FILE_SEGMENT_BYTES; } pt101->tfile.sectionchecksum = sectionchecksum; pt101->tfile.us0_file_trans = ustimer_get_origin(); pt101->tfile.bSegtransing = true; } else { cot |= 0x40; segmentbytes = 0; IEC101_FreeFile(pt101); } /*文件名称*/ *pd++ = (BYTE)InfoAddr; *pd++ = (BYTE)(InfoAddr >> 8); *pd++ = (BYTE)(filename); // 10 *pd++ = (BYTE)(filename >> 8); // 11 *pd++ = section; // 节名 12 *pd++ = segmentbytes; // 段的长度 13 for (i = 0; i < segmentbytes; i++) { *pd = pt101->tfile.pdat[pt101->tfile.transBytes++]; sectionchecksum += *pd++; } IEC101_Asdu_Add(pt101, g_arrIECBuf, 6 + segmentbytes, 1, cot, 125, FRAME_I); // 无文件应答 } /************************************************************************** 函数名称：IEC101_EchoLastSection 函数版本：1.00 作者： 创建日期：2007.9.1 函数功能说明：应答最后的节或段 输出参数：pt101缓冲区地址，filename 文件名,section 节名,LSQ限定词 返回值： 更新信息： 更新日志1： 日期： 修改者： 修改内容： 修改原因： ***************************************************************************/ static void IEC101_EchoLastSection(IEC101_DEF *pt101, WORD filename, BYTE section, BYTE LSQ) { BYTE *pd = g_arrIECBuf; // 从第7个字节开始 /*文件名称*/ *pd++ = (BYTE)pt101->tfile.InfoAddr; *pd++ = (BYTE)(pt101->tfile.InfoAddr >> 8); *pd++ = (BYTE)(filename); // 10 *pd++ = (BYTE)(filename >> 8); // 11 *pd++ = section; // 节名 12 switch (LSQ) { case 1: *pd++ = 1; // LSQ=1：不带停止激活文件传输13 *pd++ = pt101->tfile.filechecksum; // 文件校验和 14 break; case 3: *pd++ = 3; // LSQ=3：不带停止激活的节传输 *pd++ = pt101->tfile.sectionchecksum; // 节校验和 break; } IEC101_Asdu_Add(pt101, g_arrIECBuf, 7, 1, 13, 123, FRAME_I); // 无文件应答 } /************************************************************************** 函数名称：IEC101_SegmentContinue 函数版本：1.00 作者： 创建日期：2007.9.1 函数功能说明：主循环中继续发送节中剩余的段 输出参数：pt101缓冲区地址，filename 文件名,section 节名 返回值： 更新信息： 更新日志1： 日期： 修改者： 修改内容： 修改原因： ***************************************************************************/ void IEC101_SegmentContinue(IEC101_DEF *pt101) { BYTE *pd = g_arrIECBuf; // 从第7个字节开始 BYTE sectionchecksum = 0; // 节校验和 BYTE segmentbytes; int i; if (!pt101->tfile.bSegtransing) return; if (pt101->tfile.transBytes < pt101->tfile.sectionlenth) // 段还未传输完毕 { if (pt101->tfile.transBytes + FILE_SEGMENT_BYTES >= pt101->tfile.sectionlenth) { segmentbytes = pt101->tfile.sectionlenth % FILE_SEGMENT_BYTES; // 最后的段的字节数 } else { segmentbytes = FILE_SEGMENT_BYTES; } *pd++ = (BYTE)pt101->tfile.InfoAddr; *pd++ = (BYTE)(pt101->tfile.InfoAddr >> 8); /*文件名称*/ *pd++ = (BYTE)(pt101->tfile.filename); // 10 *pd++ = (BYTE)(pt101->tfile.filename >> 8); // 11 *pd++ = pt101->tfile.transsection; // 节名 12 *pd++ = segmentbytes; // 段的长度 13 for (i = 0; i < segmentbytes; i++) { *pd = pt101->tfile.pdat[pt101->tfile.transBytes++]; sectionchecksum += *pd++; } pt101->tfile.sectionchecksum += sectionchecksum; pt101->tfile.us0_file_trans = ustimer_get_origin(); IEC101_Asdu_Add(pt101, g_arrIECBuf, 6 + segmentbytes, 1, 13, 125, FRAME_I); // 无文件应答 } else { IEC101_EchoLastSection(pt101, pt101->tfile.filename, pt101->tfile.transsection, 3); IEC101_FreeFile(pt101); } } void IEC101_File_Respone(IEC101_DEF *pt101, BYTE *dat, BYTE cot, BYTE SCAFQ) // { BYTE *pd = g_arrIECBuf; // 从第7个字节开始 u8 vsq, type; u8 CotByte = 0; // 传送原因双字节 u8 AppByte = 0; // 应用单元地址双字节 if (tRunPara.b101Cot2Byte) CotByte = 1; if (tRunPara.b101App2Byte) AppByte = 1; type = dat[0]; vsq = dat[1]; *pd++ = dat[4 + CotByte + AppByte]; // 应用单元地址 *pd++ = dat[5 + CotByte + AppByte]; // *pd++ = dat[6 + CotByte + AppByte]; // 文件名 *pd++ = dat[7 + CotByte + AppByte]; // *pd++ = dat[8 + CotByte + AppByte]; // 节名 12 *pd++ = SCAFQ; // 限定词 IEC101_Asdu_Add(pt101, g_arrIECBuf, 6, vsq, cot, type, FRAME_I); // 无文件应答 } /************************************************************************** 函数名称：IEC101_File_Echo 函数版本：1.00 作者： 创建日期：2007.9.1 函数功能说明：对文件召唤的应答处理 输出参数：pt101缓冲区地址，dat报文缓冲区地址从报文的帧类型开始 返回值： 更新信息： 更新日志1： 日期： 修改者： 修改内容： 修改原因： ***************************************************************************/ void IEC101_File_App(IEC101_DEF *pt101, BYTE *dat) // dat 从报文的帧类型开始 { BYTE COT, SCQ; // 传送原因 WORD filename, section; // 文件名 节名 DWORD InfoAddr; // 信息体地址 u8 CotByte = 0; // 传送原因双字节 u8 AppByte = 0; // 应用单元地址双字节 if (tRunPara.b101Cot2Byte) CotByte = 1; if (tRunPara.b101App2Byte) AppByte = 1; COT = dat[2]; InfoAddr = dat[4 + CotByte + AppByte] + (dat[5 + CotByte + AppByte] << 8); filename = dat[6 + CotByte + AppByte] + (dat[7 + CotByte + AppByte] << 8); // 文件名 section = dat[8 + CotByte + AppByte]; // 节名 SCQ = dat[9 + CotByte + AppByte]; // 选择和召唤限定词 // rt_printf("\r\n COT=%d addr=%4x filename=%d,section=%d,SCQ=%d",COT,InfoAddr,filename,section,SCQ); if (IEC_Getdir(InfoAddr) == NULL) { IEC101_File_Respone(pt101, dat, (47 | 0x40), SCQ); // 否定应答，非所希望的通信服务 return; } if (COT == 5) /*请求目录 */ { IEC101_Direct_Echo(pt101, InfoAddr); /*目录响应 cot =5代表召唤目录*/ } else if (COT == 13) { switch (SCQ) { case 1: /*选择文件*/ IEC101_EchoFileReady(pt101, InfoAddr, filename); break; case 2: /*请求文件*/ IEC101_EchoSectionReady(pt101, InfoAddr, filename, section); // 节准备好报文 break; case 6: /*请求节*/ IEC101_SegmentSend(pt101, InfoAddr, filename, section); // 发送本节中所有的段 break; default: IEC101_File_Respone(pt101, dat, COT, SCQ | 0x30); // 否定应答，非所希望的通信服务 break; } } else { IEC101_File_Respone(pt101, dat, (45 | 0x40), SCQ); // 否定应答，未知的传送原因 } } /************************************************************************** 函数名称：IEC101_File_Echo 函数版本：1.00 作者： 创建日期：2007.9.1 函数功能说明：对文件召唤的应答处理 输出参数：pt101缓冲区地址，dat报文缓冲区地址从报文的帧类型开始 返回值： 更新信息： 更新日志1： 日期： 修改者： 修改内容： 修改原因： ***************************************************************************/ void IEC101_File_Echo(IEC101_DEF *pt101, BYTE *dat) // dat 从报文的帧类型开始 { BYTE COT, SCQ; // 传送原因 WORD filename, section; // 文件名 节名 DWORD InfoAddr; // 信息体地址 u8 CotByte = 0; // 传送原因双字节 u8 AppByte = 0; // 应用单元地址双字节 if (tRunPara.b101Cot2Byte) CotByte = 1; if (tRunPara.b101App2Byte) AppByte = 1; COT = dat[2]; InfoAddr = dat[4 + CotByte + AppByte] + (dat[5 + CotByte + AppByte] << 8); filename = dat[6 + CotByte + AppByte] + (dat[7 + CotByte + AppByte] << 8); // 文件名 section = dat[8 + CotByte + AppByte]; // 节名 SCQ = dat[9 + CotByte + AppByte]; // 选择和召唤限定词 // rt_printf("\r\n COT=%d addr=%4x filename=%d,section=%d,SCQ=%d",COT,InfoAddr,filename,section,SCQ); if (IEC_Getdir(InfoAddr) == NULL) { IEC101_File_Respone(pt101, dat, (47 | 0x40), SCQ); // 否定应答，非所希望的通信服务 return; } if (COT == 5) /*请求目录 */ { IEC101_Direct_Echo(pt101, InfoAddr); /*目录响应 cot =5代表召唤目录*/ } else if (COT == 13) { switch (SCQ) { case 1: /*选择文件*/ IEC101_EchoFileReady(pt101, InfoAddr, filename); break; case 2: /*请求文件*/ IEC101_EchoSectionReady(pt101, InfoAddr, filename, section); // 节准备好报文 break; case 6: /*请求节*/ IEC101_SegmentSend(pt101, InfoAddr, filename, section); // 发送本节中所有的段 break; default: IEC101_File_Respone(pt101, dat, COT, SCQ | 0x30); // 否定应答，非所希望的通信服务 break; } } else { IEC101_File_Respone(pt101, dat, (45 | 0x40), SCQ); // 否定应答，未知的传送原因 } } /************************************************************************** 函数名称：IEC101_File_Sure 函数版本：1.00 作者： 创建日期：2007.9.1 函数功能说明：对文件处理的确认应答 输出参数：pt缓冲区地址，dat报文缓冲区地址从报文的帧类型开始 返回值： 更新信息： 更新日志1： 日期： 修改者： 修改内容： 修改原因： ***************************************************************************/ void IEC101_File_Sure(IEC101_DEF *pt101, BYTE *dat) // dat 从报文的帧类型开始 { BYTE COT, AFQ; // 传送原因 WORD filename, section; // 文件名 节名 DWORD InfoAddr; // 信息体地址 u8 CotByte = 0; // 传送原因双字节 u8 AppByte = 0; // 应用单元地址双字节 if (tRunPara.b101Cot2Byte) CotByte = 1; if (tRunPara.b101App2Byte) AppByte = 1; COT = dat[2]; InfoAddr = dat[4 + CotByte + AppByte] + (dat[5 + CotByte + AppByte] << 8); filename = dat[6 + CotByte + AppByte] + (dat[7 + CotByte + AppByte] << 8); // 文件名 section = dat[8 + CotByte + AppByte]; // 节名 AFQ = dat[9 + CotByte + AppByte]; // 选择和召唤限定词 if (IEC_Getdir(InfoAddr) == NULL) { IEC101_File_Respone(pt101, dat, (47 | 0x40), AFQ); // 否定应答，未知的信息体地址 return; } if (COT != 13) { IEC101_File_Respone(pt101, dat, (45 | 0x40), AFQ); // 否定应答，未知的传送原因 } switch (AFQ) /*AFQ文件确认或节确认*/ { case 1: // 文件传输的正确认可 IEC101_FreeFile(pt101); IEC101_File_Respone(pt101, dat, COT, AFQ); // 需商讨，文件传输完毕后，对文件的确认，需要上送什么信息合适，以前是上送更新后的目录 sunxi break; case 2: // 文件传输的否定认可 IEC101_FreeFile(pt101); IEC101_File_Respone(pt101, dat, COT, AFQ); // 需商讨，文件传输完毕后，对文件的确认，需要上送什么信息合适，以前是上送更新后的目录 sunxi break; case 3: // 节传输的正确认可 IEC101_FreeFile(pt101); if (pt101->tfile.transsection < pt101->tfile.setctionnum - 1) // 现有调试工具UTDEBU，节名从0开始， tfile.setctionnum 需减1 sunxi ,后续程序恢复 { pt101->tfile.filechecksum += pt101->tfile.sectionchecksum; // 文件校验和 section += 1; IEC101_EchoSectionReady(pt101, InfoAddr, filename, section); // 下一节准备好 } else if (section >= pt101->tfile.setctionnum - 1) // //现有调试工具UTDEBU，节名从0开始， tfile.setctionnum 需减1 sunxi,后续程序恢复 { IEC101_EchoLastSection(pt101, filename, section, 1); // LSQ = 3; 最后的段 } break; case 4: // 节传输的否定认可 IEC101_FreeFile(pt101); IEC101_EchoSectionReady(pt101, InfoAddr, filename, section); // 节准备好报文 break; default: break; } } void IEC101_FreeFile(IEC101_DEF *pt101) { if (pt101->tfile.bFiletransing) { pt101->tfile.bFiletransing = false; pt101->tfile.bSegtransing = false; if (!pt101->tfile.pdat) { rt_free(pt101->tfile.pdat); pt101->tfile.pdat = NULL; } rt_printf("\r\nIEC101文件节传输完毕，释放内存，文件:%d 节:%d\r\n", pt101->tfile.filename, pt101->tfile.transsection); } }