Need Help about C program of RC5.

#include <12F629.h>

#FUSES NOWDT //No Watch Dog Timer
#FUSES INTRC_IO //Internal RC Osc, no CLKOUT
#FUSES NOCPD //No EE protection
#FUSES NOPROTECT //Code not protected from reading
#FUSES NOMCLR //Master Clear pin used for I/O
#FUSES PUT //Power Up Timer
#FUSES NOBROWNOUT //No brownout reset

#use delay(clock=4000000)
#use rs232(baud=9600,parity=N,xmit=PIN_A0,rcv=PIN_A1,bits=8)

typedef unsigned int8 U8;
typedef unsigned int16 U16;
typedef int1 BIT;
#define VOID void

#pragma use fast_io (A)

#pragma byte GPIO = 0x05
#pragma byte TMR0 = 0x01
#pragma byte INTCON = 0x0B
#pragma byte PIR1 = 0x0C
#pragma bit TMR1F = PIR1.0
#pragma byte IOC = 0x96

#pragma bit IR_IOC = IOC.2
#pragma bit IR_PIN = GPIO.2
#pragma bit IR_INT = INTCON.0
#define IR_TIME TMR0

#define enable_INT_IR() IR_IOC = 1
#define clr_INT_IR() IR_PIN = 1; IR_INT = 0
#define is_INT_IR() (IR_INT != 0)

#define is_SIGNAL_IR() (IR_PIN==0)
#define is_IDLE_IR() (IR_PIN==1)
#define set_TIME_IR(tm) IR_TIME=tm
#define get_TIME_IR() IR_TIME
#define nIRtimeBase 32 // 32uS
#define nIRtolerance 30 // +/- 30%
#define defIRtime 889 // 889uS RC-5/RC-5X 1 physical (half logic) bit time
#define minIRtime ((((((100-nIRtolerance)*defIRtime)*10)/(nIRtimeBase*100))+5)/10)
#define maxIRtime ((((((100+nIRtolerance)*defIRtime)*10)/(nIRtimeBase*100))+5)/10)

U8 gIRstat; // IR state number
enum { stIR_NONE=0, stIR_IDLE, stIR_SIGNAL };
U16 gIRdata; // IR data (14 logic bits)
#define add_Data_0_IR() gIRdata <<= 1
#define add_Data_1_IR() gIRdata <<= 1; gIRdata |= 1
U8 gIRcount; // IR bit counter
#define nIRcount (14*2) // 14 logic bits = 28 physical bits
//-U8 gIRruntime; // IR running time (counting only if gIRstat != stIR_NONE)
#define nIRruntime 30000 // 25mS: 14*(889+889)=24.892mS
//#define timeout_RUNTIME_IR() (get_timer1() > nIRruntime)
#define timeout_RUNTIME_IR() (TMR1F != 0)
#define set_RUNTIME_IR(tm) set_timer1(65536UL-(tm)); TMR1F = 0
BIT bIRphysicalBitCount; // 0:1st physical bit, 1:2nd physical bit
BIT bIRphysicalBitData; // last physical bit data
BIT bIRnewHit; // 1:new IR code is received

VOID InitIR( VOID ) // initial IR engine
{
gIRstat = stIR_NONE;
bIRnewHit = FALSE;
// hardware dependent: set correct snapped interrupt edge setting
enable_INT_IR();
clr_INT_IR();
}

VOID TimeoutIR( VOID ) // check IR running timeout
{
if( gIRstat != stIR_NONE) {
if( timeout_RUNTIME_IR() ) { // timeout
InitIR();
}
}
}

VOID PollIR( VOID ) // put it in ISR (trigger when IR_PIN edge is changed)
{
U8 mIRtime;

mIRtime = get_TIME_IR(); set_TIME_IR(0);
switch( gIRstat ) {
case stIR_NONE:
if( is_SIGNAL_IR() ) { // 1st logic bit (start bit) is 1 (01)
// IR engine is starting
gIRstat++; // gIRstat = stIR_IDLE;
//----------- gIRruntime = 0; // IR running time is counting
set_RUNTIME_IR(nIRruntime); // IR running time is counting
gIRdata = 0; // it is not necessary if mask unused bits before using it
gIRcount = 1; // as hit 1st physical bit
bIRphysicalBitCount = 1; // ready to process 2nd physical bit
return;
}
return;
case stIR_IDLE: // now is IR.IDLE signal (process last SIGNAL)
if( mIRtime > 2*maxIRtime ) { // time > 2t
goto _error_IDLE_PollIR; // last signal too long
}
if( mIRtime < 1*minIRtime ) { // time < 1t
goto _error_IDLE_PollIR; // last signal too short
}
bIRphysicalBitData = 0; // now is IDLE
if( bIRphysicalBitCount == 0 ) { // now is 1st physical bit (1x)
if( mIRtime > 2*minIRtime ) { // time > 2t
goto _error_IDLE_PollIR; // bad code, bi-phase no this (11) combination
}
bIRphysicalBitCount = 1; // ready to process 2nd physical bit
} else { // now is 2nd physical bit (01)
add_Data_1_IR(); // add logic bit data 1 (01)
if( mIRtime < 2*minIRtime ) { // time < 2t
bIRphysicalBitCount = 0; // ready to process 1st physical bit
} else { // time >= 2t, it is 011 (extra physical bit)
gIRcount++; // add extra physical bit count
bIRphysicalBitCount = 1; // ready to process 2nd physical bit
}
}
break;
case stIR_SIGNAL: // now is IR.SIGNAL signal (process last IDLE)
if( mIRtime > 2*maxIRtime ) { // time > 2t
goto _error_SIGNAL_PollIR; // last signal too long
}
if( mIRtime < 1*minIRtime ) { // time < 1t
goto _error_SIGNAL_PollIR; // last signal too short
}
bIRphysicalBitData = 1; // now is SIGNAL
if( bIRphysicalBitCount == 0 ) { // now is 1st physical bit (0x)
if( mIRtime > 2*minIRtime ) { // time > 2t
goto _error_SIGNAL_PollIR; // bad code, bi-phase no this (00) combination
}
bIRphysicalBitCount = 1; // ready to process 2nd physical bit
} else { // now is 2nd physical bit (10)
add_Data_0_IR(); // add logic bit data 0 (10)
if( mIRtime < 2*minIRtime ) { // time < 2t
bIRphysicalBitCount = 0; // ready to process 1st physical bit
} else { // time >= 2t, it is 100 (extra physical bit)
gIRcount++; // add extra physical bit count
bIRphysicalBitCount = 1; // ready to process 2nd physical bit
}
}
break;
}

// ready to process next physical bit
gIRcount++;
if( gIRcount >= nIRcount ) { // the last physical bit
goto _complete_check_PollIR;
}
if( gIRcount == nIRcount-1 ) { // the 27th physical bit
if( bIRphysicalBitData == 0 ) { // now is 0 as complete, due to no more new edge will be changed
bIRphysicalBitCount = 0; // as ready to process 1st physical bit
add_Data_0_IR(); // add logic bit data 0 (10)
goto _complete_check_PollIR;
}
}
// the 1~27th physical bit
gIRstat = bIRphysicalBitData == 0 ? stIR_SIGNAL : stIR_IDLE; // swap state
// hardware dependent: toggle snapped interrupt edge setting
//-clr_INT_IR();
return;

_complete_check_PollIR:
if( bIRphysicalBitCount == 0 ) { // correct, no any pending physical bit
InitIR();
// ex: check Start Bit, process Toggle(Repeat) Bit, translate Address/Command Bits....
bIRnewHit = TRUE;
return;
}
_error_IDLE_PollIR:
_error_SIGNAL_PollIR:
InitIR();
return;
}

void main()
{
port_a_pullups(0xFF);
setup_timer_0(RTCC_INTERNAL|RTCC_DIV_32);
setup_timer_1(T1_INTERNAL|T1_DIV_BY_1);

// TODO: USER CODE!!
printf( "IR\n" );
InitIR();
while(TRUE) {
if( is_INT_IR() ) {
clr_INT_IR();
PollIR();
if( bIRnewHit == TRUE ) { // new IR code is coming
bIRnewHit = FALSE;
// process IR event here
printf( "%4lX\n", gIRdata );
}
}
TimeoutIR();
}
}

Click to expand...