ISCS需求及问题

// Modbus_COMS.cpp: implementation of the CModbus_TCPC class.

//

//////////////////////////////////////////////////////////////////////

//#include "stdafx.h"

#include "modbus_tcpc4.h"

#include "se_btl.h"

#include "se_log.h"

//#include <math.h>

#ifdef _DEBUG

#undef THIS_FILE

static char THIS_FILE[]=__FILE__;

#define new DEBUG_NEW

#endif

//////////////////////////////////////////////////////////////////////

// Construction/Destruction

//////////////////////////////////////////////////////////////////////

CModbus_TCPC::~CModbus_TCPC()

{

}

CModbus_TCPC::CModbus_TCPC()

{

}

void CModbus_TCPC::Init(S_PROTOCOLCFG *pcfg)

{

	PRawCtrl	=	pcfg->PRawCtrl;

	pRxBuf		=	pcfg->pRxBuf;

	pTxBuf		=	pcfg->pTxBuf;

	pCmdMem		=	pcfg->pCmdMem;

	pRtu		=	pcfg->pRtu;

	pLink		=	pcfg->pLink;

	pTable		=	pcfg->pTable;

	pZfDataCtrl	=	pcfg->pZfDataCtrl;

//	pHis		=	pcfg->pHis;

	Policy			=0;

	m_xto16 = pLink->GetKwhScanInterval();

	if (m_xto16 > 0){

		if (3 != m_xto16 && 4 != m_xto16)	m_xto16 = 3;

	}

	else m_xto16 = 0;

	PrintLog(1, "m_xto16 = %d!", m_xto16);

	m_func34 = m_xto16;

	m_func12 = 1;

	WillSendType = m_func12;

	if (m_xto16)	WillSendType = m_func34;

	cnt_sequence	=0;

	m_RcvTimeOuts=pLink->GetRxTimeouts();

	if(m_RcvTimeOuts<=0)	m_RcvTimeOuts=10;

	sint32 rtuno	= pLink->GetRtuNo();

//	m_SyncTime = pRtu->GetSyncTimeInt(rtuno)*60;

//	if(m_SyncTime<=0)m_SyncTime=60;

	m_LastSynctime = 0;

	m_LastSendTime = 0;

	addrDI	= 0;

	addrAI	= 0;

	addrDI = pRtu->GetSyncTimeInt(rtuno);//????RTU??ʱ??ͬ??????

	addrAI = pRtu->GetKwhNum(rtuno);//????RTU??ACC?????

	scopeDI = pRtu->GetYxNum(rtuno);

	scopeAI = pRtu->GetYcNum(rtuno);

	IndexDI = 0;

	IndexAI = 0;

	numDI	= 0;

	numAI	= 0;

	if (m_xto16)scopeDI = 0;

}

void CModbus_TCPC::GetWillSendType()

{

	if (m_xto16){

		Policy=1;

		WillSendType = m_xto16; return;

	}

	if(Policy == 0) //Initial Step

	{

		if (WillSendType == m_func12)

		{

			if(IndexDI >= scopeDI)

			{

				WillSendType = m_func34;

				IndexDI = 0;

			}

			return;

		}

		else if (WillSendType == m_func34)

		{

			if(IndexAI >= scopeAI)

			{

				WillSendType = m_func12;

				IndexAI = 0;

				Policy = 1;

			}

			return;

		}

		return;

	}

	if (WillSendType == m_func12)

		WillSendType = m_func34;

	else

		WillSendType = m_func12;

}

//???ɶ?д???????Ĵ???????Ȧ״̬??

//[?豸??ַ] [?????01] [??ʼ?Ĵ?????ַ??8λ] [??8λ] [??ȡ?ļĴ???????8λ] [??8λ] [CRCУ??ĵ?8λ] [CRCУ??ĸ?8λ]

//??ֻ?ɶ????????Ĵ?????????״̬??

//[?豸??ַ] [?????02] [??ʼ?Ĵ?????ַ??8λ] [??8λ] [??ȡ?ļĴ???????8λ] [??8λ] [CRCУ??ĵ?8λ] [CRCУ??ĸ?8λ]

//д??????????Ȧ״̬??

//[?豸??ַ] [?????05] [?????õļĴ?????ַ??8λ] [??8λ] [???õ????ݸ?8λ] [??8λ] [CRCУ??ĵ?8λ] [CRCУ??ĸ?8λ]

//???ɶ?дģ?????Ĵ????????ּĴ?????

//[?豸??ַ] [?????03] [??ʼ?Ĵ?????ַ??8λ] [??8λ] [??ȡ?ļĴ???????8λ] [??8λ] [CRCУ??ĵ?8λ] [CRCУ??ĸ?8λ]

//??ֻ?ɶ?ģ?????Ĵ?????????Ĵ?????

//[?豸??ַ] [?????04] [??ʼ?Ĵ?????ַ??8λ] [??8λ] [??ȡ?ļĴ???????8λ] [??8λ] [CRCУ??ĵ?8λ] [CRCУ??ĸ?8λ]

//д????ģ?????Ĵ????????ּĴ?????

//[?豸??ַ] [?????06] [?????õļĴ?????ַ??8λ] [??8λ] [???õ????ݸ?8λ] [??8λ] [CRCУ??ĵ?8λ] [CRCУ??ĸ?8λ]

sint32 CModbus_TCPC::RxProc()

{

	sint32 rtuno	= pLink->GetRtuNo();

	uint8 buf[1024];

	int datalen = 0 ,datanum =0;

	int i,j;

	sint32 buflen=pRxBuf->GetReadableSize();

	int nowtime=GetNowSecond();

	E_RAW_ComStat commstatus = pLink->GetCommStatus();

	if ( commstatus==CMST_RX_CNT && (nowtime-m_LastSendTime) >= m_RcvTimeOuts)

	{

		//??ʱ???ط???ֱ????????һ???ն?

		pRxBuf->Move(buflen);

		pLink->RegisterFrm(FRAME_RX_TIMEOUT);

		pLink->SetCommStatus(CMST_TX_CNT);

		PrintLog(LOG_VIOLATION,	"RTUNO = %d ???ݳ?ʱ%d!",rtuno,m_RcvTimeOuts);

		return -1;

	}

	if (buflen<7)		//?????ݻ????ݲ??????ı???·ͨѶ״̬???????ȴ?

		return -1;

	datalen = pRxBuf->Read(buf,7,DEF_BUFF_NOMOVE);

/*	int ret = CheckFrameHeader(buf,7);

	if(ret<0)

	{

		pRxBuf->Move(buflen);

		pLink->RegisterFrm(FRAME_RX_MISSTEP);

		PrintLog(LOG_VIOLATION,"ModbusHead??һ??\n");

		return -1;

	}

	else if( ret == 0)

		return 0;

*/

	uint16 d_len=buf[4]*256 + buf[5] + 6;

	if(buflen<d_len)

		return -1;

	datalen = pRxBuf->Read(buf,d_len,DEF_BUFF_MOVE);

//	PrintLog(LOG_INFORMATION,"<<<<< ReceiveType=%d, numbyte=%d",buf[7],buf[8]);

	if(buf[7] & 0x80)

		return ErrorHandle(buf[7]);

	uint16 YxYcId=0;

	switch(buf[7])

	{

		case 1:

		case 2:

			//if (WillSendType == m_func12)

			{

				//????ң??

				for(i=0;i<buf[8];i++)

				{

					uint8 value=buf[9+i];

					for(j=0;j<8;j++)

					{

						YxYcId=8*i+j+IndexDI;

						if(YxYcId >= (IndexDI + numDI))

							break;

						PRawCtrl->PutAYx(rtuno,YxYcId+1,value&1);//YX NO  +1

						value>>=1;

					}

				}

				//PrintLog(LOG_INFORMATION, "---- Receive RTU%d Yx data ",rtuno);

				if(buf[8]*8 < numDI)

					IndexDI += buf[8]*8;

				else

					IndexDI += numDI;

				pLink->RegisterFrm(FRAME_RX_SUC);

				pLink->SetCommStatus(CMST_NORMAL);

				return 1;

			}

			break;

		case 3:

		case 4:

			//????ң??

			//if (WillSendType == m_func34)

			{

				for(i=0;i<buf[8]/2;i++)

				{

					YxYcId=i+IndexAI;

					if(YxYcId >= (IndexAI + numAI))

						break;

					sint32 yc_value=256*buf[9+2*i]+buf[9+2*i+1];

					PRawCtrl->PutAYc(rtuno,YxYcId+1,yc_value);		//YC NO +1

				}

				//PrintLog(LOG_INFORMATION, ">>>> Receive RTU%d Yc data Func=%d", rtuno, m_func34);

				pLink->RegisterFrm(FRAME_RX_SUC);

				pLink->SetCommStatus(CMST_NORMAL);

				if (m_xto16){

					//????ң??

					for (i = 0; i < buf[8] / 2; i++)

					{

						YxYcId = i + IndexAI;

						if (YxYcId >= (IndexAI + numAI))

							break;

						uint8 value1 = buf[9 + 2 * i + 1];

						uint8 value2 = buf[9 + 2 * i];

						for (j = 0; j < 8; j++)

						{

							YxYcId = 16 * i + j + IndexDI;

							PRawCtrl->PutAYx(rtuno, YxYcId + 1, value1 & 1);//YX NO  +1

							value1 >>= 1;

							YxYcId = 16 * i + 8 + j + IndexDI;

							PRawCtrl->PutAYx(rtuno, YxYcId + 1, value2 & 1);//YX NO  +1

							value2 >>= 1;

						}

					}

				}

				if(buf[8]/2 < numAI)

					IndexAI += buf[8]/2;

				else

					IndexAI += numAI;

				if (m_xto16){

					if (buf[8] / 2 < numAI)

						IndexDI += buf[8] * 8;

					else

						IndexDI += numDI;

				}

				return 1;

			}

			break;

		case 5:

			//ң?ط???

			if(WillSendType == 5)

			{

				pLink->RegisterFrm(FRAME_RX_SUC);

				pLink->SetCommStatus(CMST_NORMAL);

				return 1;

			}

			break;

		case 6:

			//ң??????

			if(WillSendType == 6)

			{

				pLink->RegisterFrm(FRAME_RX_SUC);

				pLink->SetCommStatus(CMST_NORMAL);

				return 1;

			}

			break;

		case 16:

			WillSendType = m_func34;

			{

				pLink->RegisterFrm(FRAME_RX_SUC);

				pLink->SetCommStatus(CMST_NORMAL);

				return 1;

			}

			break;

		default:

			return 0;

			break;	

	}

//	pLink->RegisterFrm(FRAME_RX_SUC);

//	pLink->SetCommStatus(CMST_NORMAL);

	return 1;

}

sint32	CModbus_TCPC::CheckFrameHeader(uint8* buff,sint32 len)

{

	if(len<7)

		return 0;

	if(buff[0] != cnt_sequence/256 || buff[1] != cnt_sequence%256)

		return -1;

	sint32 rtuno	= pLink->GetRtuNo();

	uint8 rtuaddr=pRtu->GetRtuAddr(rtuno);

	if(buff[2]!=0 || buff[3]!=0 || buff[6]!= rtuaddr)

		return -2;

	return 1;

}

uint8	CModbus_TCPC::ErrorHandle(uint8 errfunc)

{

	uint8  retFunc = errfunc & 0x7f;

	if(retFunc != WillSendType)	//???????

		return 0;

	if (WillSendType == m_func12)

	{	

		IndexDI = 0;

		numDI = 0;

	}

	else if (WillSendType == m_func34)

	{

		IndexAI = 0;

		numAI = 0;

		IndexDI = 0;

		numDI = 0;

	}

	pLink->RegisterFrm(FRAME_RX_SUC);

	pLink->SetCommStatus(CMST_NORMAL);

	return 1;

}

uint8 CModbus_TCPC::OperateRegister(uint8 FuncNo, uint16 Address, uint16 Value)

{

	uint8 txbuff[256];

	sint32 rtuno=pLink->GetRtuNo();

	uint8 rtuadd=pRtu->GetRtuAddr(rtuno);

	uint8 len=0;

	if(cnt_sequence>=65535)

		cnt_sequence=0;

	else

		cnt_sequence++;

	//7bytes Head

	txbuff[len++]=cnt_sequence/0x100;//H Transaction Identifier

	txbuff[len++]=cnt_sequence%0x100;//L

	txbuff[len++]=0;//Protocol Identifier "0 = MODBUS protocol"

	txbuff[len++]=0;

	txbuff[len++]=0;//len_H

	txbuff[len++]=6;//len_L

	txbuff[len++]=rtuadd;//Unit Identifier

	txbuff[len++]=FuncNo;

	txbuff[len++]=Address/0x100;//??

	txbuff[len++]=Address%0x100;//??

	txbuff[len++]=Value/0x100;//??

	txbuff[len++]=Value%0x100;//??

//	pLink->RegisterFrmCode(RAW_CODEDIR_DOWN,(char *)txbuff,len);

	pLink->RegisterFrm(FRAME_TX_SUC);

	pTxBuf->Write(txbuff,len);

	pLink->SetCommStatus(CMST_RX_CNT);

	m_LastSendTime = GetNowSecond();

	//PrintLog(LOG_INFORMATION,">>>>>>RTU%d SendType = %d ,start=%d ,num=%d",rtuno,WillSendType,Address,Value);

	return len;

}

uint8	CModbus_TCPC::Operate_16(uint16 Address, uint16 num,uint16* pValue)

{

	if(num>125 || pValue==NULL)

	{

		PrintLog(LOG_ERROR,">>>>>> Wrong Func_16 parameter");

		return 0;

	}

	uint8 txbuff[256];

	sint32 rtuno=pLink->GetRtuNo();

	uint8 rtuadd=pRtu->GetRtuAddr(rtuno);

	uint8 len=0;

	if(cnt_sequence>=65535)

		cnt_sequence=0;

	else

		cnt_sequence++;

	//7bytes Head

	txbuff[len++]=cnt_sequence/0x100;//H Transaction Identifier

	txbuff[len++]=cnt_sequence%0x100;//L

	txbuff[len++]=0;//Protocol Identifier "0 = MODBUS protocol"

	txbuff[len++]=0;

	txbuff[len++]=0;//len_H

	txbuff[len++]=num*2+7;//len_L

	txbuff[len++]=rtuadd;//Unit Identifier

	txbuff[len++]=0x10;

	txbuff[len++]=Address/0x100;//??

	txbuff[len++]=Address%0x100;//??

	txbuff[len++]=num/0x100;

	txbuff[len++]=num%0x100;

	txbuff[len++]=num*2;

	uint8 i=0;

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

	{

		txbuff[len++]=pValue[i]/0x100;//??

		txbuff[len++]=pValue[i]%0x100;//??

	}

//	pLink->RegisterFrmCode(RAW_CODEDIR_DOWN,(char *)txbuff,len);

	pLink->RegisterFrm(FRAME_TX_SUC);

	pTxBuf->Write(txbuff,len);

	pLink->SetCommStatus(CMST_RX_CNT);

	m_LastSendTime = GetNowSecond();

	//PrintLog(LOG_INFORMATION,">>>>>>RTU%d SendType = 16 ,start=%d ,num=%d",rtuno,Address,num);

	return len;

}

sint32 CModbus_TCPC::TxProc()

{

	E_RAW_ComStat commstatus = pLink->GetCommStatus();

	if( commstatus !=CMST_TX_CNT && commstatus !=CMST_NORMAL)

		return 0;

	if(pRxBuf->GetReadableSize()>0)

	{

		PrintLog(LOG_ERROR, "------- ???? ????????!\n");

		pRxBuf->Move(pRxBuf->GetReadableSize());

	}

	if(Policy && ProcCmd())

	{

		pLink->SetCommStatus(CMST_RX_CNT);

		return 1; //?????ⲿ?·?????

	}

/*	sint32 nowtime = GetNowSecond();

	if(m_SyncTime>0 && ((nowtime - m_LastSynctime) > m_SyncTime))

	{

		m_LastSynctime = nowtime;

		return SendSyncTime(nowtime);

	}

*/

//<xyanglee>temp

//	if(( nowtime - m_LastSendTime)<1)

//		return 0;

	uint8 len=0;

	GetWillSendType();

	sint32 rtuno	= pLink->GetRtuNo();

	switch(WillSendType)

	{

	case 1://read DIO R/W

	case 2:

		if(scopeDI<1) break;

		if(IndexDI >= scopeDI)

			IndexDI = 0;

		if((scopeDI - IndexDI)>MAX_BYTE_NUM*8)

			numDI = MAX_BYTE_NUM*8;

		else

			numDI = scopeDI - IndexDI;

		if(numDI>0)

			len = OperateRegister(WillSendType,IndexDI+addrDI,numDI);	

		break;

	case 3://read AIO R/W

	case 4:

		if(scopeAI<1) break;

		if(IndexAI>=scopeAI)

		{IndexAI = 0;

		if(m_xto16)IndexDI = 0;}

		if((scopeAI - IndexAI)>MAX_BYTE_NUM/2)

			numAI = MAX_BYTE_NUM/2;

		else

			numAI = scopeAI - IndexAI;

		if (m_xto16)numDI = numAI * 16;

		if(numAI>0)

			len = OperateRegister(WillSendType,IndexAI+addrAI,numAI);	

		break;

	default:

		break;

	}

	if(len>0)

		pLink->SetCommStatus(CMST_RX_CNT);

	return len;

}

uint8	CModbus_TCPC::SendSyncTime(sint32 nowtime)

{

	uint16 buff[256];

	SSE_CLOCK seclock;

	CSeTime SeTime;

	SeTime.CovertTime(nowtime,&seclock);

	/*

	buff[0] = 0xFF00;

	buff[1] = seclock.year;

	buff[2] = seclock.month;

	buff[3] = seclock.day;

	buff[4] = seclock.hour;

	buff[5] = seclock.minute;

	buff[6] = seclock.second;

	*/

	buff[0] = seclock.year/1000 * 0x1000 + seclock.year/100%10 *0x100+seclock.year/10%10 * 0x10 + seclock.year%10  ;

	buff[1] = seclock.month/10%10 *0x1000 +seclock.month%10*0x100+seclock.day/10%10 *0x10 +seclock.day%10;

	buff[2] = seclock.hour/10%10 *0x1000 +seclock.hour%10*0x100+seclock.minute/10%10 *0x10 +seclock.minute%10;

	buff[3] = seclock.second/10%10 *0x10 +seclock.second%10;

	//40080

	Operate_16(79,4,buff);

	WillSendType=16;

	return 1;

}

BOOL CModbus_TCPC::ProcCmd()

{

	BOOL b_ret=FALSE;

	sint32 rtuno	= pLink->GetRtuNo();

	uint8 rtuaddr	= pRtu->GetRtuAddr(rtuno);

	if(pCmdMem->GetCmdNum(rtuno)<=0)

		return FALSE;	

	S_RAWCMD rawcmd;

	if(pCmdMem->GetACmd(rtuno,&rawcmd)==0)

		return FALSE;	

	PrintLog(LOG_INFORMATION,"?յ?RTU%d???ն? rtuaddr:%d ????:%d\n",rtuno,rtuaddr,rawcmd.type);

	uint8 len=0;

	m_cmdaddr =rawcmd.src;

	switch(rawcmd.type)

	{

	case DC_K_CMD_DOOPER: //ң??

		{

			S_DO_CTL *cmdinfo;

			cmdinfo=(S_DO_CTL *)(&rawcmd.data);

			uint16 ykno = (uint16)cmdinfo->ptAddr;//ң?غ?

			switch(cmdinfo->funcCode)

			{

				case DC_K_CTL_DOSEL://ѡ??

					//ֱ?ӷ?У

					rawcmd.type=DC_K_CMDRET_DOOPER;

					rawcmd.len=sizeof(cmdinfo);

					rawcmd.src = m_cmdaddr;

					cmdinfo->retCode=1;

					pCmdMem->RptAResult(rtuno,rawcmd);

					break;

				case DC_K_CTL_DOEXE://ִ??

					{

						uint16 AoNo=(ykno+15)/16;

						uint16 bit=(ykno-1)%16;

						float32 yctmp=0;

						uint16	ytVal=1<<bit;

						PRawCtrl->GetAYc(rtuno,AoNo,&yctmp);

						uint16	ycVal=(uint16)yctmp;

						uint16 ykvalue;

						if(cmdinfo->ctlVal==0){//??բ

							ykvalue = 0x0000;

							ycVal = ycVal & (~ytVal);

						}

						if(cmdinfo->ctlVal==1){//??բ

							ykvalue = 0xff00;

							ycVal = ycVal | (ytVal);

						}

						if(ykno>=1 )

						{

							WillSendType = 5;

							len=OperateRegister(5,ykno-1+addrDI-1,ykvalue);

							b_ret=TRUE;

						}

/*						if(ykno>=1 )

						{

							WillSendType = 6;

							len=OperateRegister(6,AoNo-1+addrAI,ycVal);

							b_ret=TRUE;

						}

*/						//<xyanglee>

						PrintLog(LOG_WARNING,"<<<<<RTU%d YK no=%d   val=%d\n",rtuno,ykno,cmdinfo->ctlVal);

					}

					break;

				case DC_K_CTL_DODEL://????

					break;

			}

		}

		break;

	case DC_K_CMD_AOOPER:

		{

			S_AO_CTL * aoinfo;

			aoinfo = (S_AO_CTL*)(&rawcmd.data);

			switch(aoinfo->funcCode)

			{

			case DC_K_CTL_AOSEL://ѡ??

				//ֱ?ӷ?У

				rawcmd.type=DC_K_CMDRET_AOOPER;

				rawcmd.len=sizeof(aoinfo);

				rawcmd.src = m_cmdaddr;

				aoinfo->retCode=1;

				pCmdMem->RptAResult(rtuno,rawcmd);

				break;

			case DC_K_CTL_AOEXE://ִ??

				{

					sint32 ytvalue=(sint32)(aoinfo->ptVal);

					uint16 ptno = aoinfo->ptAddr;

					if(ptno>=1)

					{

						WillSendType = 6;

						len=OperateRegister(6,ptno-1+addrAI,ytvalue);

						b_ret=TRUE;

					}

					//<xyanglee>

					PrintLog(LOG_WARNING,"<<<<<<RTU%d YT no=%d   val=%d\n",rtuno,ptno,ytvalue);

				}

				break;

			case DC_K_CTL_AODEL://????

				break;

			default:

				break;

			}

		}

		break;

	default: //?????????·????????		

		break;

	}

	pCmdMem->DelACmd(rtuno);

	return b_ret;

}

sint32 CModbus_TCPC::GetNowSecond()

{

	CSeTime     SE_T;

	TCriterionTime tmptime;//sint32

	SE_T.GetNow(&tmptime);

	return (sint32)tmptime;

}

void	CModbus_TCPC::SetExtendedPara(uint16 no, sint32 val)

{

	if(no == 0){//3to16or4to16

		if (val){

			m_xto16 = val;

			if (3 != val && 4!=val) m_xto16 = 3; 

		}

		else m_xto16 = 0; 

	}

	if(no == 1){//func1,2

		if (1 == val || 2 == val)

			m_func12 = val;

		else m_func12 = 1;

	}

	if(no == 2){//func3,4

		if (3 == val || 4 == val)

			m_func34 = val;

		else m_func34 = 3;

	}

	if(no == 3)//DIO-fromAdd

		addrDI = val;	

	if(no == 4)//AIO-fromAdd

		addrAI = val;

	if (m_xto16)WillSendType = m_func34;

	else{ 

		WillSendType = m_func12; 

		sint32 rtuno = pLink->GetRtuNo();

		scopeDI = pRtu->GetYxNum(rtuno);

	}

	PrintLog(LOG_WARNING, "SetExtendedPara no=%d   val=%d \n", no, val);

}

//??Լ???󴴽?????

#ifdef __unix

extern "C" CProtocol* CreateProtocol(char *defpara)

#else

extern "C" __declspec(dllexport)  CProtocol* CreateProtocol(char *defpara)

#endif

{

	CProtocol *pEpv = new CModbus_TCPC;

	return pEpv;

}