⭐ 欢迎来到虫虫下载站！ | 📦 资源下载 📁 资源专辑 ℹ️ 关于我们
⭐ 虫虫下载站
📤 上传资源

📄 target.cpp

📁 采用LPC的芯片做的气体排放检测,包括气体成分分析,数据的处理,数据传输给工作站.
💻 CPP
📖 第 1 页 / 共 2 页
字号:
🔍
12 
#define IN_TARGET
#include "config.h"
extern U8	Data373_2;
extern	U8	g_ucBaudRate;
extern	U8		g_ucProtocol;
extern  U16 U16_o2updata[20];
extern  U16 U16_o2downdata[20];
volatile unsigned int	SysTime;
REG32 Timer_count;
unsigned int	StartTime;
volatile unsigned int	UART0RxdCount;
volatile unsigned int	UART1RxdCount;
volatile unsigned int	UART2RxdCount;
volatile unsigned int	UART3RxdCount;

//volatile unsigned char UART0_RxdBuf[UART0_MAX_LENGTH];
//volatile unsigned char UART1_RxdBuf[UART1_MAX_LENGTH];
//volatile unsigned char UART2_RxdBuf[UART2_MAX_LENGTH];
U8	TimeBuf[8];
U32	bPumpCtrl;
//	variable for key
REG32	key_Current;
REG32	key_Last;


REG8	key_Stat;
REG8	key_Continue;
REG8	key_Value;	
REG8	key_Reserved;
U32 Timer1_count=0;
U8 O2_Blage;
//U8 O2_Timer[64];
U16 O2_count;
//extern	unsigned char		g_ucMachineAddr;
#define 	CPU_Idle(); 
void memset(unsigned char* Buf,unsigned char ucData,unsigned int nLen)
{
	unsigned int ni;
	for(ni=0;ni<nLen;ni++)
		Buf[ni]=ucData;
}
void memcpy(unsigned char* destBuf,unsigned char* srcBuf,unsigned int nLen)
{
	unsigned int ni;
	for(ni=0;ni<nLen;ni++)
		destBuf[ni]=srcBuf[ni];
}
/*********************************************************************************************************
** 函数名称: IRQ_UART0_RecServ(void)	与上位机通讯
** 功能描述: UART0中断处理程序，将收到数据放到全局缓冲区，缓冲区指针加1，
**			 先清零g_ucRecFlag，前台程序空闲就查询g_ucRecFlag。为 1 时，延时100ms，
**			 再清零g_ucRecFlag 和缓冲区指针，就可以进行 PCCmd 处理。
********************************************************************************************************/

REG32 US0r_r, US0r_w, US0t_r, US0t_w;
REG8 US0_rbuf[US0RBUF_LEN], US0_tbuf[US0TBUF_LEN];
__irq void US0_interrupt(void)			// UART0中断处理程序
{
	U8 stat,i;
	U32 tmp;
	while(!((stat=U0IIR)&0x01)){			// 有中断需要处理(最低位为0)
		switch(stat&0x0e){
		case 0x02:	// TX FIFO空
			for(i=0; i<8; i++){				// 每次最多发送8个字节
				tmp=(US0t_r+1)&(US0TBUF_LEN-1);	// 处理缓冲区回绕
				if(tmp!=US0t_w){
					US0t_r=tmp;
					U0THR=US0_tbuf[tmp];
				}else
					break;
			}
			break;
		case 0x04:	// 输入数据有效
		case 0x0c:	// 输入超时
			do{
				tmp=U0RBR;
				if(US0r_r!=US0r_w){			// 缓冲区未满
					US0_rbuf[US0r_w++]=tmp;
					US0r_w&=(US0RBUF_LEN-1);// 缓冲区回绕
					UART0RxdCount++;
				}
			}while(U0LSR&0x01);
			break;
		case 0x06:	// 接收线状态错误
			tmp=U0LSR;							// 不处理线错误状态
			break;
		}
	}
	VICVectAddr = 0;							// 中断处理结束
}

int US0_getchar(void)						// 从UART0输入缓冲区读数据,空则返回-1
{
	U32 tmp;
	tmp=(US0r_r+1)&(US0RBUF_LEN-1);
	if(tmp!=US0r_w){
		US0r_r=tmp;
		return US0_rbuf[tmp];
	}else
		return -1;
}

void US0_putchar(U8 ch)						// 向UART0输出缓冲区写数据,若满则等待
{
	while(US0t_r==US0t_w);					// 发送缓冲区满则等待
	VICIntEnClr=VIC_SELECT_UART0;			// 禁止UART0中断
	US0_tbuf[US0t_w++]=ch;
	US0t_w&=(US0TBUF_LEN-1);				// 缓冲区回绕
	if(U0LSR&0x40){							// 发送FIFO空
		US0t_r=(US0t_r+1)&(US0TBUF_LEN-1);	// 处理缓冲区回绕
		U0THR=US0_tbuf[US0t_r];				// 直接发送
	}
	VICIntEnable|=VIC_SELECT_UART0;		// 允许UART0中断
}
/*********************************************************************************************************
** 函数名称: IRQ_UART1_RecServ(void)	与仪器通讯
** 功能描述: UART1中断处理程序，将收到数据放到全局缓冲区，缓冲区指针加1，
**			总是主动的。知道大约什么时候有数据到达。	所以只在这段时间开中断，流程如下：
**			1. 发送命令给仪器，
**			2. 开 UART1 中断，根据不同的命令做不同的延时，
**			2. 关 UART1 中断，就可以进行  处理。
********************************************************************************************************/
REG32 US1r_r, US1r_w, US1t_r, US1t_w;
REG8 US1_rbuf[US1RBUF_LEN], US1_tbuf[US1TBUF_LEN];
__irq void US1_interrupt(void)			// UART1中断处理程序
{
	U8 stat,i;
	U32 tmp;
	while(!((stat=U1IIR)&0x01)){			// 有中断需要处理(最低位为0)
		switch(stat&0x0e){
		case 0x02:	// TX FIFO空
			for(i=0; i<8; i++){				// 每次最多发送8个字节
				tmp=(US1t_r+1)&(US1TBUF_LEN-1);	// 处理缓冲区回绕
				if(tmp!=US1t_w){
					US1t_r=tmp;
					U1THR=US1_tbuf[tmp];
				}else
					break;
			}
			break;
		case 0x04:	// 输入数据有效
		case 0x0c:	// 输入超时
			do{
				tmp=U1RBR;
				if(US1r_r!=US1r_w){			// 缓冲区未满
					US1_rbuf[US1r_w++]=tmp;
					US1r_w&=(US1RBUF_LEN-1);// 缓冲区回绕
					UART1RxdCount++;
				}
			}while(U1LSR&0x01);
			break;
		case 0x06:	// 接收线状态错误
			tmp=U1LSR;							// 不处理线错误状态
			break;
		}
	}
	VICVectAddr = 0;							// 中断处理结束
}
int US1_getchar(void)						// 从UART1输入缓冲区读数据,空则返回-1
{
	U32 tmp;
	tmp=(US1r_r+1)&(US1RBUF_LEN-1);
	if(tmp!=US1r_w){
		US1r_r=tmp;
		return US1_rbuf[tmp];
	}else
		return -1;
}

void US1_putchar(U8 ch)						// 向UART1输出缓冲区写数据,若满则等待
{
	while(US1t_r==US1t_w);					// 发送缓冲区满则等待
	VICIntEnClr=VIC_SELECT_UART1;			// 禁止UART1中断
	US1_tbuf[US1t_w++]=ch;
	US1t_w&=(US1TBUF_LEN-1);				// 缓冲区回绕
	if(U1LSR&0x40){							// 发送FIFO空
		US1t_r=(US1t_r+1)&(US1TBUF_LEN-1);	// 处理缓冲区回绕
		U1THR=US1_tbuf[US1t_r];				// 直接发送
	}
	VICIntEnable|=VIC_SELECT_UART1;		// 允许UART1中断
}
void	HappyLED(void)
{
	Data373_2 ^= 0x10;
	Write373_2
	(Data373_2);
}
extern U8 TimeBuf[8];
void	 Timer0_Handler(void)
{    
	if(++Timer_count==29)// 1ms(57.6)
	{		 				
		Timer_count=0;
		SysTime++;
		if(SysTime%1000 == 0)
		{
				TimeBuf[0]++;
				if(TimeBuf[0]>=60)
				{//秒
					TimeBuf[0]=0;
					TimeBuf[1]++;
					if(TimeBuf[1]>=60)
					{//分
						TimeBuf[1]=0;
						TimeBuf[2]++;	
						if(TimeBuf[2]>23)	TimeBuf[2]=0;		
					}
				}			
		}
		if(SysTime%10 == 0){
			if(bPumpCtrl){
				;//bPumpCtrl = 0;
	//		IOSET0 = PUMP_DRIVE_PIN;
			}else{
				;//bPumpCtrl = 1;
//				IOCLR0 = PUMP_DRIVE_PIN;			
			}
		}		
    }
	T0IR = 0x01;	    		// 清除中断标志// 不需要通知VIC中断处理结束				            
//	VICVectAddr = 0;	// 通知VIC中断处理结束
}

__irq void timer1_interrupt(void)
{
   U8 i,j,k,l;
   static U8 m;
   static U8 n;
   IODIR0|=1<<12;
   if(O2_Blage==0)//
   {    
       if(Timer1_count++>=60000)// 延时15秒
       {
                
     	 	    IOCLR0|=(1<<14);
           	    IOCLR0|=(1<<15);
           	    IOSET0|=(1<<17);
           	    IOCLR0|=(1<<18);
      		    O2_Blage=3;//预热结束标志
      		    Timer1_count=0;
     		    //Timer1_count=0;
     		    //O2_count=0;
        }
  }  				
   else
   {  	
       if(O2_Blage==3)
        { 
         
         // if(Timer1_count++>=120)
          //{
           Timer1_count++;
           if((IOPIN0&(1<<16))==0)
           {
                 //US3_putchar(Timer1_count);
              
                 /*i=(U8)((Timer1_count%10)+'0');
                 j=(U8)((Timer1_count/10)%10+'0');
                 k=(U8)((Timer1_count/100)+'0');
                 l=' ';
                 US0_putchar(k);
                 US0_putchar(j);
                 US0_putchar(i);
                 US0_putchar(l);
                 US0_putchar(l);*/
                 if(m>19){m=0;}
                 U16_o2updata[m]=(U16)Timer1_count;
                 m++;
           		 IOSET0|=(1<<14);
           		 IOSET0|=(1<<15);
           		 IOCLR0|=(1<<17);
           		 IOSET0|=(1<<18);
           		 O2_Blage=5;
           		 Timer1_count=0;
           		 
          }		 
           		 //O2_Timer[O2_count]=Timer1_count;
           		 //O2_count++;
           		 //Timer1_count=0;
          //}	
        }
       //if(O2_Blage==5)
        
        	//if(Timer1_count++>=80)
        	//{
           else if (O2_Blage==5)
           
           {
           Timer1_count++;
           if((IOPIN0&(1<<16))!=0)
            { 
                     
           		//if(O2_count<=63)
           		//{
           		
           		   
                 /*i=(U8)((Timer1_count%10)+'0');
                 j=(U8)((Timer1_count/10)%10+'0');
                 k=(U8)((Timer1_count/100)+'0');
                 l=' ';
                 US0_putchar(k);
                 US0_putchar(j);
                 US0_putchar(i);
                 US0_putchar(l);
                 US0_putchar(l);*/
                     if(n>19){n=0;}
                     U16_o2downdata[n]=(U16)Timer1_count;
                     n++;
           		     IOCLR0|=(1<<14);
            		 IOCLR0|=(1<<15);
           			 IOSET0|=(1<<17);
           			 IOCLR0|=(1<<18);
           			 O2_Blage=3;
           			 Timer1_count=0;
           			 
           	}
           	}		 
           			 //O2_Timer[O2_count]=Timer1_count;
           		     //O2_count++;
           		    // Timer1_count=0;
                // }
                // else 
               // {
               // O2_Blage=0;
               // O2_Blage|=1|(1<<3);
               // }
           //}
                
       
   }     
       
     
T1IR = 0x01;//中断返回//清除中断标志位
VICVectAddr = 0;
}
unsigned int GetSysTimeTick(void)//__inline
{
	return SysTime;
}
void	ResetClock(void)
{
	StartTime = GetSysTimeTick();
}
unsigned int	IsTimeOut(unsigned int nDelayTime)
{
	if((SysTime - StartTime) >= nDelayTime)		return 1;
	else	return 0;
}
void Sleep(unsigned int	nDelayTime)
{//功能：以毫秒为单位，延时
	unsigned int nStartTime,i;
	nStartTime = SysTime;
	for(;;)
	{
		if((SysTime-nStartTime) >= nDelayTime) break;
		for(i=0;i<100;i++);
		CPU_Idle();
	}		
}
/*=====================================**
**
**
**=====================================*/

REG8  US2_rbuf[US2RBUF_LEN], US2_tbuf[US2TBUF_LEN];
REG32 US2r_r, US2r_w, US2t_r, US2t_w;
REG32 US2r_stat, US2r_byte, US2r_count, US2t_stat, US2t_byte, US2t_count, US2_div, US2_tmp, US2_enable;
/*
extern void Set_US2_TX(void);
extern void Clr_US2_TX(void);
extern U32  Tst_US2_RX(void);*/
#define		Set_US2_TX()	(IOSET = TXD2)
#define		Clr_US2_TX()	(IOCLR = TXD2)
#define		Tst_US2_RX()	(IOPIN0&RXD2)
void US2_interrupt(void)					// UART2软件串口中断处理程序(17.361us)
{
	U32 tmp;
	if(US2_enable&&(--US2_tmp==0)){
		US2_tmp=US2_div;
		if(US2r_stat==0){						// US2输入处理,空闲状态
			if(Tst_US2_RX()==0){				// 输入低电平
				US2r_count=4;					// 第一次延时1.3T
				US2r_stat=1;
				US2r_byte=0;
			}
		}else if(US2r_stat<9){				// 8位数据位
			if(--US2r_count==0){
				US2r_byte>>=1;
				if(Tst_US2_RX())
					US2r_byte|=0x100;
				US2r_count=3;					// 以后每次延时1T
				US2r_stat++;
			}
		}else if(US2r_stat==9){				// 1位停止位
			if(--US2r_count==0){
				if(Tst_US2_RX()){				// 停止位有效
					US2r_stat=0;				// 重新允许接收
					if(US2r_r!=US2r_w){		// 缓冲区未满
						US2_rbuf[US2r_w]=(US2r_byte>>1);
					    UART2RxdCount++;
						//if(UART2RxdCount<UART2_MAX_LENGTH)	UART2_RxdBuf[UART2RxdCount++]=US2_rbuf[US2r_w];
						US2r_w++; 
						if(US2r_w>=US2RBUF_LEN)	// 缓冲区回绕
							US2r_w=0;
					}
				}else
					US2r_stat=10;
			}
		}else
//			if(TST_US2_RX)						// 若停止位无效则必须等待高电平才能开始下一个字节的接收
			if(Tst_US2_RX())					// 若停止位无效则必须等待高电平才能开始下一个字节的接收
				US2r_stat=0;
		if(US2t_stat==0){						// US2输出处理,空闲状态
			tmp=US2t_r+1;
			if(tmp>=US2TBUF_LEN)
				tmp=0;
			if(tmp!=US2t_w){
				US2t_r=tmp;
				US2t_byte=(US2_tbuf[tmp]|0x100);		// 停止位为1
				US2t_stat=1;
				US2t_count=3;
				Clr_US2_TX();
//				CLR_US2_TX;						// 开始位为0
			}
		}else if(US2t_stat<10){				// 加上停止位共9位数据
			if(--US2t_count==0){
				if(US2t_byte&1)
12

⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -