demomotocon.cpp

工业自动化CAN总线通信的应用层程序

				if(OperateCode==0x33 || OperateCode==0x55)
				{
					BOOL bBITWrited = (OperateCode==0x33)?FALSE:TRUE;
					CAN_DATA canDataOld = m_canDataDOS1[(MAX_OFFSET_PS+1)*i+j/SIZEOF_DATA];
					if(bBITWrited) m_canDataDOS1[(MAX_OFFSET_PS+1)*i+j/SIZEOF_DATA].Data[j/8] |= BIT_MASK1<<j%8;
					else m_canDataDOS1[(MAX_OFFSET_PS+1)*i+j/SIZEOF_DATA].Data[j/8] &= BIT_MASK1<<j%8^BIT_MASK2;
					BYTE* pData = &m_canDataDOS1[(MAX_OFFSET_PS+1)*i+j/SIZEOF_DATA].Data[0];
					if(DoWriteData(pCC,m_DvcAddrDest[i],FC_PS_DO_C+j/SIZEOF_DATA,pData,CAN_VDL_FIXED,3))
						m_pDO[m_nSizeDO*i+j]->EndOperate();
					else m_pDO[m_nSizeDO*i+j]->EndOperate(m_strComError);
					m_canDataDOS1[(MAX_OFFSET_PS+1)*i+j/SIZEOF_DATA] = canDataOld;
					m_bCanDataDOS1OK[(MAX_OFFSET_PS+1)*i+j/SIZEOF_DATA] = FALSE;
					break;
				}
			}
		}
	}
}

BOOL CMyUnitCanCM::DoReadData(COMCONTROL* pCC)
{
	BYTE* pCanMsg = &m_canMsg.FC[0];
	memcpy(++pCanMsg,pCCRX,sizeof(m_canMsg)-sizeof(m_canMsg.FC[0]));
	if((m_canMsg.FC[0]&FC_CAN_F)!=FC_CAN_F) {SetComError("CAN帧格式错!"); return FALSE;}
	BYTE DataLen = (m_canMsg.FC[0]&FC_CAN_DL);
	BYTE ValidDL = (DataLen>=sizeof(m_canMsg.CS))?(DataLen-sizeof(m_canMsg.CS)):0;
	if(ValidDL==CAN_VDL_NULL || ValidDL>CAN_VDL_FIXED) {SetComError("数据长度错!"); return FALSE;}
	if(GetAddSum(&m_canMsg.FC[2],10,DataLen)!=m_canMsg.CS) {SetComError("数据校验错!"); return FALSE;}
	if(IsPFofPDU1(m_canMsg.FC[2]))
	{
		if(m_canMsg.FC[2]==FC_PF_DVC_REG && m_canMsg.FC[3]==FC_DA_BRD) ReveiveDvcInfo();
		else ReveiveMonitorInfo();
	}
	else if(IsPFofPDU2(m_canMsg.FC[2]))
	{
		if(m_canMsg.FC[2]!=FC_PF_DVC_PS) {SetComError("PDU2主功能码错!"); return FALSE;}
		BYTE FCParamGrp = m_canMsg.FC[3];
		BYTE DvcAddrDest = m_canMsg.FC[4];
		if(DvcAddrDest<MIN_SIZE_DVC || DvcAddrDest>MAX_SIZE_DVC)
		{
			SetComError("设备地址错!");
			return FALSE;
		}
		else if(FCParamGrp<MIN_SIZE_PS || FCParamGrp>MAX_SIZE_PS)
		{
			SetComError("功能约束参数组错!");
			return FALSE;
		}
		else ReveiveDvcData(DvcAddrDest,FCParamGrp);
	}
	if(m_nCountMsgAllDvc<MAX_SIZE_MSG) OnPrintMsgFile(FC_DA_MD,FALSE);
	return TRUE;
}

BOOL CMyUnitCanCM::DoWriteData(COMCONTROL* pCC,BYTE DvcAddrDest,BYTE FCParamGrp,BYTE* pData,BYTE VldDL,BYTE Precedence)
{
	m_canMsg.FC[0] = (BYTE)((FC_CAN_F|VldDL)+sizeof(m_canMsg.CS));
	m_canMsg.FC[1] = min(Precedence*4,MAX_SIZE_FC);
	m_canMsg.FC[2] = FC_PS_DO_C;
	m_canMsg.FC[3] = DvcAddrDest;
	m_canMsg.FC[4] = (BYTE)m_address.dwAddressSrc;
	memcpy(&m_canMsg.canData.Data[0],pData,min(sizeof(m_canMsg.canData),VldDL));
	m_canMsg.CS = GetAddSum(&m_canMsg.FC[2],10,VldDL+sizeof(m_canMsg.CS));
	memcpy(pCCTX,&m_canMsg,sizeof(m_canMsg));
	pCCPort->ClearCom();
	pCCPort->WriteCom(pCCTX,sizeof(m_canMsg));
	Sleep(0);
	OnPrintMsgFile(FC_DA_MD,TRUE);
	OnPrintMsgFile(DvcAddrDest,TRUE);
	return TRUE;
}

void CMyUnitCanCM::ReveiveDvcAddrDest(void)
{
	for(register WORD i=0;i<MAX_COUNT_DVC;i++)
	{
		if(m_DvcAddrDest[i]==FC_DA_MD) continue;
		if(m_pDvcAddr[i]) m_pDvcAddr[i]->RefreshData((float)m_DvcAddrDest[i]);
	}
	m_bDvcAddrDestOK = TRUE;
}

void CMyUnitCanCM::ReveiveDvcInfo(void)
{
	for(register WORD i=0;i<MAX_COUNT_DVC;i++)
	{
		if(m_DvcAddrDest[i]==FC_DA_MD) continue;
		if(m_DvcAddrDest[i]==m_canMsg.FC[4])
		{
			if(m_pDvcInfo[i]) m_pDvcInfo[i]->RefreshData((float)m_canMsg.canData.Data[0]);
			m_bDvcRegistered[i] = TRUE;
		}
		else continue;
		if(m_bDvcRegistered[i])
		{
			CString strMessage;
			strMessage.Format("%02X#设备入网申请,信息码为%02X",m_canMsg.FC[4],m_canMsg.canData.Data[0]);
			ReveiveSOESelf("电气设备运行",strMessage);
			m_bDvcRegistered[i] = FALSE;
			break;
		}
	}
}

void CMyUnitCanCM::ReveiveMonitorInfo(void)
{
	BYTE FC_PF = m_canMsg.FC[2];
	BYTE SltAddr = m_canMsg.FC[3];
	BYTE SrcAddr = m_canMsg.FC[4];
	CString strMessage;
	strMessage.Format("%02X#->%02X#执行%02XH控制命令!",SrcAddr,SltAddr,FC_PF);
	ReveiveSOESelf("电气设备运行",strMessage);
	Sleep(0);
}

void CMyUnitCanCM::ReveiveDvcData(BYTE DvcAddrDest,BYTE FCParamGrp)
{
	if(FCParamGrp>=FC_PS_DI && FCParamGrp<=FC_PS_DI+MAX_OFFSET_PS)
		ReveiveDataDI(DvcAddrDest,FCParamGrp);
	else if(FCParamGrp>=FC_PS_AI && FCParamGrp<=FC_PS_AI+MAX_OFFSET_PS)
		ReveiveDataAI(DvcAddrDest,FCParamGrp);
	else if(FCParamGrp>=FC_PS_DO_S1 && FCParamGrp<=FC_PS_DO_S1+MAX_OFFSET_PS)
		ReveiveDataDOS1(DvcAddrDest,FCParamGrp);
	else if(FCParamGrp>=FC_PS_DO_S2 && FCParamGrp<=FC_PS_DO_S2+MAX_OFFSET_PS)
		ReveiveDataDOS2(DvcAddrDest,FCParamGrp);
	else if(FCParamGrp>=FC_PS_DO_S1_SYN && FCParamGrp<=FC_PS_DO_S1_SYN+MAX_OFFSET_PS)
		ReveiveDataDO1SSyn(DvcAddrDest,FCParamGrp);
	else if(FCParamGrp>=FC_PS_EVT_DI && FCParamGrp<FC_PS_EVT_DI+MAX_OFFSET_PS)
		ReveiveSOE(DvcAddrDest,FCParamGrp);
	else if(FCParamGrp>=FC_PS_EVT_DO_S1 && FCParamGrp<FC_PS_EVT_DO_S1+MAX_OFFSET_PS)
		ReveiveSOE(DvcAddrDest,FCParamGrp);
	else if(FCParamGrp>=FC_PS_EVT_DO_S2 && FCParamGrp<FC_PS_EVT_DO_S2+MAX_OFFSET_PS)
		ReveiveSOE(DvcAddrDest,FCParamGrp);
}

void CMyUnitCanCM::ReveiveDataDI(BYTE DvcAddrDest,BYTE FCParamGrp)
{
	register BYTE Status = (BYTE)FALSE;
	register WORD i,j,k;
	j = (FCParamGrp-FC_PS_DI>0)?(WORD)(FCParamGrp-FC_PS_DI):0;
	int nSizeDI = 0;
	if(m_nSizeDI<32) nSizeDI = 32;
	else nSizeDI = m_nSizeDI;
	for(i=0;i<MAX_COUNT_DVC;i++)
	{
		if(m_DvcAddrDest[i]==FC_DA_MD) continue;
		if(!IsDvcAddrValid(DvcAddrDest,m_DvcAddrDest[i])) continue;
		m_pDvcAddr[i]->RefreshData((float)DvcAddrDest);
		if(m_nSizeDI+m_nSizeDO<=SIZEOF_DATA && m_nSizeDI>=8 && m_nSizeDO>=8)
		{
			for(k=0;k<m_nSizeDI;k++)
			{
				if(m_pDI[m_nSizeDI*i+k])
				{
					Status = m_canMsg.canData.Data[k/8]&(BIT_MASK1<<(BYTE)(k-k/8*8));
					m_pDI[m_nSizeDI*i+k]->RefreshData(Status!=0);
				}
			}
			for(k=0;k<m_nSizeDO;k++)
			{
				if((nSizeDI+7)/8+k/8>=CAN_VDL_FIXED) return;
				if(m_pDO1S[m_nSizeDO*i+k])
				{
					Status = m_canMsg.canData.Data[(nSizeDI+7)/8+k/8]&(BIT_MASK1<<(BYTE)(k-k/8*8));
					if(m_bDvcDOS1FlickerCfg[MAX_SIZE_DI*i+k] && m_bClockDO1SFlickerSynRcvOK)
					{
						if(Status==TRUE)
						{
							if(IsFilteringOFF(m_wClockDO1SFlickerSynSlf)) Status = FALSE;
						}
//						else Status = FALSE;
//						{
//							if(IsFilteringON(m_wClockDO1SFlickerSynSlf)) Status = TRUE;
//						}
//						if(IsFilteringOFF(m_wClockDO1SFilterSynSlf)) Status = FALSE;
//						else Status = TRUE;
//						if(m_dwClock100msDO1S>500L)
//						{
							m_pDO1S[m_nSizeDO*i+k]->RefreshData(Status!=0);
							m_dwClock100msDO1S = 0L;
//						}
					}
					else m_pDO1S[m_nSizeDO*i+k]->RefreshData(Status!=0);
				}
			}
			memset(&m_canDataDOS1[(MAX_OFFSET_PS+1)*i+j],0,sizeof(m_canDataDOS1[(MAX_OFFSET_PS+1)*i+j]));
			memcpy(&m_canDataDOS1[(MAX_OFFSET_PS+1)*i+j],&m_canMsg.canData.Data[(nSizeDI+7)/8],(m_nSizeDO+7)/8);
			m_bCanDataDOS1OK[(MAX_OFFSET_PS+1)*i] = TRUE;
		}
		else if(m_nSizeDI>=SIZEOF_DATA)
		{
			for(k=0;k<SIZEOF_DATA;k++)
			{
				if(SIZEOF_DATA*j+k>=MAX_SIZE_DI) return;
				if(m_pDI[m_nSizeDI*i+SIZEOF_DATA*j+k])
				{
					Status = m_canMsg.canData.Data[k/8]&(BIT_MASK1<<(BYTE)(k-k/8*8));
					m_pDI[m_nSizeDI*i+SIZEOF_DATA*j+k]->RefreshData(Status!=0);
				}
			}
		}
		OnPrintMsgFile(DvcAddrDest,FALSE);
		if(IsDvcAddrValid(DvcAddrDest,m_DvcAddrDest[i])) break;
	}
}

void CMyUnitCanCM::ReveiveDataAI(BYTE DvcAddrDest,BYTE FCParamGrp)
{
	register WORD i,j;
	j = (FCParamGrp-FC_PS_AI>0)?(WORD)(FCParamGrp-FC_PS_AI):0;
	if(WSIZEOF_DATA*j+3>=MAX_SIZE_AI) return;
	for(i=0;i<MAX_COUNT_DVC;i++)
	{
		if(m_DvcAddrDest[i]==FC_DA_MD) continue;
		if(!IsDvcAddrValid(DvcAddrDest,m_DvcAddrDest[i])) continue;
		m_pDvcAddr[i]->RefreshData((float)DvcAddrDest);
		if(m_pAI[m_nSizeAI*i+WSIZEOF_DATA*j])
			m_pAI[m_nSizeAI*i+WSIZEOF_DATA*j]->RefreshData(MAKEDATA2(m_canMsg.canData.Data[0],m_canMsg.canData.Data[1])*1.0f);
		if(m_pAI[m_nSizeAI*i+WSIZEOF_DATA*j+1])
			m_pAI[m_nSizeAI*i+WSIZEOF_DATA*j+1]->RefreshData(MAKEDATA2(m_canMsg.canData.Data[2],m_canMsg.canData.Data[3])*1.0f);
		if(m_pAI[m_nSizeAI*i+WSIZEOF_DATA*j+2])
			m_pAI[m_nSizeAI*i+WSIZEOF_DATA*j+2]->RefreshData(MAKEDATA2(m_canMsg.canData.Data[4],m_canMsg.canData.Data[5])*1.0f);
		if(m_pAI[m_nSizeAI*i+WSIZEOF_DATA*j+3])
			m_pAI[m_nSizeAI*i+WSIZEOF_DATA*j+3]->RefreshData(m_canMsg.canData.Data[6]*1.0f);
		OnPrintMsgFile(DvcAddrDest,FALSE);
		if(IsDvcAddrValid(DvcAddrDest,m_DvcAddrDest[i])) break;
	}
}

void CMyUnitCanCM::ReveiveDataDOS1(BYTE DvcAddrDest,BYTE FCParamGrp)
{
	register BYTE Status = (BYTE)FALSE;
	register WORD i,j,k;
	j = (FCParamGrp-FC_PS_DO_S1>0)?(WORD)(FCParamGrp-FC_PS_DO_S1):0;
	for(i=0;i<MAX_COUNT_DVC;i++)
	{
		if(m_DvcAddrDest[i]==FC_DA_MD) continue;
		if(!IsDvcAddrValid(DvcAddrDest,m_DvcAddrDest[i])) continue;
		m_pDvcAddr[i]->RefreshData((float)DvcAddrDest);
		for(k=0;k<SIZEOF_DATA;k++)
		{
			if(SIZEOF_DATA*j+k>=MAX_SIZE_DO) return;
			if(m_pDO1S[m_nSizeDO*i+SIZEOF_DATA*j+k])
			{
				Status = m_canMsg.canData.Data[k/8]&(BIT_MASK1<<(BYTE)(k-k/8*8));
				if(m_bDvcDOS1FlickerCfg[MAX_SIZE_DI*i+k] && m_bClockDO1SFlickerSynRcvOK)
				{
					if(Status==TRUE) {if(IsFilteringON(m_wClockDO1SFlickerSynSlf)) Status = FALSE;}
					else {if(IsFilteringOFF(m_wClockDO1SFlickerSynSlf)) Status = TRUE;}
				}
				m_pDO1S[m_nSizeDO*i+SIZEOF_DATA*j+k]->RefreshData(Status!=0);
			}
			memset(&m_canDataDOS1[(MAX_OFFSET_PS+1)*i+j],0,sizeof(m_canDataDOS1[(MAX_OFFSET_PS+1)*i+j]));
			memcpy(&m_canDataDOS1[(MAX_OFFSET_PS+1)*i+j],&m_canMsg.canData,sizeof(m_canDataDOS1[(MAX_OFFSET_PS+1)*i+j]));
			m_bCanDataDOS1OK[(MAX_OFFSET_PS+1)*i+j] = TRUE;
		}
		OnPrintMsgFile(DvcAddrDest,FALSE);
		if(IsDvcAddrValid(DvcAddrDest,m_DvcAddrDest[i])) break;
	}
}

void CMyUnitCanCM::ReveiveDataDOS2(BYTE DvcAddrDest,BYTE FCParamGrp)
{
	register WORD i,j,k;
	j = (FCParamGrp-FC_PS_DO_S2>0)?(WORD)(FCParamGrp-FC_PS_DO_S2):0;
	for(i=0;i<MAX_COUNT_DVC;i++)
	{
		if(m_DvcAddrDest[i]==FC_DA_MD) continue;
		if(!IsDvcAddrValid(DvcAddrDest,m_DvcAddrDest[i])) continue;
		m_pDvcAddr[i]->RefreshData((float)DvcAddrDest);
		for(k=0;k<SIZEOF_DATA;k++)
		{
			if(SIZEOF_DATA*j+k>=MAX_SIZE_DO) return;
			if(m_pDO2S[m_nSizeDO*i+SIZEOF_DATA*j+k])
				m_pDO2S[m_nSizeDO*i+SIZEOF_DATA*j+k]->RefreshData(m_canMsg.canData.Data[k/8]&(BIT_MASK1<<(BYTE)(k-k/8*8)));
		}
		OnPrintMsgFile(DvcAddrDest,FALSE);
		if(IsDvcAddrValid(DvcAddrDest,m_DvcAddrDest[i])) break;
	}
}

void CMyUnitCanCM::ReveiveDataDO1SSyn(BYTE DvcAddrDest,BYTE FCParamGrp)
{
	if(!IsDvcAddrValid(DvcAddrDest,m_DvcAddrDest[0])) return;
	if(FCParamGrp-FC_PS_DO_S1_SYN>0) return;
	m_wClockDO1SFlickerSynRcv = MAKEDATA2(m_canMsg.canData.Data[0],m_canMsg.canData.Data[1]);
	m_wClockDO1SFlickerSynSlf = m_wClockDO1SFlickerSynRcv;
	m_bClockDO1SFlickerSynRcvOK = (BYTE)TRUE;
}

void CMyUnitCanCM::ReveiveSOESelf(CString strType,CString strMsg)
{
	g_pMngEvent->AddEvent(strType,m_strName,strMsg);
}

void CMyUnitCanCM::ReveiveSOE(BYTE DvcAddrDest,BYTE FCParamGrp)
{
}

void CMyUnitCanCM::OnPrintMsgFile(BYTE DvcAddrDest,BOOL bSendFlag)
{
	CString strFileName;
	if(DvcAddrDest!=FC_DA_MD) strFileName.Format("%02X#设备报文.txt",DvcAddrDest);
	else strFileName = "所有设备报文.txt";
	strFileName = g_strSCADADAT+"\\msg\\"+strFileName;
	CStdioFile file;
	CFileFind findfile;
	if(!findfile.FindFile(strFileName))
	{
		if(!file.Open(strFileName,CFile::modeCreate|CFile::modeWrite)) return;
		CString strMsgHead,strHeadInfo;
		if(DvcAddrDest!=FC_DA_MD) strHeadInfo.Format("%02X#设备报文",DvcAddrDest);
		else strHeadInfo = "所有设备报文";
		strMsgHead.Format("//------------------------------ %s -----------------------------\n",strHeadInfo);
		file.SeekToBegin();
		file.WriteString(strMsgHead);
		file.Close();
		if(DvcAddrDest==FC_DA_MD) m_nCountMsgAllDvc = 0;
		for(register WORD i=0;i<MAX_COUNT_DVC;i++)
		{
			if(DvcAddrDest==FC_DA_MD) break;
			if(IsDvcAddrValid(DvcAddrDest,m_DvcAddrDest[i])) {m_nCountMsg[i] = 0; break;}
		}
	}
	else
	{
		CFileStatus fstatus;
		if(!file.GetStatus(strFileName,fstatus)) return;
	}
	if(file.Open(strFileName,CFile::modeWrite|CFile::shareDenyWrite))
	{
		CString strMsgInfo;
		if(DvcAddrDest==FC_DA_MD)
		{
			if(!bSendFlag) strMsgInfo.Format("%05d->RX: ",m_nCountMsgAllDvc++);
			else strMsgInfo.Format("%05d->TX: ",m_nCountMsgAllDvc++);
		}
		for(register WORD i=0;i<MAX_COUNT_DVC;i++)
		{
			if(DvcAddrDest==FC_DA_MD) break;
			if(IsDvcAddrValid(DvcAddrDest,m_DvcAddrDest[i]))
			{
				if(m_nCountMsg[i]>=MAX_SIZE_MSG) return;
				if(!bSendFlag) strMsgInfo.Format("%05d->RX: ",m_nCountMsg[i]++);
				else strMsgInfo.Format("%05d->TX: ",m_nCountMsg[i]++);
				break;
			}
		}
		CString strByte;
		strByte.Format("%02X ",m_canMsg.FC[0]);
		strMsgInfo += strByte;
		strByte.Format("%02X ",m_canMsg.FC[1]);
		strMsgInfo += strByte;
		strByte.Format("%02X ",m_canMsg.FC[2]);
		strMsgInfo += strByte;
		strByte.Format("%02X ",m_canMsg.FC[3]);
		strMsgInfo += strByte;
		strByte.Format("%02X ",m_canMsg.FC[4]);
		strMsgInfo += strByte;
		for(i=0;i<sizeof(m_canMsg.canData);i++)
		{
			strByte.Format("%02X ",m_canMsg.canData.Data[i]);
			strMsgInfo += strByte;
		}
		strByte.Format("%02X ",m_canMsg.CS);
		strMsgInfo += strByte;
		time_t timeNow;
		WORD wMillSec = 0;
		g_pMngTime->GetTime(timeNow,wMillSec);
		CTime time = timeNow;
		int nYear = time.GetYear();
		int nMonth = time.GetMonth();
		int nDay = time.GetDay();
		int nHour = time.GetHour();
		int nMin = time.GetMinute();
		int nSec = time.GetSecond();
		int nMillSec = (int)wMillSec;
		CString strDateTime;
		strDateTime.Format("<%04d-%02d-%02d %02d:%02d:%02d.%03d> ",nYear,nMonth,nDay,nHour,nMin,nSec,nMillSec);
		strMsgInfo += strDateTime;
		if(!bSendFlag) strMsgInfo += "\n";
		else strMsgInfo += "*\n";
		file.SeekToEnd();
		file.WriteString(strMsgInfo);
		findfile.Close();
		file.Close();
	}
}

void CMyUnitCanCM::Serialize(CArchive& ar)
{
	CMyUnit::Serialize(ar);
	register WORD i;
	if(ar.IsStoring())
	{
		ar << m_nSizeDI << m_nSizeAI << m_nSizeDO;
		for(i=0;i<MAX_COUNT_DVC;i++)
		{
			ar << m_bEnabledDvc[i];
			ar << m_DvcAddrDest[i];
		}
	}
	else
	{
		ar >> m_nSizeDI >> m_nSizeAI >> m_nSizeDO;
		for(i=0;i<MAX_COUNT_DVC;i++)
		{
			ar >> m_bEnabledDvc[i];
			ar >> m_DvcAddrDest[i];
		}
	}
}