slavesimens.c

本人设计的DL/T645规约电能表的抄表和电表模拟软件

	{ 0xb613, tf6+14, 2},                              
	{ 0xb61f, tf6+10, 6}, ///175                             
	                                           
	{ 0xb621, tf6+16, 2},                              
	{ 0xb622, tf6+18, 2},                              
	{ 0xb623, tf6+20, 2},                              
	{ 0xb62f, tf6+16, 6}, 
		                                      
	{ 0xb650, tf6+22, 2}, ////180,                              
	{ 0xb651, tf6+24, 2},                              
	{ 0xb652, tf6+26, 2},                              
	{ 0xb653, tf6+28, 2},
	{ 0xb65f, tf6+22, 8},
                        
	{ 0xb660, tf6+30, 2},                              
	{ 0xb661, tf6+32, 2},                              
	{ 0xb662, tf6+34, 2},
	{ 0xb663, tf6+36, 2},

	{ 0xb664, tf6+38, 2},                              
	{ 0xb665, tf6+40, 2},   // 190                           
	{ 0xb66f, tf6+30, 12},
	
	{ 0xc010, tf6+42, 4	},                             
	{ 0xc011, tf6+46, 3	}  ///194
                                                       
};

#define SIEMENS_ID_TABLE_SIZE  (sizeof(SiemensIdTable)/sizeof(SiemensTableType))
	
INT32U gSiemensBaud = 300;
int fd;

int  InitSimensCom(INT8U uart,int nSpeed,int nDataBits,char Parity,int nStopBit)
{
		fd = 	OpenCom(uart);
		if(fd > 0)
		{
				SetComOpt(fd,nSpeed,nDataBits,Parity,nStopBit);
				return  fd;
		}
		else
		{
			printf("Open Com Error\n");
			return E_COM_OTHER;
		}
}


int  ReceiveSiemensFrame(int fd, INT8U *pbuf, INT16U bufsize)
{
	int nGetBytes;
	INT32U timeout;
	
	INT16U nPosition = 0;
	INT16U size = 50;
	timeout = 500;
	int itimes = 0;

	while(1)
	{
		nGetBytes = SlaveRecvFrame(fd,&pbuf[nPosition],bufsize,&size,timeout);
		printf("Simens:nGetBytes is %d\n",nGetBytes);
		
		if(nGetBytes>0)
		{
			nPosition += nGetBytes;
			itimes = 0;
		}
		else
		{
			if(itimes>=2 || nPosition >0)
			{
			  break;
			}
			usleep(10);
			itimes++;
		}
	}	
	//mPrintStr(gSiemensMeterBuff,20);
	//	mPrintfHex("%s:ntotoal recv is %d\n",dinfo,nPosition);
		return nPosition;	

}
#define SIEMENS_ID_BYTE_TIMEOUT        3
int RcvIdentifyFrame(int fd, INT8U *pbuf, INT16U bufsize)
{
		int nGetBytes = 0;
		int nRecvLen = 23;
		int ntimes =0;
		INT16U psize;
		INT8U tempBuf[512];

		while(1)
		{
			//nGetBytes = ICRecvBytes(cType,cp1107Hd,(BYTE*)&gMeterTmpBuf,Siemens_FIRST_REVLENGTH,Siemens_SLAVE_WAIT_OUT);
			 SlaveRecvFrame(fd,tempBuf,nRecvLen,&psize,120);
			printf("IEC Get %d\n",psize);
			if(psize <= 0)
			{
				if(ntimes>=3)
				{
					return E_COM_RECV;
				}
				usleep(10);
				ntimes++;
			}
			else
			 break;
		}	
	nGetBytes = psize;
	//MaskBit7(tempBuf, nGetBytes);
	if(nGetBytes>0&&tempBuf[0]== '/'&&
	   tempBuf[nGetBytes-2]==CR&&tempBuf[nGetBytes-1]==LF)
	{
		return nGetBytes;
	}
	return nGetBytes;
}
void GetSiemensMeterInfo(INT8U *pBuff, int len, SiemensMeterInfoType *pSiemensMeterInfo)
{
	IdentifyFrameType *pIdFrame;
	int length;

	pIdFrame=(IdentifyFrameType *) pBuff;
	memcpy((INT8U *)(pSiemensMeterInfo->factoryId), (INT8U *)(pIdFrame->factory), 3);
	pSiemensMeterInfo->factoryId[3]='\0';
	pSiemensMeterInfo->baudrate=pIdFrame->baudRate;
	length=len-sizeof(IdentifyFrameType)-2+1;
	memcpy((INT8U *)(pSiemensMeterInfo->model), (INT8U *)(pIdFrame->Id), length);
	pSiemensMeterInfo->model[length]='\0';
}	

void AckBoudRate(INT8U port, INT8U BoudRate, INT8U mode)
{
	AckFrameType ackFrame;
	
	ackFrame.Ack=ACK;
	ackFrame.V='0';
	ackFrame.Z=BoudRate;
	ackFrame.Y=mode;
	ackFrame.cr=CR;
	ackFrame.lf=LF;
//	memcpy(gMeterSendBuf, (INT8U *)&ackFrame, sizeof(AckFrameType));
	//SlaveDirectSendFrame(port, (INT8U *)&ackFrame, sizeof(AckFrameType));
}

int  SiemensDataReadFrame(INT8U port, INT8U *pDataBuff, INT16U bufsize)
{
	int size;
//	INT8U  buff[4]={'!', CR, LF, ETX};
	
	if((size = ReceiveSiemensFrame(port, pDataBuff, bufsize)) > 0)
	{
//		if(memcmp(pDataBuff+size-4-1, buff, 4)==0 || memcmp(pDataBuff+size-3, buff, 3) == 0)
//		{
			return size;
//		}
//		else
//		{
//			return 0;
//		}
	}
	else 
	{
		return 0;
	}
}
/*
INT8U Check(INT8U *pBuff, int len)
{
	int i;
	int offset;
	INT8U check=0;
	
	for(i=0; i<len; i++)
	{
		check^=*(pBuff+i);
	}
	return check;
}

*/
void SendSiemensReqFrame(int fd, INT8U *pAddr, int AddrLen)
{
	
	memcpy(gMeterSendBuf, "/?", 2);
	memcpy(gMeterSendBuf+2, pAddr, AddrLen);

	memcpy(gMeterSendBuf+2+AddrLen, "!\r\n", 3);
	SlaveSendFrame(fd,gMeterSendBuf,AddrLen+5,5);
}


INT16U  SiemensReadMeter( INT8U *pMeterAddr, int MeterAddrLen, SiemensMeterInfoType *pSiemensMeterInfo, INT8U *pbuf, INT16U bufsize,INT8U  *ll)
{     
	int i;
	int len;
	INT16U length=0;
	INT8U buff[100];
	INT8U port = SLAVE_PORT_1;
	for(i=0;i<3; i++)
	{
		SendSiemensReqFrame(fd, pMeterAddr, MeterAddrLen);
		gSiemensBaud = 300;
		if((len = RcvIdentifyFrame(fd,  buff, 100))>0)
		{
			
			GetSiemensMeterInfo(buff, len, pSiemensMeterInfo);
#if SLAVE_DEBUG_EN > 0	  
				printf("pSiemensMeterInfo \n");
				mPrintfHex((INT8U *)pSiemensMeterInfo,sizeof(SiemensMeterInfoType));
//				pbuf[length] = 0;
//				printf("%s", pbuf);
#endif 
              *ll=pSiemensMeterInfo->baudrate;
			switch(pSiemensMeterInfo->baudrate)
			{
				case SIEMENS_MODEC_BAUD_RATE_600:
					gSiemensBaud = 600;
					break;
				case SIEMENS_MODEC_BAUD_RATE_1200:
					gSiemensBaud = 1200;
					break;
				case SIEMENS_MODEC_BAUD_RATE_2400:
					gSiemensBaud = 2400;
					break;
				case SIEMENS_MODEC_BAUD_RATE_4800:
					gSiemensBaud = 4800;
					break;
				case SIEMENS_MODEC_BAUD_RATE_9600:
					gSiemensBaud = 9600;
					break;
				default:
					gSiemensBaud =300;
			}
			if(i < 2)
			{
				AckBoudRate(port, pSiemensMeterInfo->baudrate, '0');

			}

			if((length = SiemensDataReadFrame(port, pbuf, bufsize)) > 0)
			{
#if SLAVE_DEBUG_EN > 0	  
			//	printf("SiemensDataReadFrame %d \n", length);
//				pbuf[length] = 0;
//				printf("%s", pbuf);
#endif		
				if(IsSiemensDataValid((INT8U *)&(pSiemensMeterInfo->model[0]), pbuf, length) == TRUE)
				{
#if SLAVE_DEBUG_EN > 0	  
					printf("SiemensDataValid\n");
#endif				
					break;
				}
				else
				{
#if SLAVE_DEBUG_EN > 0	  
					printf("SiemensDataValid ERROR\n");
#endif				

				}
			}
			else
			{

			}
			gSiemensBaud = 300;
		}
		else
		{
			gSiemensBaud = 300;
		}
	}
	
	gSiemensBaud = 300;
	return length;
}



void DealWithMaxRqu(INT8U *ptr, INT8U *pMaxRqu,INT8U *pMaxRquTime)
{
/*	INT8U buff[10];
	INT8U *p;
	
	buff[0]='0';
	buff[1]=*ptr;
	memcpy(buff+2, ptr+2, 3);
	buff[5]='0';
	if(IsDigitalASCII(buff,6)==0){
		pMaxRqu[0]=0xff;
	}
	else
		ASCIIToBCD(buff, 6, pMaxRqu);
	p = (INT8U *)strchr((char *)ptr, '(');
	if(p!=NULL)
	{
		pMaxRquTime[0]=((*(p+13)-'0')<<4)|(*(p+14)-'0');
		pMaxRquTime[1]=((*(p+10)-'0')<<4)|(*(p+11)-'0');
		pMaxRquTime[2]=((*(p+7)-'0')<<4)|(*(p+8)-'0');
		pMaxRquTime[3]=((*(p+4)-'0')<<4)|(*(p+5)-'0');
	}
	else
	{
		memset(pMaxRqu, 0xff, 3);
		memset(pMaxRquTime, 0xff, 4);
	}
	*/
	INT8U buff[10];
	INT8U *p;

	if(*(ptr + 1) == '.')
	{
		buff[0]='0';
		buff[1]=*ptr;
		memcpy(buff+2, ptr+2, 3);
		buff[5]='0';
	}
	else
	{
		memcpy(buff, ptr, 2);
		memcpy(buff+2, ptr+3, 2);
		buff[4]='0';buff[5]='0';
	}
	mASCIIToBCD(buff, 6, pMaxRqu);
	p = (INT8U *)strchr((char *)ptr, '(');
	if(p!=NULL)
	{
		pMaxRquTime[0]=((*(p+13)-'0')<<4)|(*(p+14)-'0');
		pMaxRquTime[1]=((*(p+10)-'0')<<4)|(*(p+11)-'0');
		pMaxRquTime[2]=((*(p+7)-'0')<<4)|(*(p+8)-'0');
		pMaxRquTime[3]=((*(p+4)-'0')<<4)|(*(p+5)-'0');
	}
	else
	{
		memset(pMaxRqu, 0xff, 3);
		memset(pMaxRquTime, 0xff, 4);
	}
	
}

BOOL IsSiemensEnergyDataValid(INT8U *pRcvData, INT8U *pCharacterStr)
{

	INT8U *ptr;

	ptr = (INT8U *)strstr((char *)pRcvData, (char *)pCharacterStr);
	if(ptr!= NULL)
	{
		return TRUE;
	}
	else
	{
		return FALSE;
	}
}

void GetZMDEnergy(INT8U *pRcvData, INT8U *pCharacterStr, INT8U *pResult)
{

	INT8U *ptr;
	INT8U buff[20];
	int SearchStrLen;
	INT8U a;

	ptr = (INT8U *)strstr((char *)pRcvData, (char *)pCharacterStr);
	SearchStrLen = strlen((char *)pCharacterStr);
	if(ptr!= NULL)
	{
		ptr+=SearchStrLen;
		a = *(ptr-1);
		if( a != '(')
		{
			ptr = (INT8U *)strchr((char *)ptr, '(');
			if(ptr== NULL)
			{
				memcpy(pResult, 0, 4);
				return;
			}
			ptr++;
		}
		memcpy(buff, ptr, 6);
		memcpy(buff+6, ptr+7, 2);		
	//	ASCIIToBCD(buff, 8, pResult);
	}
	else
	{
		memset(pResult, 0xff, 4);
	}
}

void GetZFBEnergy(INT8U *pRcvData, INT8U *pCharacterStr, INT8U *pResult)
{

	INT8U *ptr;
	INT8U buff[20];
	int SearchStrLen;
	INT8U a;

	ptr = (INT8U *)strstr((char *)pRcvData, (char *)pCharacterStr);
	SearchStrLen=strlen((char *)pCharacterStr);
	if(ptr!= NULL)
	{
		ptr+=SearchStrLen;
		
		a = *(ptr-1);
		if( a != '(')
		{
			ptr = (INT8U *)strchr((char *)ptr, '(');
			if(ptr== NULL)
			{
				memcpy(pResult, 0, 4);
				return;
			}
			ptr++;
		}
		
		buff[0]='0';
		memcpy(buff+1, ptr, 5);
		memcpy(buff+6, ptr+6, 2);	
		mASCIIToBCD(buff, 8, pResult);
	}
	else
		memset(pResult, 0xff, 4);
}

void GetMaxRqu(INT8U *pRcvData, INT8U *pCharacterStr, INT8U *pMaxRqu, INT8U *pMaxRquTime)
{
	INT8U *ptr;
	int SearchStrLen;
	INT8U a;
	
	ptr = (INT8U *)strstr((char *)pRcvData, (char *)pCharacterStr);
	SearchStrLen=strlen((char *)pCharacterStr);
	if(ptr!= NULL)
	{
		ptr+=SearchStrLen;
		
		a = *(ptr-1);