slaveactaris.c

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

	  INT8U PhyAddrhi, PhyAddrlow;
	  INT8U actarisBuff[MAX_ACTARIS_FRAME_SIZE];
	
        PhyAddrhi = (PhysicalAddr&0xff00)>>8;                 //Physical Address high byte
        PhyAddrlow = PhysicalAddr&0x00ff;   
		
	  size = 0;
	  ptr = actarisBuff;
	  *(ptr++) = 0x7e;
	  *(ptr++) = 0xa0;
	  *(ptr++) = 0x0a;
	  *(ptr++) = 0x00;
	  *(ptr++) = 0x22;
	  size+=5;
	 *(ptr++) = PhyAddrhi;
	 *(ptr++) = PhyAddrlow;
	 size+=2;
	 *(ptr++) = 0x03;
	 *(ptr++) = 0xB1;
	 tryfcs16(&actarisBuff[1], 8);
	 ptr += 2;
	 *(ptr++) = 0x7e;
	 size += 5;
	 SendActarisFrame(port, actarisBuff, size);
	 if(ReceiveActarisFrame(fd,actarisBuff) == TRUE)
 	{
 #if SLAVE_DEBUG_EN > 0	  
	printf("Slaveactaris finished ok\n");
#endif
       }
}



BOOL RequireActaris(INT16U PhysicalAddr)
{
	INT8U port = SLAVE_PORT_1;
	 INT8U commande[80]={0x7e,0xA0,0x46,0x00,0x22,0x00,0x00,0x03,0x10,0x30,0x00,0xe6,0xe6,0x00,0x60,0x35,0xa1,0x09,
	 0x06,0x07,0x60,0x85,0x74,0x05,0x08,0x01,0x01,0x8a,0x02,0x07,0x80,0x8b,0x07,0x60,0x85,0x74,0x05,0x08,0x02,
	 0x01,0xac,0x0a,0x80,0x08,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0xbe,0x10,0x04,0x0e,0x01,0x00,0x00,0x00,0x06,
	 0x5f,0x04,0x00,0x00,0x00,0x14,0x00,0x00};
	 
	  INT8U PhyAddrhi, PhyAddrlow;
	 INT8U actarisBuff[MAX_ACTARIS_FRAME_SIZE];
	 
        PhyAddrhi = (PhysicalAddr&0xff00)>>8;                 //Physical Address high byte
        PhyAddrlow = PhysicalAddr&0x00ff;   
		
	 commande[5]=PhyAddrhi;
	 commande[6]=PhyAddrlow;
	 tryfcs16(&commande[1],8);
	 tryfcs16(&commande[1],68);
	 commande[71]=0x7e;
	 SendActarisFrame(port,commande,72);
	 if(ReceiveActarisFrame(fd,actarisBuff)==TRUE)
 	{
 #if SLAVE_DEBUG_EN > 0	  
	printf("Slaveactaris reqapp ok \n");
#endif
	 	return TRUE;
       }
	 else
	 {
	 	return FALSE;
	 }
}

INT32U actarisbytetolong(INT8U *bcd,INT8U size)
{
	INT32U  datalong;
	INT8U  *ptr; 
   INT8U i;
	
	ptr = bcd;
	datalong  = 0;
	for(i = 0; i < size; i++)
	{
		datalong *= 256;
		datalong +=*ptr ;
		ptr++;
	}
	return datalong;
}
INT16U actarisbyteto16U(INT8U *bcd,INT8U size)
{
	INT16U  datalong ;
	INT8U  *ptr; 
	int  i;
	
	ptr = bcd;
	datalong  = 0;
	for(i = 0; i < size; i++)
	{
		datalong *= 256;
		datalong +=*ptr ;
		ptr++;
	}
	return datalong;
}

 void DealWithActarisData(INT8U *pBuff, 	int  len)
{
	INT16U DataWord;
	INT32U DataLong;
	if(len == 4)
	{ 
	     //mPrintfHex((INT8*)pBuf,4);
       	DataLong=actarisbytetolong(pBuff,4);
		 mLongToBcd(DataLong,pBuff,4);
	}
	else if (len == 2)
	{ 
	    DataWord=actarisbyteto16U(pBuff,2);
	     //wordtobcdl(DataWord,pBuff);
       }
          
}
 void Adjustactrice(INT16U idnum,INT8U *sbuff,INT8U *dbuff,INT16U  lend)
{	INT16U  len,i,j,lgth;
	INT8U datatype;	
	INT8U buff1[10];
	INT8U buff2[10];
	for(i=0;i<10;i++)
		{buff1[i]=0;
	         buff2[i]=0;
		}
       len = ActarisOBISTab[idnum].datasize;	
	datatype = ActarisOBISTab[idnum].datatype;	
	if(len==lend&&datatype==0)	
		memcpy(dbuff, sbuff, lend);
       else
	   	{//printf("cccccccccccccccccccccccc");   
	         for(i=0;i<len;i++)
	           {buff1[i<<1]=*(sbuff+i)&0x0f;
		      buff1[(i<<1)+1]=*(sbuff+i)>>4;
	             }
#if SLAVE_DEBUG_EN > 0	  
	printf("Slave actaris dealData1:\n");
	mPrintfHex(buff1,len*2);
#endif
	        if(datatype)
	           {     lgth=len*2-datatype;
		           memcpy(buff2,buff1+datatype,lgth);
			   //printf("ddddddddddddddddddddd");   
	             }
		 else 		
		 	{memcpy(buff2,buff1,len*2);
		         for(i=0;i<0x03ff;i++)   i=i;        //delay 
		// printf("eeeeeeeeeeeeeeeeeeeee");   
		}
#if SLAVE_DEBUG_EN > 0	  
	printf("Slave actaris dealData2:\n");
	mPrintfHex(buff2,len*2);
#endif
	        for(i=0;i<lend;i++)
	        	{
		    *(dbuff+i)=buff2[2*i]+buff2[2*i+1]*0x10;
		    for(j=0;j<0x03ff;j++)  j=j;        //delay 
	#if SLAVE_DEBUG_EN > 0		
                  printf("dbuff %d   ,buff1%d , buff2 %d\n",*(dbuff+i),buff2[2*i],buff2[2*i+1]*0x10);
	#endif	
	        	}
#if SLAVE_DEBUG_EN > 0	  
       printf("lend===%d\n",lend);
	printf("Slave actaris dealData3:\n");       
	mPrintfHex(dbuff,len);
#endif			
              }		
}



INT8U ActarisReadOneDataIdFromMeter(INT16U dataId, INT8U *pBuff, INT16U *pLength, INT16U PhysicalAddr)
{
	INT8U SendCommand[30] = {0x7e,0xa0,0x1b,0x00,0x22};
	INT8U *ptr, i;
	INT8U pBuff1[10];
	int a;
	int len;
	INT16U iddatasize;
	INT8U datatype = 0;
	INT8U retvalue = SUCCESS;
	INT8U port = SLAVE_PORT_1;
	INT8U PhyAddrhi, PhyAddrlow;
	INT8U actarisBuff[MAX_ACTARIS_FRAME_SIZE];

        PhyAddrhi = (PhysicalAddr&0xff00)>>8;                 //Physical Address high byte
        PhyAddrlow = PhysicalAddr&0x00ff;   
       //printf("phyaddrhi==%c,PhyAddrlow==%c\n", PhyAddrhi, PhyAddrlow);	
	ptr=&SendCommand[5];	
for(i=0;i<3;i++)
{
	if( LinkActaris(PhysicalAddr) == TRUE)
	{
		break;
	}	
}	
if(i>=3)  	return FALSE;
	if(RequireActaris(PhysicalAddr) == FALSE)
	{
		return FALSE;
	}
	*(ptr++)=PhyAddrhi;
	*(ptr++)=PhyAddrlow;
	*(ptr++)=0x03;
	*(ptr++)=0x32;
	tryfcs16(&SendCommand[1],8);

	*pLength = 0;	

	//iddatasize = LCGetIDDataSize(dataId);
	
	a = mBinarySearch(dataId, (unsigned char *)ActarisOBISTab, sizeof(ActarisOBISType), ACTARIS_OBIS_TAB_SIZE);

	if(a < 0)
	{
		memset(pBuff, 0xff, iddatasize);		
		return SUCCESS;
	}
	len = ActarisOBISTab[a].datasize;
	*pLength=len;
	datatype = ActarisOBISTab[a].datatype;
	 memcpy(&SendCommand[11],COSEM_FIX_FORMAT,5);
	 SendCommand[16]=0x81;
	 memcpy(&SendCommand[17], (INT8U *)(ActarisOBISTab[a].classId), 2);
	 memcpy(&SendCommand[19], (INT8U *)(ActarisOBISTab[a].obis), 6);
	 SendCommand[25]=0x02;
	 tryfcs16(&SendCommand[1],25);
	 SendCommand[28]=0x7e;
        SendActarisFrame(port,SendCommand,29);
		
 	 memset(actarisBuff, 0, MAX_ACTARIS_FRAME_SIZE);
	 
	 if(ReceiveActarisFrame(fd,actarisBuff) == TRUE)
        {
#if SLAVE_DEBUG_EN > 0	  
	printf("Slave actarisdataid:\n");
	mPrintfHex((INT8U *)&dataId,2);
#endif
		if(actarisBuff[19 + 2 + len] == 0x7e)
		{ 
	         	memset(pBuff1, 0, 10);
       	       memcpy(pBuff1, &actarisBuff[19], len);
#if SLAVE_DEBUG_EN > 0	  
	printf("Slave actaris Data:\n");
	mPrintfHex(pBuff1, len);
#endif
			DealWithActarisData(pBuff1, len);
#if SLAVE_DEBUG_EN > 0	  
	printf("Slave actaris dealData:\n");
	mPrintfHex(pBuff1, len);
#endif	
			Adjustactrice( a,pBuff1,pBuff,*pLength);
#if SLAVE_DEBUG_EN > 0	  
	printf("Slave actaris Dataend:\n");
	mPrintfHex(pBuff,len);
#endif			
             retvalue=SUCCESS;
		}  
	 }
	 return retvalue;

}
int ActarisReadDataFromMeter(INT16U dataId, INT8U *pBuff, INT16U *pLength, INT16U PhysicalAddr)
{
	INT16U startId, idNum, idDataSize;
	INT16U i;
	INT16U size;
	INT8U buff[10];
	INT32U value;
	INT8U retvalue;
	

	*pLength = 0;
	if((dataId & 0x000f) == 0x000f)
	{
		switch(dataId)
		{
			case 0x901f:
			case 0x902f:				
			//case 0x911f:
			//case 0x912f:
				startId = dataId&0xfff0;
				idNum = 5;
				idDataSize = 4;
				break;
			case 0xa01f:
			case 0xa02f:
			//case 0xa11f:
			//case 0xa12f:
				startId = dataId&0xfff0;
				idNum = 5;
				idDataSize = 3;
				break;				
			case 0xb61f:
			case 0xb62f:	
				startId = dataId&0xfff1;
				idNum = 3;
				idDataSize = 2;
				break;				
			case 0xb63f:
				startId = 0xb630;
				idNum = 4;
				idDataSize = 3;
				break;
			case 0xb64f:
			case 0xb65f:	
				idDataSize = 2;
				idNum = 4;
				startId = dataId&0xfff0;				
				break;
			case 0xb66f:
				startId = 0xb660;
				idNum = 6;
				idDataSize = 2;
				break;
			default:
				return SUCCESS;
		}
		*pLength = 0;
		for(i = 0; i < idNum; i++)
		{
			if(ActarisReadOneDataIdFromMeter(startId, pBuff + *pLength, &size, PhysicalAddr) != SUCCESS)
			{
				memset(pBuff + *pLength, 0xff, idDataSize);
			}
			startId ++;
			*pLength += idDataSize;
		}
	}
	else if(dataId == 0xb640)
	{
		idDataSize = 2;
		*pLength = 0;
		startId = 0xb64a;
		value = 0;
		for(i = 0; i < 2; i++)
		{
			retvalue = ActarisReadOneDataIdFromMeter(startId, buff, &size, PhysicalAddr);
			if(retvalue != SUCCESS)
			{
				return retvalue;
			}
			startId ++;
			
			value += mBcdToLong(buff, idDataSize);
		}
		mLongToBcd(value, pBuff, idDataSize);
		*pLength = idDataSize;
	}
	else
	{
		retvalue = ActarisReadOneDataIdFromMeter(dataId, pBuff, pLength, PhysicalAddr);
		if(retvalue != SUCCESS)
		{
			return retvalue;
		}
	}
	return SUCCESS;
}

int SlaveActarisReadData(MpComProperty *mpProperty, INT16U id, INT8U *pbuf, INT16U bufsize, INT16U *psize)
{
      INT16U  Addr;
			INT16U PhysicalAddr;
		
      memcpy((INT8U *)&Addr, (INT8U *)mpProperty->addr, 2);//physical Address

      Addr = mBcdToWord(Addr);

      PhysicalAddr = ActarisPhysicalAddress(Addr);
     *psize = 0;

	return ActarisReadDataFromMeter(id, pbuf, psize, PhysicalAddr);
}