i.c

有关AD芯片AD7730的应用程序

#include "Board.h"
#include "Comm.h"
#include "AD7730.h" 
//======================================================
EPPFLAGS bEPPflags;
static unsigned char bMyNo=0;
COMM_CONTROL bCommControl;
unsigned char idata CommBuf[8];
unsigned char idata DisplayBuffer[16];

WEIGHT_TEMP bWEIGHT_TEMP;
//======================================================
void StartCommTimer(unsigned short iTime)
{
	
	TR1=0;
	TF1=0;
	TL1=iTime;
	TH1=iTime>>8;

	ET1=1;
	TR1=1;

	return;
}

void StopCommTimer(void)
{
	
	TR1=0;
	TF1=0;
	ET1=0;
	return;

}

void EntryTx(void)
{
	MCU_DE=1;
	REN=0;
	TI=0;
	return;
}

void EntryRx(void)
{
	MCU_DE=0;
	REN=1;
	RI=0;
	return;
}
//======================================================
//AD7730（外部中断0）中断处理
ad7730_isr() interrupt 0
{
	unsigned long lTemp;

	MCU_STATLED = 1;

	if (!MCU_ADI){


		if (bWEIGHT_TEMP.bTimes<AVERAVGETIMES) {

			lTemp=AD_ReadDataReg(0);

			if (bWEIGHT_TEMP.bTimes==0) {				//第一次
				bWEIGHT_TEMP.lMaxWeight = lTemp;			
				bWEIGHT_TEMP.lMinWeight = 0;			
				bWEIGHT_TEMP.lTempWeight= 0;
			}
			else if (bWEIGHT_TEMP.bTimes==1) {			//第二次

				if (lTemp>bWEIGHT_TEMP.lMaxWeight) {
					bWEIGHT_TEMP.lMinWeight = bWEIGHT_TEMP.lMaxWeight;			
					bWEIGHT_TEMP.lMaxWeight = lTemp;			
				}
				else {
					bWEIGHT_TEMP.lMinWeight = lTemp;			
				}

			}
			else {
				if (lTemp>bWEIGHT_TEMP.lMaxWeight) {
					bWEIGHT_TEMP.lTempWeight = bWEIGHT_TEMP.lTempWeight + bWEIGHT_TEMP.lMaxWeight;
					bWEIGHT_TEMP.lMaxWeight=lTemp;
				}
				else if(lTemp<bWEIGHT_TEMP.lMinWeight) {
					bWEIGHT_TEMP.lTempWeight = bWEIGHT_TEMP.lTempWeight + bWEIGHT_TEMP.lMinWeight;
					bWEIGHT_TEMP.lMinWeight=lTemp;
				}
				else {
					bWEIGHT_TEMP.lTempWeight = bWEIGHT_TEMP.lTempWeight + lTemp;
				}
			}

			bWEIGHT_TEMP.bTimes++;

		}
		else {

			bWEIGHT_TEMP.lNowWeight=bWEIGHT_TEMP.lTempWeight/(AVERAVGETIMES-2);

			bWEIGHT_TEMP.lTempWeight=0;
			bWEIGHT_TEMP.bTimes=0;

			bWEIGHT_TEMP.fNewWeight=1;
			
		}


	}
	
	MCU_STATLED = 0;

}

//定时器0中断处理#define Comm_OverTime_Long	-200*MAIN_CLOCK/12000
t0_isr() interrupt 1
{
}

//键盘中断（外部中断1）处理
key_isr() interrupt 2
{
	unsigned char u,bKo,bKey;

	KEYPORT = 0x0F;

	MCU_KEYI=1;

	bKey=0xFF;
	
	bKo=0xF7;

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

		bKo=(bKo<<1)|0x01;

		KEYPORT = (KEYPORT & 0x0F)|bKo;

		if (MCU_KEYI) {
			Delay(10);
			if (MCU_KEYI) {
				if (MCU_RI0==0) {
					bKey=u*4+0;
				}
				else if (MCU_RI1==0) {
					bKey=u*4+1;
				}
				else if (MCU_RI2==0) {
					bKey=u*4+2;
				}
				else  {
					bKey=u*4+3;
				}

				break;
			}
		}

		
	}

	if (u!=0xFF) {
		while(MCU_KEYI==0){
		};
		Delay(10);
		while(MCU_KEYI==0){
		};

	}
}

//定时器1中断处理
t1_isr() interrupt 3
{
	StopCommTimer();
	TF1=0;		//清除中断标志

	if ( (bEPPflags.bits.CommStat==Transmiting_HandShakeAck) ||
		 (bEPPflags.bits.CommStat==Transmiting_BagAck) ) {			//是否是发送延时定时

		SBUF = bCommControl.bAck;

	}
	else  {															//接收超时
		bEPPflags.bits.CommStat=Receiving_Handshake;

		RI=0;
		TI=0;

		SM2=1;		//进入多机通讯中断模式
		EntryRx();

	}


}

//串行口中断
comm_isr() interrupt 4
{
	unsigned char u,bTmp;

	if (RI){

		if ( bEPPflags.bits.CommStat==Receiving_Handshake ) {		//如果处于等待握手状态
			if ( (SBUF==0xFF) ||(SBUF==bMyNo) ) {
				SM2=0;			//禁止多机通讯
			
				if (SBUF==0xFF) { 
					bCommControl.bPointer=0;
					bEPPflags.bits.CommStat=Receiving_Bag;			//不进行握手应答，直接进入接收包状态
				
				}
				else if (SBUF==bMyNo) {
					bCommControl.bPointer=0;
					bEPPflags.bits.CommStat=Transmiting_HandShakeAck;//进入握手应答发送状态
	
					EntryTx();
					bCommControl.bAck=DLE;							//用DLE进行应答
					
				}
			}
			else {
				SM2=1;			//使能多机通讯，仍然呆在等待握手状态
			}

		}
		else if ( bEPPflags.bits.CommStat==Receiving_Bag ) { //如果处于等待包状态

			if ((SBUF==DLE && bEPPflags.bits.fHaveDLE) || (SBUF!=DLE && !bEPPflags.bits.fHaveDLE)) {
				
				bEPPflags.bits.fHaveDLE=FALSE;

				if (bCommControl.bPointer==0) {
					bCommControl.bSerial=SBUF;
				}
				else if (bCommControl.bPointer==1){
					bCommControl.bCommand=SBUF;
				}
				else if (bCommControl.bPointer==2){
					bCommControl.bLength=SBUF;
				}
				else if (bCommControl.bPointer>2 && bCommControl.bPointer<bCommControl.bLength+3){
					CommBuf[bCommControl.bPointer-3]=SBUF;
				}
				else {

					bEPPflags.bits.CommStat=Receiving_BagEnd_DLE;

					bTmp=bCommControl.bSerial ^ bCommControl.bCommand ^ bCommControl.bLength;
					
					if (bCommControl.bLength!=0) {
						for (u=0;u<bCommControl.bLength;u++) {
							bTmp=bTmp ^ CommBuf[u];
						}
					}

					if (bTmp!=SBUF) {
						bEPPflags.bits.CommCode=Bcc_Error;	//填写出错码为"接收校验错误"
					}

				}
				
				if (bEPPflags.bits.CommStat==Receiving_Bag) {
					bCommControl.bPointer++;
				}

			}
			else if ( (SBUF==DLE) && (!bEPPflags.bits.fHaveDLE) ){		//如果收到了DLE，且bEPPflags.bits.fHaveDLE=FALSE
				bEPPflags.bits.fHaveDLE=TRUE;
			}
			else {		//只剩下SBUF!=DLE且bEPPflags.bits.fHaveDLE一种可能
				bEPPflags.bits.CommStat=Receiving_BagEnd_DLE;
			}

		}
		else if ( bEPPflags.bits.CommStat==Receiving_BagEnd_DLE ) { //如果处于等待包尾的DLE的状态

			if (SBUF==DLE) {
				bEPPflags.bits.CommStat=Receiving_BagEnd_ETX;
			}
			else {
				bEPPflags.bits.CommCode=Receiving_BagEndDLE_Error;	//填写出错码为"接收包尾DLE错误"
			}

		}
		else if ( bEPPflags.bits.CommStat==Receiving_BagEnd_ETX ) { //如果处于等待包尾的ETX的状态

			bEPPflags.bits.CommStat=Transmiting_BagAck;				//下一个状态是进行包应答

			EntryTx();

			if ( (SBUF==ETX) && (bEPPflags.bits.CommCode==COMM_NO_ERROR) ) {
				bCommControl.bAck=DLE;
			}
			else {
				bCommControl.bAck=NAK;
			}
		}
		else if ( bEPPflags.bits.CommStat==Receiving_HandShakeAck ) { //如果处于等待对方对握手的应答

			bEPPflags.bits.CommStat=Transmiting_Bag;
			
			bCommControl.bPointer=0;

			MCU_DE=1;				//RS485发送使能
			TI=0;
			
			SBUF=bCommControl.bSerial;

		}
		else if ( bEPPflags.bits.CommStat==Receiving_BagAck ) { //如果处于等待对方对数据的应答

			SM2=1;			//禁止多机通讯
			EntryRx();
			bEPPflags.bits.CommStat=Receiving_Handshake;
		
		}

		RI=0;

	}
	else if (TI){				//发送完毕中断


		if (bEPPflags.bits.CommStat==Transmiting_HandShakeAck) {

			bEPPflags.bits.fHaveDLE=FALSE;
			bCommControl.bPointer=0;

			bEPPflags.bits.CommStat=Receiving_Bag;
			EntryRx();
		}

		else if(bEPPflags.bits.CommStat==Transmiting_BagAck) {		//发完了对对方命令的应答

			if (SBUF==DLE) {
				bEPPflags.bits.CommStat=Wait_Process;				//等待处理
			}
			else {
				bEPPflags.bits.CommStat=Receiving_Handshake;
				SM2=1;	
			}

			EntryRx();
		}

		else if(bEPPflags.bits.CommStat==Transmiting_Handshake) {

			bEPPflags.bits.CommStat=Receiving_HandShakeAck;
			EntryRx();
			
		}

		else if(bEPPflags.bits.CommStat==Transmiting_Bag) {

			if (SBUF==DLE) {
				SBUF=DLE;
			}
			else {


				if ( bCommControl.bPointer==0 ) {
					SBUF=bCommControl.bSerial;	
				}
				else if ( bCommControl.bPointer==1 ) {
					SBUF=bCommControl.bCommand;	
				}
				else if ( bCommControl.bPointer==2 ) {
					SBUF=bCommControl.bLength;	
				}
				else if ( (bCommControl.bPointer>2) && (bCommControl.bPointer<bCommControl.bLength+3) ) {
					SBUF=CommBuf[bCommControl.bPointer-2];	
				}
				else {

					bTmp=bCommControl.bSerial ^ bCommControl.bCommand ^ bCommControl.bLength;
					
					for (u=0;u<bCommControl.bPointer-3;u++) {
						bTmp=bTmp ^ CommBuf[u];
					}

					SBUF=bTmp;
					bEPPflags.bits.CommStat=Receiving_BagAck;
					MCU_DE=0;				//RS485接收使能
				}
		
				bCommControl.bPointer++;
		
			}
		}

		TI=0;

	}


	//下面根据情况设置并启动接收超时或者发送定时

	if( (bEPPflags.bits.CommStat==Receiving_Bag) && (bCommControl.bPointer==0) || 	//等待接收数据包的首字节
		(bEPPflags.bits.CommStat==Receiving_HandShakeAck) ||						//等待接收握手应答
		(bEPPflags.bits.CommStat==Receiving_BagAck) ) {								//等待接收对数据包的应答

		//这三种情况都涉及到主机从发到收的切换，因此接收超时较大
		StartCommTimer(COMM_OVT_LONG);
	}
	else if ( (bEPPflags.bits.CommStat==Receiving_Bag) && (bCommControl.bPointer!=0) ||
 			  (bEPPflags.bits.CommStat==Receiving_BagEnd_DLE) ||
			  (bEPPflags.bits.CommStat==Receiving_BagEnd_ETX) ) {//数据包的中间字节

		//由于主机不涉及从发到收的切换，这里只设置较小的接收超时
		StartCommTimer(COMM_OVT_SHORT);
	}
	else if ( (bEPPflags.bits.CommStat==Transmiting_HandShakeAck) ||
			  (bEPPflags.bits.CommStat==Transmiting_BagAck) ) {

		//由于采用RS485半双工通讯，所以开始发送之前要延时，以等待对方转入接收
		StartCommTimer(COMM_TX_DELAY);
	}
	else {																			//其它情况禁止接收定时
		StopCommTimer();
	}


}