ir.c

来自「CS8955控制TV软件。用MCU做模拟电视的控制。」· C语言 代码 · 共 239 行

/******************************************************************************\
     Project Version:   MTKCARDVD()
********************************************************************************
     Filename:          ir.c

     Author:            Bonson chen

     Company:           CoreTek/ACT Company

********************************************************************************
     File Version:      1.01
     File Created:      July 2007

     Compiled Using:    keil uVision2 Version 2.23 

********************************************************************************
     Files Required:

********************************************************************************
     File Description:

********************************************************************************
     File History:

--------------------------------------------------------------------------------
  Date         Name           Description
--------------------------------------------------------------------------------
  Mar. 2007    bonson chen    File Created
  
\******************************************************************************/
#define _IR_RECV_C_

#pragma NOAREGS
#include "Global.h"
#include "key.h"

#include "irkey.h"

// static variables

// *********************************************************************
// Function : void vIrInit(void)
// Description : Called when system initial, to reset IR and UI
// Parameter : None
// Return    : None
// *********************************************************************
void vInitIRVar(void) 
{
  // reset IR related variable
  _bIR0 = IR_NONE;
  _fgIRKeyValid = FALSE;
  _bPlaypostKey = IR_NONE;
  _bIRKey0 = IR_NONE;
  _bIRLongPush = IR_NONE;
  LongPushCount = 0;
  _bRemoteTimer = 0;
}

#define IR_OVERFLOW            250  /* 38 ms */
#define IR_LEAD_CENTER         23   /* 3.37 ms */
#define IR_REPEAT_CENTER       14   /* 2.25 ms */
#define IR_DATA_CENTER         8    /* 1.21 ms */

#define IR_LEADH_MAX           93
#define IR_LEADH_MIN           80	//measure is 83	//87
#define IR_LEADL_MAX           48
#define IR_LEADL_MIN           38 //35	//measure is 40	//40
#define IR_DATA1_MAX           20
#define IR_DATA1_MIN            9
#define IR_DATA0_MAX            6
#define IR_DATA0_MIN            2
#define IR_REPEAT_MIN          15//measure is 18		//19
#define IR_REPEAT_MAX          24
#define IR_PULSE_MAX            7
#define IR_PULSE_MIN            4

#define IR_HEAD_TIMER			13500
#define IR_CONHEAD_TIMER        11250
#define IR_HEAD_MISTAKE			400
#define IR_DIGITAL1_TIMER		2250
#define IR_DIGITAL0_TIMER       1125
#define IR_DIGITAL_MISTAKE      200
void vDelay100us(void)
{
  
  BYTE c;

      for (c=0;c<28;c++)
     {
        _nop_();_nop_();_nop_();_nop_();
        _nop_();_nop_();_nop_();_nop_();
        _nop_();_nop_();
        _nop_();_nop_();_nop_();_nop_();
        
      }
}

/************************************************************************
     Function : 
  Description : 
    Parameter : 
    Return    : 
************************************************************************/
BYTE bRemoteDetect(void)
{
  BYTE bCount, i, j;
  BYTE bCodes[4];
  BYTE bByte;

	// ********** Leader signal (low 9ms + high 4.5 ms) **********
  for (bCount=0; (!PIN_IR); bCount++) vDelay100us();		   //Leader signal low = 9ms

  if ((bCount < IR_LEADH_MIN) || (bCount > IR_LEADH_MAX))
  {
     return(IR_NONE);
  }

  for (bCount = 0; ((PIN_IR) && (bCount < (IR_LEADL_MAX+10))); bCount++) vDelay100us();   //Leader signal high = 4.5ms

  if ((bCount < IR_LEADL_MIN) || (bCount > IR_LEADL_MAX)) // outside high 4.5 range
  { // consider same key is pressed
    // if input the same key, only leader code is sent
    //  low (9ms) , high (2.25), low (0.56)
//   if ((bCount >= IR_REPEAT_MIN) && (bCount <= IR_REPEAT_MAX))   // key remain pressed
    {
  	  for (bCount=0; !PIN_IR ; bCount++) vDelay100us();
    }

    for (bCount=0; (PIN_IR) && (bCount < (IR_DATA1_MAX+20)) ; bCount++) vDelay100us();

//    if ((bCount >= IR_PULSE_MIN) && (bCount <= IR_PULSE_MAX))
    if (bCount >= (IR_DATA1_MAX+10))
    {
   			//gotoxy(1,1);
		//	PrintHex(bCount,1);	
      _bRemoteTimer = 5;
      if ((++LongPushCount)>=5)
      {
          LongPushCount = 0;
          _bRemoteTimer = 0;
          return(IR_LONGPUSH); // return the previous input key
      }   
    }
    else
        LongPushCount = 0;

    return(IR_NONE);
  } 

    LongPushCount = 0;

  // *********** Read Code *************
	// logic 0 = low (0.56) + high (0.56)
	// logic 1=  low (0.56) + high (1.68)
  for (i=0; i<4; i++)
  {
  	bByte = 0;
  	for (j=0; j<8; j++)
       {
	    for (bCount=0; (!PIN_IR); bCount++) vDelay100us(); //bypass low signal at INT0

	    for (bCount=0; (PIN_IR) && (bCount < (IR_DATA1_MAX+10)) ; bCount++) vDelay100us();

	    if (bCount == 0)
           {
     		j--;
       	continue;     // maybe signal noise
           }

           bByte >>= 1;	  // shift right one bit

           if (bCount >= IR_DATA1_MIN)	 // bit=0 => bCount<9ms; bit=1 => bCount>9ms
           {			//  > 0.9 ms==> logic 1
		      //     else ==> logic 0
    	         if (bCount >= IR_DATA1_MAX)
                {
                     return(IR_NONE);         // bCount>30 => error
                }
                bByte |= 0x80;
          }
    }
    bCodes[i] = bByte;
  }

  if ((bCodes[0] != IR_CUSTOM_CODE) || (bCodes[1] != ~bCodes[0]))
  {
    return(IR_NONE);                // system code error
  }

  // each bit of aCodes[2] will be invert of aCodes[3]
  if (bCodes[2] == ~bCodes[3])
  {
      _bIR0 = bCodes[2];
      if (bCodes[2] >= IR_KEY_GAP_START)
      {
          bCodes[2] -= IR_KEY_GAP_SIZE;
      }

      if (bCodes[2] < IR_KEY_TBL_SIZE)
      {
          {
              /* look up the mapping table */
              bCodes[2] = _pbIRKeyTbl[bCodes[2]];
          }

          /* put the received key */
          if (bCodes[2] != IR_NONE)
          {
              // long push key
              if (IsLongPushKey(bCodes[2]))
              {
                   _bRemoteTimer = 5;
              }
              /* assume IR interrupt priority is the highest */
             return(bCodes[2]);
          }
      }
  }

  return(IR_NONE);
}


BYTE bGetIR0(BYTE bKey)
{
BYTE i;
for(i = 0; i< (IR_KEY_CODE_MAX-IR_KEY_GAP_SIZE); i++)
	{
	 if(bKey ==_pbIRKeyTbl[i])
	 	{
	 	if(i < IR_KEY_GAP_START)
			return i;
		else
			return(i + IR_KEY_GAP_SIZE);
	 	}
	}
return(IR_NONE);
}