driver.c

通过遥控红外信号在电器之间传输数据的软件

/*==========================================================================*/
/*
;     SOURCE_FILE:    Driver.C
;     APPLICATION:	  LPC9XX
;     COMPONENT:     ISR,IIC,IR
;     DATE:           16 May 2006
;
;     (C) 2006 : CHANGHONG FPD SOFTWARE Lab
       AUTHOR:       DJ
*/
/*==========================================================================*/

#define _DRIVER_C_
/* ======================================= */
// INCLUDE    
/* ======================================= */
#include <REG922.H>
#include <intrins.h>
#include "define.h"
#include "Driver.h"
#include "clone.h"
/* ======================================= */
//  STATIC VARIABLE DEFINE
/* ====================================== */
//i2c
static Bool  bSubAddrSended = FALSE;
static Bool  bIrSendTimer1Use = FALSE;   
static Bool  bIrOutPinChangeStandby = FALSE;
static Bool  bIrOutPinStatus = 0;

static I2C_MESSAGE DATA NvI2c;
//ir
static Byte  DATA    ucIrDetectStatus = 0;
static Byte  DATA    ucIrRecBitCount = 0;
static Byte  DATA    ucIrRecByte = 0;
static Byte  DATA    ucNeedRecByteNum = 0;
//static Byte  DATA    ucIrDetectTimer = 0;
//static Byte  DATA    ucDelay1msCount = 0;
static Byte  DATA    ucIrSendDelayType = 0;



/* ======================================= */
//MACRO DEFINE
/* ======================================= */

/* ======================================= */
//FUNCTION DEFINE
/* ======================================= */
//only use for creat IR 38K carrier wave
void ISR_Timer0(void) interrupt 1 using 1
{
   TF0 = 0;//clear the flag
   TR0 = 0;
   TL0 = LOWBYTE(ISR_TIME0_38K_RELOAD_VALUE);
   TH0 = HIGHBYTE(ISR_TIME0_38K_RELOAD_VALUE);
   TR0 = 1; 
   
   if((bIrOutPinStatus == 0) ||
   	(bIrOutPinChangeStandby == TRUE))
   {
       bIrOutPinChangeStandby = FALSE;
       PIN_IR_OUT = ~PIN_IR_OUT;
      	bIrOutPinStatus = ~bIrOutPinStatus;	  
   }
   else
   {
      bIrOutPinChangeStandby = TRUE;
   }
}

/* ======================================= */
//IR receive hander
void ISR_ExtInt1(void) interrupt 2 using 1
{
	Word  irTimer;
       IE1 = 0;//clear flag
//       irTimer = ucIrDetectTimer;
//	ucIrDetectTimer = 0;
	TR1 = 0;
       irTimer = (TH1<<8) + TL1;
	TL1 = 0;
	TH1 = 0;
       TR1 = 1;

       if(INT1)  return;      //get rid of debounce
	switch(ucIrDetectStatus)
	{
	case IR_STANDBY:
		  ucIrDetectStatus = IR_CHECK_LEADING;
		break;
	case IR_CHECK_LEADING:
		if(irTimer > (IR_LEADING_TIME - IR_LEADING_DIFF) &&
		    irTimer < (IR_LEADING_TIME + IR_LEADING_DIFF) )
		{
		     ucIrDetectStatus = IR_REC_DATA;
		     ucIrRecBitCount = 0;
		     ucNeedRecByteNum = 0;
		     ucIrRecByte = 0;
		}
		else
		{
		    ucIrDetectStatus = IR_STANDBY;
		}
		break;
	case IR_REC_DATA:
		  ucIrRecByte >>= 1;
               if(irTimer <= IR_LOGIC0_1_BORDER) 
               {
		   ;//ucIrRecByte &= ~BIT7;      // 0
               }
		 else 
		 {
		   ucIrRecByte |= BIT7;            // 1
		 }
//		 else
//		 {
//		     g_ucIRRecDataType = REC_ERROR;
//		     ucIrDetectStatus = IR_STANDBY;			   
//		 }
		 ucIrRecBitCount++;
		if((ucIrRecBitCount % 8) == 0)
	      {
		   irRecBuffer[(ucIrRecBitCount/8) - 1] = ucIrRecByte;
                 ucIrRecByte = 0;
		   if(ucIrRecBitCount == 16)//get first 2 bytes 
		   {
				if((irRecBuffer[0] == 0xAA) && (irRecBuffer[1] == 0x55))
				{
					g_ucIRRecDataType = REC_SEND_READY;
					g_bIRDetect = 1;
				}
				else if((irRecBuffer[0]== 0xAB) && (irRecBuffer[1] == 0x54))
				{
					g_ucIRRecDataType = REC_DATA_ADDRESS;
					ucNeedRecByteNum = 5;			
				}
				else if((irRecBuffer[0] == 0xAC) && (irRecBuffer[1] == 0x53))
				{
					g_bIRDetect = 1;			   
					g_ucIRRecDataType = REC_REC_READY;
				}
				else if((irRecBuffer[0] == 0xAD) && (irRecBuffer[1] == 0x52))
				{
					g_ucIRRecDataType = REC_N_BYTES;
				}
				else if((irRecBuffer[0] == 0xAE) && (irRecBuffer[1] == 0x51))
				{
					g_ucIRRecDataType = REC_16_BYTES;
					ucNeedRecByteNum = 19;
				}
				else
				{
				//g_ucIRRecDataType = REC_ERROR;		 //test	
					ucIrDetectStatus = IR_STANDBY;			    
				}
		 }
		else if((ucIrRecBitCount == 24) && ( g_ucIRRecDataType == REC_N_BYTES))
		{
			ucNeedRecByteNum  = irRecBuffer[2] + 4;
		}
		else if(ucIrRecBitCount == (ucNeedRecByteNum*8))
		{
			g_bIRDetect = 1;		   
		}
		if(g_bIRDetect)
		{
			ucIrDetectStatus = IR_STANDBY;
		}

          }
		break;

		default:
		break;	
	}
	//20060616>>>confirm
	 EX1 = 1;
	 IT1 =  1;
	 //20060616<<<
}
/* ======================================= */

void ISR_Timer1(void) interrupt 3 using 2
{
	TF1 = 0; //Clear Flag

	if(ucIrSendDelayType != DELAY_FINISH)
	{
	    ucIrSendDelayType = DELAY_FINISH;
	}
	
      if(ucIrDetectStatus != IR_STANDBY)
      {
	  ucIrDetectStatus = IR_STANDBY;
	   TR1 = 0;
      }
}

/* ======================================= */
void ISR_I2c(void) interrupt 6 using 1
{
   switch(I2STAT)
   {
    case 0x08://A START condition has been transmitted
	I2DAT = NV_DEVICE_ADDR;//for nv ,first start must write device address with write
	STA = 0;
	break;

    case 0x10://A repeated START condition has been transmitted
	 if(NvI2c.Direction == NV_WRITE)
	      I2DAT = NV_DEVICE_ADDR;
	 else
	      I2DAT = NV_DEVICE_ADDR + 1;

	STA = 0;	 	
      break;
//master transmit	
    case 0x18://SLA+W has been transmitted;ACK has been received
      	I2DAT = HIGHBYTE(g_wCloneNVAddress);
	NvI2c.RetryCount = 0;
	break;
    case 0x20://SLA+W has been transmitted; NOT-ACK has been received
       if(NvI2c.RetryCount > 3)
       {
         NvI2c.RetryCount = 0;
         STO = 1;		 
	  g_bI2cError = 1;
       }
	else
	{
	   STO = 1;
	   STA = 1;
	   NvI2c.RetryCount++;
	}
	break;
	
    case 0x28://Data byte in I2DAT has been transmitted; ACK has been received
      if(bSubAddrSended)
	 {
	   if(NvI2c.Direction== NV_WRITE)  //write
	   {
		if(NvI2c.DataNum--)
		{
		 I2DAT = *(NvI2c.pbuffer++);
		 NvI2c.RetryCount = 0;
		}
		else
		{
		  STO = 1;
		  g_bI2cOk = TRUE;
		}
	   }
	   else                   //read
	   { 
	      STA = 1;     //repeated start
	      NvI2c.RetryCount = 0;
	   }
	}
	else
	{
	   I2DAT = LOWBYTE(g_wCloneNVAddress);
	   bSubAddrSended = TRUE;
	}  

	break;
    case 0x30://Data byte in I2DAT has been transmitted, NOT ACK has been received
      if(NvI2c.RetryCount > 3)
      	{
      	   NvI2c.RetryCount = 0;
      	   STO = 1;
	   g_bI2cError = TRUE;
      	}
	else
	{
		I2DAT = *(NvI2c.pbuffer - 1);
	       NvI2c.RetryCount++;
	}  
	break;
    case 0x38://Arbitration lost in SLA+R/W or data bytes
      STA = 0;
      g_bI2cError = TRUE;
	break;

//master receiver
	
    case 0x40://SLA+R has been transmitted; ACK has been received
      STA = 0;
      AA   = 1;
     NvI2c.RetryCount = 0;
	break;
	
    case 0x48://SLA+R has been transmitted; NOT ACK has been received
      if(NvI2c.RetryCount > 3)
    	{  
    	NvI2c.RetryCount = 0;
       STA = 0;
	STO = 1;
	g_bI2cError = TRUE;
    	}
	else
	{
	 STA = 1;
	 NvI2c.RetryCount++;
	}
	
	break;
	
    case 0x50://Data byte has been received; ACK has been returned
    	*(NvI2c.pbuffer) =  I2DAT;
	  NvI2c.pbuffer++;
	  NvI2c.DataNum--;
       if(NvI2c.DataNum <= 1)   AA = 0;
	else   AA = 1;

		
	break;
	
    case 0x58://Data byte has been received; NACK has been returned
      *(NvI2c.pbuffer) = I2DAT;
	 STO = 1;
	 g_bI2cOk = TRUE;
	break; 
	
	default:
	 STA = 0;
	 STO = 1;
	 g_bI2cError = TRUE;
	break;	
   }
      SI = 0;

}
/* ======================================= */
void ISR_KBI(void)  interrupt 7 using 1
{