islavecomm.c

电力行业的DL645采集程序,嵌入式Linux环境

#define ARM_ISLAVECOMM_GLOBALS
#include "cfg_ISlave.h"

const unsigned short crctttab[256] =
{
	0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
	0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF,
	0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6,
	0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE,
	0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485,
	0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D,
	0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4,
	0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC,
	0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
	0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B,
	0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12, 
	0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A, 
	0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41, 
	0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49, 
	0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70,
	0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78, 
	0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F,
	0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067, 
	0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E,
	0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256,
	0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D,
	0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
	0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C,
	0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634,
	0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB,
	0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3,
	0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
	0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92,
	0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9,
	0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1,
	0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8,
	0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
};
void mPrintfHex(const INT8U *pBuf, INT32U size)
{
    INT32U i;
    for(i = 0; i < size; i++)
      printf("%02x ",pBuf[i]);
    printf("\n");
}
void mPrintfStr(const INT8U *pBuf, INT32U size)
{
    INT32U i;
    for(i = 0; i < size; i++)
      printf("%c",pBuf[i]);
    printf("\n");
}

INT8U mCheckSumByte(INT8U *pBuf, INT32U size)
{
    INT8U chkSum;
    chkSum = 0;
    while(size--)
    {
        chkSum += *pBuf;
        pBuf++;
    }
    return chkSum;
}

int mBinarySearch(INT16U key, INT8U *pBuff, INT16U UnitSize, INT16U size)
{
	int lo = 0;
	int hi = size;
	int mid;
	INT16U tempValue = 0;

	while (lo <= hi)
	{
		mid = (lo + hi) / 2;
		tempValue = *(INT16U *)(pBuff+(long)mid*UnitSize);

		if (key == tempValue)
			return mid;

		if (key < *(INT16U *)(pBuff+(long)mid*UnitSize))
			hi = mid - 1;
		else
			lo = mid + 1;
	}
	return -1;
}
int mIsASCII(INT8U *pAsciiData, int len)
{
	INT8U i;
	for(i=0;i<len;i++){
		if(pAsciiData[i]<0x30||pAsciiData[i]>0x39)
			return 0;
	}
	return -1;

}
void mASCIIToBCD(INT8U *pAsciiData, int len, INT8U *pBCDBuff)
{
	INT8U num;
	int i;

	num=len/2;
	
	if(mIsASCII(pAsciiData,len)==0)
	{
		memset(pBCDBuff, 0, num);
		return;
	}
	
	for(i=0; i<num; i++)
	{
		pBCDBuff[num-i-1]=((*(pAsciiData+i*2)-'0')<<4)|(*(pAsciiData+i*2+1)-'0');
	}
}
INT8U mGetWeek(int year, int month, int day)
{
	INT8U week;
	long int s;
	s=(year-1)+(year-1)/4-(year-1)/100+(year-1)/400+mGetDays(year,month,day);
	week=s%7;
	return week;
}
int  mGetDays(int year, int month, int day)
{
	int i;
	int days=0;
	for(i=1;i<=month-1;i++)
	{
		switch(i)
		{
			case 1:
			case 3:
			case 5:
			case 7:
			case 8:
			case 10:
			case 12:
				days+=31;
				break;
			case 2:
				if(mLeapYear(year))
					day+=29;
				else
					day+=28;
				break;
			case 4:
			case 6:
			case 9:
			case 11:
				day+=30;
				break;
			default:
				break;
		}
	}
	days+=day;
	return days;			
}
int mLeapYear(int Year)
{
	if((Year%4==0&&Year%100!=0)||Year%400==0)
		return 1;
	else
		return 0;
}
void KWtoW(INT8U *PBuf,INT16U size)
{
	INT32U tmpV= 0;
	memcpy(&tmpV,PBuf,size);
	tmpV = tmpV << 4;
	memcpy(PBuf,&tmpV,size);
}
void movel3bit(INT8U *PBuf,INT16U size)
{
	INT32U tmp= 0;
	memcpy(&tmp,PBuf,size);
	tmp = tmp << 3;
	memcpy(PBuf,&tmp,size);
}

void mLongToBcd(INT32U num, INT8U *bcd, INT8U size)
{
	INT8U *ptr, i, tmp;

	ptr = bcd;
	for(i = 0; i < size; i++)
	{
		*ptr = num%10;
		num = num/10;
		tmp = num%10;
		*ptr |= ((tmp << 4) & 0xf0);
		num = num/10;
		ptr++;
	}
}

INT32U mBcdToLong(INT8U *bcd, INT8U size)
{
	INT32U num;
	INT8U *ptr, i;

	ptr = bcd + size - 1;
	num = 0;
	for(i = 0; i < size; i++)
	{
		num *= 10;
		num += ((*ptr >> 4)&0x0f);
		num *= 10;
		num += ((*ptr)&0x0f);
		ptr--;
	}
	return num;
}


INT16U mUpdCrc(INT16U crc, int c)
{
	int tmp;
	tmp=(crc>>8)^c;
	crc=(crc<<8)^crctttab[tmp];
	return crc;
}

INT16U mGetCRCTT(INT8U *pBuf, INT16U size, INT16U crc)
{
	INT16U c, tmp;
	INT16U i;

	for(i = 0; i < size; i++)
	{
		c = pBuf[i];

		tmp=(crc>>8)^c;
		crc=(crc<<8)^crctttab[tmp];
	}
	return crc;
}
INT8U mBcd2Byte(INT8U bcd)
{
	return (INT8U)(((bcd>>4)&0x0f)*10 + (bcd&0x0f));
}
//????4???????       //
INT8U mHexToCompressBcd(INT8U *SrcBuff , INT8U SrcDigits, INT8U SrcDecimalDigits, INT8U *DestBuff, INT8U DestDigits, INT8U DestDecimalDigits)
{

	int i;
	INT32U a;
	INT8U buff[10];
	INT8U buff1[10];
	INT8U Digits;
	INT8U DecimalDigits;


	if(SrcDigits>4)
		return FALSE;

	memset(buff1,0,10);
	memcpy(buff1,SrcBuff,SrcDigits);

	memcpy((INT8U *)&a, buff1, 4);
	sprintf((char *)buff,"%d",a); // ld-->d
	Digits=strlen((char *)buff);

	for(i=0;i<Digits;i++)
		buff1[i]=buff[Digits-i-1]-0x30;


	if(Digits%2)										// λ???    	//
		buff1[Digits++]=0;

	Digits>>=1;
	DecimalDigits=SrcDecimalDigits;

	for(i=0;i<Digits;i++)								//????bcd?          //
		buff[i]=buff1[i<<1]|((INT8U) (buff1[(i<<1)+1]<<4));

	if(Digits==DestDigits&&DecimalDigits==DestDecimalDigits)
		memcpy(DestBuff, buff, DestDigits);
	else
		mAdjustDigits( buff, Digits, DecimalDigits, DestBuff, DestDigits, DestDecimalDigits);
		return TRUE;
}

/*****************************************************************************************
???      BOOL AdjustDigits(INT8U * SrcBuff, INT8U SrcDigits, INT8U SrcDecimalDigits, INT8U *DestBuff, INT8U DestDigits, INT8U DestDecimalDigits)
???:      BCD?С?λ??
???:      
???:      
????:      
*****************************************************************************************/

//????bcd?        //
INT8U mAdjustDigits(INT8U * SrcBuff, INT8U SrcDigits, INT8U SrcDecimalDigits, INT8U *DestBuff, INT8U DestDigits, INT8U DestDecimalDigits)
{
	int i;
	INT8U buff1[10];
	INT8U buff2[10];
	INT8U sub;
	INT8U Digits;


	if(SrcDigits==DestDigits&&SrcDecimalDigits==DestDecimalDigits)
	{
		memcpy(DestBuff, SrcBuff, DestDigits);
		return TRUE;
	}

	for(i=0;i<SrcDigits;i++)
	{
		buff1[i<<1]=*(SrcBuff+i)&0x0f;
		buff1[(i<<1)+1]=*(SrcBuff+i)>>4;
	}

	if(SrcDecimalDigits>=DestDecimalDigits)
	{
		sub=SrcDecimalDigits-DestDecimalDigits;
		Digits=SrcDigits*2-sub;
		memcpy(buff2,buff1+sub,Digits);
	}
	else if(SrcDecimalDigits<DestDecimalDigits)
	{
		sub=DestDecimalDigits-SrcDecimalDigits;
		memset(buff2,0,sub);
		Digits=SrcDigits*2;
		memcpy(buff2+sub,buff1,Digits);
		Digits=SrcDigits*2+sub;
	}

	if(Digits<=DestDigits*2)
	{
		memset(buff2+Digits,0,DestDigits*2-Digits);
	}

	for(i=0;i<DestDigits;i++)
		*(DestBuff+i)=(buff2[i<<1]&0x0f)|((INT8U)(buff2[(i<<1)+1]<<4));

	return TRUE;

}
INT8U mByte2Bcd(INT8U ch)
{
	return (INT8U)(((ch/10) << 4) + (ch%10));
}
INT16U mBcdToWord(INT16U bcd)
{
	INT16U num;
	INT8U tmp;

	tmp = *(((INT8U *)&bcd) + 1);
	num = (INT8U)(((tmp>>4)&0x0f)*10 + (tmp&0x0f));
	num *= 100;
	tmp = bcd & 0xff;
	num += (INT8U)(((tmp>>4)&0x0f)*10 + (tmp&0x0f));

	return num;
}

//void NewTimeByMin(tm *curtime,int nMin)
//{
//  int nTmp,nDays1Mon;
//  nTmp = curtime->tm_min + nMin;
//
//  if(nTmp < 0)
//  {
//    curtime->tm_min = nTmp + 60;
//    if(curtime->tm_hour > 1)
//    {
//      curtime->tm_hour--;
//    }
//    else
//    {
//      curtime->tm_hour = 23;      
//      if(curtime->tm_mday > 1)
//      {
//        curtime->tm_mday--;
//      }
//      else
//      {
//        if(curtime->tm_mon > 1)
//        {
//          curtime->tm_mon--;
//        }
//        else
//        {
//          curtime->tm_mon=12;
//          curtime->tm_year--;
//        } 
//        nDays1Mon = GetDaysOfMonth(curtime->tm_year,curtime->tm_mon);
//        curtime->tm_mday = nDays1Mon;
//      }    
//    }
//  }
//  else if(nTmp > 59)
//  {
//    curtime->tm_min = nTmp - 60;
//    if(curtime->tm_hour+1 < 24)
//    {
//      curtime->tm_hour++;
//    }
//    else
//    {// +
//      curtime->tm_hour = 0;
//      nDays1Mon = GetDaysOfMonth(curtime->tm_year,curtime->tm_mon);
//      if(curtime->tm_mday < nDays1Mon)
//      {
//        curtime->tm_mday++;
//      }
//      else
//      {
//        curtime->tm_mday = 1;        
//        if(curtime->tm_mon<12)
//        {
//          curtime->tm_mon++;
//        }
//        else
//        {
//          curtime->tm_mon = 1;
//          curtime->tm_year++;
//        }
//      }    
//    }
//  }  
//  else
//  {
//    curtime->tm_min = nTmp;
//  }
//}