slaveedmi.c

各种规约电表程序的(包手DL645,威胜,西门子等,的库程序)极大方便远程抄表系统

					printf("FilterEDMIFrame OK\n");
#endif					
					pRespondFrame = (EDMICmdExpRespondType *)recvBuff;
					size = frameSize - 15;
					memcpy(pRespond, (INT8U *)(pRespondFrame->cmdData), size);
#if SLAVE_DEBUG_EN > 0
					printf("size %d\n", size);
#endif					
					return size;
				}
			}
		}
		usleep(SLAVE_WAIT_DELAY_TIME);
	}

	return 0;
}


void InitEdmiSn(void)
{
	gEdmiSn=0xffff;
}

void UpdateEdmiSn(void)
{
	gEdmiSn++;
}




int SlaveEdmiLogin(MpComProperty *mpProperty)
{
	INT32U EdmiAddr;
	int length;
	INT8U buff[100];
	INT8U user[9];
	INT8U pass[9];
	INT8U pRecvBuf[EDMI_FRAME_SIZE];
	int offset;
	int i,size;
	  
	InitEdmiSn();

	offset = 0;

	memset(user, 0, 9);
	memcpy(user, mpProperty->user, 8);
  
	memset(pass, 0, 9);
	memcpy(pass, mpProperty->pass, 8);
	
	memcpy(buff, user, strlen((char*)user));
	length = strlen((char*)user);
	buff[length++]=',';

	memcpy(buff+length,pass, strlen((char*)pass));
	length += strlen((char*)pass);
	buff[length]='\0';
	length++;

  MeterAddrType *pMeterAddr = (MeterAddrType*)mpProperty->addr;
	MaskEDMIAddr(pMeterAddr, &EdmiAddr);
	mPrintfHex((INT8U *)&EdmiAddr, 4);

	for(i=0; i<2; i++)
	{
		INT32U logSCR= 0x00;
		EDMISendFrame(EdmiAddr, logSCR, gEdmiSn, 'L', buff, length);
	  size=GetEDMICmdRespondData(EdmiAddr, EDMI_SRC_ADDR, gEdmiSn, pRecvBuf);
    if(size==1&&pRecvBuf[0]==EDMI_ACK)
		{
			UpdateEdmiSn();
			return 0;
		}
	  else if(size==2&&pRecvBuf[0]==EDMI_CAN)
			return -1;
	}

	return -1;
}
int EDMILogout(MpComProperty *mpProperty)
{
	INT32U EdmiAddr;
	INT8U dataBuff[EDMI_FRAME_SIZE];
	int size;

  MeterAddrType *pMeterAddr = (MeterAddrType*)mpProperty->addr;
	MaskEDMIAddr(pMeterAddr, &EdmiAddr);

	EDMISendFrame(EdmiAddr, EDMI_SRC_ADDR, gEdmiSn, 'X', dataBuff, 0);
	size=GetEDMICmdRespondData(EdmiAddr, EDMI_SRC_ADDR, gEdmiSn, dataBuff);
	if(size==1 && dataBuff[0]==EDMI_ACK)
	{
		UpdateEdmiSn();
		return SUCCESS;
	}
	else if(size==2 && dataBuff[0]==EDMI_CAN)
	{
		if(dataBuff[1] == ERROR_NOT_LOGIN)
			return SUCCESS;
		else
			return FAILED;	
	}
		
	return FAILED;
}


void  MaskEDMIAddr(MeterAddrType *pMeterAddr, INT32U *pEdmiAddr)
{
	*pEdmiAddr = mBcdToLong((INT8U*)pMeterAddr, 6);
}

int ReadEDMIRegData(MpComProperty *mpProperty, INT8U cmd,INT8U *pCmdData,int CmdDataLen, INT8U *pDataBuff)
{	
	int size;
	INT32U EdmiAddr;
	int i;
	INT8U dataBuff[EDMI_FRAME_SIZE];

#if SLAVE_DEBUG_EN > 0
	printf("ReadEDMIRegData\n");
#endif	

		if(SlaveEdmiLogin(mpProperty) != SUCCESS)
		{
				return 0;			
		}
	
	MeterAddrType *pMeterAddr = (MeterAddrType*)mpProperty->addr;
	MaskEDMIAddr(pMeterAddr, &EdmiAddr);

	#if SLAVE_DEBUG_EN > 0
		printf("EdmiAddr %x\n", EdmiAddr);
	#endif		

	for(i=0; i<2; i++)
	{
		EDMISendFrame(EdmiAddr, EDMI_SRC_ADDR, gEdmiSn, cmd, pCmdData, CmdDataLen);
		size = GetEDMICmdRespondData(EdmiAddr, EDMI_SRC_ADDR, gEdmiSn, dataBuff);
		if(size > 0)
		{
#if SLAVE_DEBUG_EN > 0
			printf("dataBuff %d:\n", size);
			mPrintfHex(dataBuff, size);
#endif			
			 if(size == 2 && dataBuff[0] == EDMI_CAN)
			{
				if(dataBuff[1] == ERROR_NOT_LOGIN)
				{
					if(SlaveEdmiLogin(mpProperty) == SUCCESS)
					{
						continue;
					}
				else
						return 0;
				}
				else
					return 0;
			 }
			 
			size -= (CmdDataLen+1);
			memcpy(pDataBuff, dataBuff + CmdDataLen + 1, size);
			UpdateEdmiSn();
#if SLAVE_DEBUG_EN > 0
			printf("data %d:\n", size);
			mPrintfHex(pDataBuff, size);
#endif				
			return size;
		}
		else
		{
			break;
		}
			
	}
	return 0;
}

//int ReadEDMIRegData(INT8U cmd,INT8U *pCmdData,int CmdDataLen,MeterAddrType *pSlaveAddr, INT8U *pUser, INT8U *pPassword, INT8U *pDataBuff)
//{	
//	INT16U size;
//	INT32U EdmiAddr;
////	INT16U testNod;	
//	int i;
//
//
//	MaskEDMIAddr(pSlaveAddr, &EdmiAddr );
//
//
////	for(i=0; i<3; i++)
////	{
////		
////		EDMIWriteFrame(EdmiAddr, EDMI_SRC_ADDR, gEdmiSn, cmd, pCmdData, CmdDataLen);
////		size=GetEDMICmdRespondData(EdmiAddr, EDMI_SRC_ADDR, gEdmiSn, gEDMIRecvBuff);
////		printHex(gEDMIRecvBuff, size);
////		if(size>0)
////		{
////			
////			 if(size==2&&gEDMIRecvBuff[0]==EDMI_CAN)
////			{
////				if(gEDMIRecvBuff[1]==ERROR_NOT_LOGIN)
////				{
////					if(EDMILogin(pSlaveAddr, pUser, pPassword )==TRUE)
////					{
//////						gEdmiLoginFlag=1;
////						continue;
////					}
////					else
////						return 0;
////				}
////				else
////					return 0;
////			 }
////			 
////      printf("EDMI:size=%d,CmdDataLen=%d\n", size,CmdDataLen);
////      //PrintHexBytes(gEDMIRecvBuff)
////			size -= (CmdDataLen+1);
////			memcpy(pDataBuff, gEDMIRecvBuff+CmdDataLen+1, size);
////#ifdef DEBUG_PRINT
////			printf("read data is:\n");
////			printHex(pDataBuff, size);
////#endif
////			UpdateEdmiSn();
////			return size;
////		}
//////		if(size>0)
//////		{
//////			printf("size=%d\n", size);
//////			size -= (CmdDataLen+1);
//////			memcpy(pDataBuff, gEDMIRecvBuff+CmdDataLen+1, size);
//////			
////// 	  }
//////			 
////
//////#ifdef DEBUG_PRINT
//////
//////#endif
//////			UpdateEdmiSn();
//////			return size;
////	}
//	return -1;
//		
//}
//			
////}
////	ExitMeterOp();
//	//return 0;
////}


int ReadEDMIMultRegData(INT8U cmd,INT8U *pCmdData,int CmdDataLen,MeterAddrType *pSlaveAddr, INT8U *pUser, INT8U *pPassword, INT8U *pDataBuff)
{	
//	INT16U size;
//	INT32U EdmiAddr;
//	///INT16U testNod;	
//	int i;


	//MaskEDMIAddr(pSlaveAddr, &EdmiAddr );

	//ClearSlaveInBuffer();

	
//	for(i=0; i<READ_METER_TRY; i++)
//	{
//		//InitEdmiUart();
//		EDMIWriteFrame(EdmiAddr, EDMI_SRC_ADDR, gEdmiSn, cmd, pCmdData, CmdDataLen);
//		//size=GetEDMICmdRespondData(EdmiAddr, EDMI_SRC_ADDR, gEdmiSn, gEDMIDataBuff);
////		InitSlave();
////printHex(gEDMIDataBuff, size);
//		if(size>0)
//		{
//			
//			 if(size==2&&gEDMIDataBuff[0]==EDMI_CAN)
//			{for(i=0; i<3; i++)
//	{
//		
//		EDMIWriteFrame(EdmiAddr, EDMI_SRC_ADDR, gEdmiSn, cmd, pCmdData, CmdDataLen);
//		size=GetEDMICmdRespondData(EdmiAddr, EDMI_SRC_ADDR, gEdmiSn, gEDMIRecvBuff);
//		printHex(gEDMIRecvBuff, size);
//		if(size>0)
//		{
//			
//			 if(size==2&&gEDMIRecvBuff[0]==EDMI_CAN)
//			{
//				if(gEDMIRecvBuff[1]==ERROR_NOT_LOGIN)
//				{
//					if(EDMILogin(pSlaveAddr, pUser, pPassword )==TRUE)
//					{
////						gEdmiLoginFlag=1;
//						continue;
//					}
//					else
//						return 0;
//				}
//				else
//					return 0;
//			 }
//			 
//      printf("EDMI:size=%d,CmdDataLen=%d\n", size,CmdDataLen);
//      //PrintHexBytes(gEDMIRecvBuff)
//			size -= (CmdDataLen+1);
//			memcpy(pDataBuff, gEDMIRecvBuff+CmdDataLen+1, size);
//#ifdef DEBUG_PRINT
//			printf("read data is:\n");
//			printHex(pDataBuff, size);
//#endif
//			UpdateEdmiSn();
//			return size;
//		}
////		if(size>0)
////		{
////			printf("size=%d\n", size);
////			size -= (CmdDataLen+1);
////			memcpy(pDataBuff, gEDMIRecvBuff+CmdDataLen+1, size);
////			
//// 	  }
////			 
//
////#ifdef DEBUG_PRINT
////
////#endif
////			UpdateEdmiSn();
////			return size;
//	}
//				if(gEDMIDataBuff[1]==ERROR_NOT_LOGIN)
//				{
//					if(EDMILogin(pSlaveAddr, pUser, pPassword)==TRUE)
//					{
////						gEdmiLoginFlag=1;
//						continue;
//					}
//					else
//						return 0;
//				}
//				else
//					return 0;
//			 }
			 
//printf("size=%d\n", size);
//			size -= (4+1);
//	//memcpy(pDataBuff, gEDMIDataBuff+4+1, size);
//#ifdef DEBUG_PRINT
//			printf("read data is:\n");
//			printHex(pDataBuff, size);
//#endif
//			UpdateEdmiSn();
//			return size;
//		}
//			
//	}
//	ExitMeterOp();
	return 0;
}


int ReadEDMIData(INT32U Addr, MpComProperty *mpProperty, INT8U *pDataBuff)
{	
	INT8U buff[50];
	int cmdsize;
	INT16U tmp;

	tmp = ByteOrder_i(Addr);
	buff[0] = (INT8U)(tmp&0xff);
	buff[1] = (INT8U)((tmp>>8)&0xff);
	cmdsize=2;
	return ReadEDMIRegData( mpProperty,'R', buff, cmdsize,  pDataBuff);	
}

int EdmiReadEnergy(MpComProperty *mpProperty, INT16U LCId, INT8U *pBuff,INT16U bufsize,INT16U *psize)
{
		int offset;
	int i;
	INT32U RegAddr;
	INT8U RegNum;
	int len;
	int datalen;
	float a;
	INT32U c;
	INT8U buff[170];


#if SLAVE_DEBUG_EN > 0
	printf("EdmiReadEnergy\n");
#endif	

	*psize=0;
	len = 0;

	if((LCId&0x000f)!=0x0f)
	{
		if(LCId >= 0x9010 && LCId<=0xb02f)
		{
			offset=mBinarySearch(LCId&(~0x0400), (INT8U *)EdmiIdTable, sizeof(EdmiTableType), EDMI_TABLE_SIZE);	
		}
		else
		{
			offset=mBinarySearch(LCId, (INT8U *)EdmiIdTable, sizeof(EdmiTableType), EDMI_TABLE_SIZE);
		}
				

		if(offset>=0)
		{
			RegAddr = EdmiIdTable[offset].IdAddr;
			if((LCId >= 0x9010 && LCId<=0xb02f) && (LCId&0x0400)!=0)		//monthly id
			{
				RegAddr = (RegAddr&(~0x0020L));
			}
			RegNum = 1;
			
			len=ReadEDMIData(RegAddr,mpProperty, buff);
#if SLAVE_DEBUG_EN > 0
			printf("len = %d:\n", len);
			mPrintfHex(buff, len);
#endif	
			if(len <= 0)
			{
				return E_NO_SUCH_DATA;
			}

			datalen = 0;

			c=ByteOrder_l(*(INT32U *)buff);
#if SLAVE_DEBUG_EN > 0
			printf("c:\n");
			mPrintfHex((INT8U *)&c, 4);
#endif			
			a = *(float *)&c;
#if SLAVE_DEBUG_EN > 0
			printf("a = %f\n", a);
#endif			

//			a=fabs(a);
			if(a < 0)
			{
				a = a*(-1);
			}
			a/=10;
#if SLAVE_DEBUG_EN > 0
			printf("a = %f\n", a);
#endif			
			c=a;
#if SLAVE_DEBUG_EN > 0
			printf("c = %d\n", c);
#endif			
			if(a-c > 0.5)
			{
				c++;
			}
#if SLAVE_DEBUG_EN > 0
			printf("c = %d\n", c);
#endif				
			mLongToBcd(c, pBuff, 4);
			datalen = 4;
#if SLAVE_DEBUG_EN > 0
			printf("Energy data\n");
			mPrintfHex(pBuff, 4);
#endif
			*psize = datalen;
			return SUCCESS;
		}
		else
		{
			return E_NO_SUCH_DATA;
		}
	}
	else
	{
		if(LCId >= 0x9010 && LCId<=0xb02f)
		{
			offset=mBinarySearch(LCId&(~0x0400), (INT8U *)EdmiIdTable, sizeof(EdmiTableType), EDMI_TABLE_SIZE);	
		}
		else
		{
			offset=mBinarySearch(LCId, (INT8U *)EdmiIdTable, sizeof(EdmiTableType), EDMI_TABLE_SIZE);
		}
		if(offset < 0)
		{
			return E_NO_SUCH_DATA;
		}
			
		LCId = LCId&0xfff0;
		memset(pBuff, 0xff, 5*4);
		datalen = 0;