ad7799.c

AD7799的驱动程序片断

//======================================
void AD_WriteFullScaleReg(unsigned char bDev,unsigned long lData)
{
	unsigned char bTmp[3];

	bTmp[0]=COMM_MASK&(ADREG_FULLSCALE|COMM_SINGLEWR);

	AD7799_WrBytes(bDev,1,bTmp);		//写通讯寄存器


	bTmp[0] = (unsigned char) ((lData>>16)&0xFF);

	bTmp[1] = (unsigned char) ((lData>>8)&0xFF);

	bTmp[2] = (unsigned char) (lData & 0xFF);


	AD7799_WrBytes(bDev,3,bTmp);		//写通讯寄存器
	return;
}
//======================================
void Init_AD(unsigned char bDev)
{
	unsigned char u;

	bDev &= 0x01;

	UnSelectAdChip();

	AD_WriteIoReg(bDev,0x40);

	AD_WriteConfigReg(bDev,0x1710);	//BO Disable，无符号，Gain=128,REF_DET = 1,BUF = 1,CH=0
	AD_WriteModeReg(bDev,0x400F);	//待命,19.6Hz

	for (u=0;u<2;u++) {
		sMyCont.sAd[u].fEnAd = 0;
		sMyCont.sAd[u].fJust = 0;
		sMyCont.sAd[u].fAdBusy = 0;
		sMyCont.sAd[u].fAdValid = 0;
		sMyCont.sAd[u].fCharge = 0;
		sMyCont.sAd[u].ulNowWeight = 0;

		sMyCont.sAd[u].bPointer = 0;
		sMyCont.sAd[u].bFlagCon = 0;

		sMyCont.sAd[u].ulArray[0] = 0;
		sMyCont.sAd[u].ulArray[1] = 0;
		sMyCont.sAd[u].ulArray[2] = 0;
		sMyCont.sAd[u].ulArray[3] = 0;
		sMyCont.sAd[u].ulArray[4] = 0;
		sMyCont.sAd[u].ulArray[5] = 0;

	}
	AD_WriteIoReg(bDev,0x60);

	return;	
}
//======================================
unsigned long InternalZeroCalibration(unsigned char bDev,unsigned char bTimes)
{
	unsigned char u;
	unsigned long lTmp;
	
	lTmp=0;

	for(u=0;u<bTimes;u++) {
		AD_WriteModeReg(bDev,0x9180);
//		Delay(1);
//		while(MCU_ADI);
		lTmp=lTmp+AD_ReadOffsetReg(bDev);
	}
	return lTmp/bTimes;

}
//======================================
	
unsigned char SetBalancePower(unsigned char bCh,unsigned char bOn)
{
	unsigned char bRet;

	ET1 = 0;
	TR1 = 0;
	TF1 = 0;

	bCh &= 0x01;

	if (sMyCont.sAd[bCh].bSwt!= 0x00 || (!bOn)) {

		sMyCont.sAd[bCh].fEnAd = bOn;
		sMyCont.sAd[bCh].fJust = 1;

		bRet = 0;
	}
	else {

		bRet = 1;
	}
/*	
	if (sMyCont.sAd[0].bSwt ||sMyCont.sAd[1].bSwt) {
		if ( !(SFST&0x08) ) {	//如果当前没有使能时钟加倍模式
			TL1 = LSB(AD_LOOP_L);
			TH1 = MSB(AD_LOOP_L);
		}
		else {
			TL1 = LSB(AD_LOOP_H);
			TH1 = MSB(AD_LOOP_H);
		}
		TF1= 0;
		ET1 = 1;
		TR1 = 1;
	}
*/	
	return bRet;

}
unsigned long ChangeAd2Weight(unsigned char bSwt,unsigned long ulAd)
{
	unsigned long ulTmp;

	ulTmp = ulAd;

	switch (bSwt) {
	case 1:
		ulTmp *= PARA_250KG;
		break;
	case 2:
		ulTmp *= PARA_200KG;
		break;
	case 3:
		ulTmp *= PARA_60KG;
		break;
	default :
		ulTmp = 0;
	}


	ulTmp /= 100;		//这里放大了10倍
	
	if (ulTmp%10>=5) {
		ulTmp = ulTmp/10*10+10;
	}
	else {
		ulTmp = ulTmp/10 *10;
	}

	return ulTmp;

}
unsigned long GetWeight(unsigned char bCh,unsigned char *bCharge)
{
	bit	fBak;

	fBak = ET1;
	ET1 = 0;

	bCh &= 0x01;

	*bCharge = sMyCont.sAd[bCh].fCharge;

	if (sMyCont.sAd[bCh].fAdValid){
		ET1 = fBak;
		return (sMyCont.sAd[bCh].ulNowWeight);
	}
	else {
		ET1 = fBak;
		return 0;
	}


}

unsigned long ExeZeroCalibration(unsigned char bCh)
{
	unsigned char idata u;
	unsigned long idata ulTmp;
	bit	fBak;

	fBak = ET1;
	ET1 = 0;
	
	ulTmp=0;

	AD_WriteIoReg(bCh,0x40);				//开灯
 	AD_WriteModeReg(bCh,0x5000|0x000F);		//进入待命模式

	for(u=0;u<AD_FILTER_WIDTH;u++) {


		AD_WriteModeReg(bCh,BIT_MODE_SYSZERO|BIT_MODE_PSW|AD_RATE_CALIB);

		do {
		}while(AD_ReadStatusReg(bCh)&0x80);

		sMyCont.sAd[bCh].ulArray[u] = AD_ReadOffsetReg(bCh);

	}

	
	AD_WriteIoReg(bCh,0x60);						//关灯

	ulTmp = GetWeight2(bCh);
	AD_WriteOffsetReg(bCh,ulTmp);

	if (sMyCont.sAd[bCh].fEnAd) {
		AD_WriteModeReg(bCh,BIT_MODE_CONTCONV|BIT_MODE_PSW|AD_RATE_DATA);
	}
	else{
		AD_WriteModeReg(bCh,BIT_MODE_POWERDOWN); 		//下电
	}

 	for(u=0;u<AD_FILTER_WIDTH;u++) {
		sMyCont.sAd[bCh].ulArray[u] = 0;
	}
	
	sMyCont.sAd[bCh].bPointer = 0;
	sMyCont.sAd[bCh].fAdValid = 0;
	ET1 = fBak;

	return ulTmp;

	
}

/*
unsigned long ExeFullScaleCalibration(unsigned char bCh,unsigned long ulWeight)
{
	unsigned char u;
	unsigned long ulTmp;
	bit	fBak;

	fBak = ET1;
	ET1 = 0;

	AD_WriteIoReg(bCh,0x40);						//开灯
	AD_WriteModeReg(bCh,0x5000|0x000F);		//进入待命模式

	ulTmp=0;


	for(u=0;u<AD_FILTER_WIDTH;u++) {

		AD_WriteIoReg(bCh,0x40);						//开灯

		AD_WriteModeReg(bCh,0xF000| AD_RATE_CALIB);

		do {

		}while(AD_ReadStatusReg(bCh)&0x80);

		sMyCont.sAd[bCh].ulArray[u] = AD_ReadFullScaleReg(bCh);

		AD_WriteIoReg(bCh,0x60);						//关灯
	}

	AD_WriteIoReg(bCh,0x60);						//关灯
	ulTmp = GetWeight2(bCh);
	AD_WriteFullScaleReg(bCh,ulTmp);

	if (sMyCont.sAd[bCh].fEnAd) {
		AD_WriteModeReg(bCh,BIT_MODE_CONTCONV|BIT_MODE_PSW|AD_RATE_DATA);
	}
	else{
		AD_WriteModeReg(bCh,BIT_MODE_POWERDOWN); 		//下电
	}

 	for(u=0;u<AD_FILTER_WIDTH;u++) {
		sMyCont.sAd[bCh].ulArray[u] = 0;
	}
	sMyCont.sAd[bCh].bPointer = 0;
	sMyCont.sAd[bCh].fAdValid = 0;

	ET1 = fBak;

	return ulTmp;
}	
*/

unsigned long MyFullScaleCalibration(unsigned char bCh,unsigned long ulWeight)
{
	unsigned long ulTmp,ulNow,ulDelta,ulAd;
	unsigned char bLast,u,v;
	bit	fBak;

	fBak = ET1;
	ET1 = 0;

	ulTmp = AD_ReadFullScaleReg(bCh);						//读出当前的满幅系数

	ulDelta = 128;

	bLast = 2;
	u = 0;

	do{

		AD_WriteModeReg(bCh,BIT_MODE_CONTCONV|BIT_MODE_PSW|AD_RATE_DATA); 		//开始转换

		for (v=0;v<AD_FILTER_WIDTH;v++){

			AD_WriteIoReg(bCh,0x40);						//开灯

			do {
			}while(AD_ReadStatusReg(bCh)&0x80);

			ulAd = AD_ReadDataReg(bCh);
			ulAd >>= 7;		///16/4，如果要分度为1克，则只能/16
			ulAd = ChangeAd2Weight(sMyCont.sAd[bCh].bSwt,ulAd);

			sMyCont.sAd[bCh].ulArray[sMyCont.sAd[bCh].bPointer] = ulAd;
		
			if (sMyCont.sAd[bCh].bPointer == AD_FILTER_WIDTH-1) {
				sMyCont.sAd[bCh].bPointer = 0;
			}
			else {
				sMyCont.sAd[bCh].bPointer ++;	
			}

			AD_WriteIoReg(bCh,0x60);						//关灯
		}

		ulNow = GetWeight2(0);
/*
ES = 0;
TI = 0;
SBUF = ulTmp&0xFF;
while(!TI);
TI = 0;
SBUF = (ulTmp>>8)&0xFF;
while(!TI);
TI = 0;
SBUF = (ulTmp>>16)&0xFF;
while(!TI);
TI = 0;
SBUF = (ulTmp>>24)&0xFF;
while(!TI);
TI = 0;
SBUF = (ulNow)&0xFF;
while(!TI);
TI = 0;
SBUF = (ulNow>>8)&0xFF;
while(!TI);
TI = 0;
SBUF = (ulNow>>16)&0xFF;
while(!TI);
TI = 0;
SBUF = (ulNow>>24)&0xFF;
while(!TI);
TI = 0;
ES = 1;
*/
		if (u==0) {		//首次利用运算减少时间

			if (ulNow>ulWeight) {
				ulTmp = (ulTmp<<8)/((ulNow<<8)/ulWeight);
				bLast = 1;
			}
			else if (ulNow<ulWeight) {
				ulTmp = (ulTmp *(((ulWeight<<8)/ulNow)>>4))>>4;
				bLast = 0;
			}
			u++;

		}
		else {

			if (ulNow>ulWeight){ 	//该减少
				if (bLast==0) {			//如果最后一次是加
					ulTmp -= ulDelta;	//恢复原值
					ulDelta /= 2;
				}
	
				ulTmp -= ulDelta;
				bLast = 1;				//改成最后一次是减
			}
			else if (ulNow<ulWeight){  	//该增加
				if (bLast==1) {			//如果最后一次是减
					ulTmp += ulDelta;	//恢复原值
					ulDelta/=2;
				}
	
				ulTmp += ulDelta;
				bLast = 0;				//改成最后一次是加
			}
			else {
				//ulDelta /= 2;
				ulDelta = 0;
				break;
			}
		}

		AD_WriteModeReg(bCh,BIT_MODE_IDLE); 		//待命
	 	AD_WriteFullScaleReg(0,ulTmp);


	}while(ulDelta!=0);

	if (sMyCont.sAd[bCh].fEnAd) {
		AD_WriteModeReg(bCh,BIT_MODE_CONTCONV|BIT_MODE_PSW|AD_RATE_DATA);
	}
	else{
		AD_WriteModeReg(bCh,BIT_MODE_POWERDOWN); 		//下电
	}


	ET1 = fBak;	

	return ulTmp;
}

unsigned char SetFullScale(unsigned char bCh,unsigned long ulDat)
{
	AD_WriteModeReg(0,0x500A);
	AD_WriteFullScaleReg(bCh,ulDat);
		
	return 0;
}

unsigned char MySetFullScale(unsigned char bCh,unsigned long ulDat)
{
	AD_WriteModeReg(0,0x500A);
	AD_WriteFullScaleReg(bCh,ulDat);
//wxg增加
	AD_WriteModeReg(bCh,BIT_MODE_CONTCONV|BIT_MODE_PSW|AD_RATE_DATA);	
	return 0;
}

unsigned char GetBalanceStatus(unsigned char bCh)
{
	unsigned int uTmp;
	unsigned char bTmp;

	uTmp = AD_ReadModeReg(bCh);

	bTmp = 0;
	if (uTmp&0x1000){
		bTmp |= 0x01;
	}
	uTmp = AD_ReadStatusReg(bCh);
	uTmp &= 0x60;
	uTmp >>= 4;
	bTmp |= uTmp;

	return bTmp;
}

unsigned char StartCharge(unsigned char bCh,unsigned long ulObj)
{
	if (sMyCont.sAd[bCh].fEnAd) {

		sMyCont.sAd[bCh].ulObjWeight = ulObj;
		sMyCont.sAd[bCh].fCharge = 1;
		sMyCont.sAd[bCh].fNewCharge = 1;
	}

	return 0;	
}

unsigned char StopCharge(unsigned char bCh)
{
	sMyCont.sAd[bCh].fCharge = 0;
	sMyCont.sAd[bCh].fNewCharge = 1;
	return 0;	
}