This is just off the top of my head, so read the appropriate documentation carefully.

Interrupts would be the way to go. That way the arduino can do other things and it will get yanked when it needs to do something.

The basic approach would be to put the IR input onto one of the external interrupt pins.  You then write an interrupt routine that gets called when the input changes.  The interrupt routine would do a couple of very simple things.

interrupt()
   ready = 0
   if pulse start
        save = clock (either millis or CLOCK0)
   else
        duration = clock - save
        ready = 1

Then your main loop can, when it gets a chance, look at ready and if it is set to 1, read the pulse length in duration.  Be sure you know what units you are using.

There's more to it than that, but this is the basic idea.  Look at the interrupt support in the Wiring reference, also check out the ATMega data sheet.  Plus read the source code for PulseIn.

HTH

So if I understand your psuedocode correctly, what your doing is pretty much writing your own pulse command, it records the clock time when the signal drops low, then once the signal goes high again subtracts the saved time from the current clock time? makes sense, now I just need to figure out how to impliment that in my program. I will try this out when I get home, unfortunately im at work right now

Wow, thanks for that last post, you deffinately posted that while i was responding to the second post! lol (I love this forum )
Im having some trouble following that code you posted, but I will do some back research on it and try and follow it a little better, thanks alot for the help guys and or gals

well Im using an old sony stereo remote that seems to work perfectly with the timing system posted on the article i linked to. The pulses start at the falling edge, my IR reciever is HIGH when its inactive, then pulses low when it gets a signal, stores them in the 12 integer array, then computes a key code, for example the power button on my remote is key code 21, so right now I have the code wait for the pulseIn(IRReciever, LOW), then it checks to see if it is less than 2200 milliseconds, then reads the rest of the pulses, computes the keycode, and returns it, when I get that return, I run it through an if statement, (this is all off memory)
int keycode = getIRKey();
if(keycode == 21)
{
//do magical things
}

the problem is the getIRKey function actually waits(pauses the program) until it gets the leading edge of the infrared code, so what i need it to do is check to see if that leading edge/keycode has been read, if not then loop through again, check, if not loop through, and then if it has do some stuff, in this case, magical things lol

Thanks again!!!!

mem, your both a saint and a devil, thank you so much for your code! but this last hour of work is going to really suck because now all I wanna do is go home and try it! I think I follow your code pretty well, and if I do have any problems, it shouldnt be to hard to fix, so ill let you know how it goes in an hour or so! THANKS AGAIN!

Glad its helped.

By doubles do you mean a repeat of the previous frame? I think the protocol says that pulses will repeat every 30ms or so if a button is held down. Is this what you are seeing?

One enhancement you may want to consider implementing is to have the interrupt handler do the decoding and store the result in an array. This has the benefit that you are much less likely lose any data if your app was busy with a task that delayed calls to get the next result. This could be implemented using simple queuing logic.

Have a search to see if anyone has posted code for reading and writing to queue buffers. If not, you could modify the code I posted here by removing the function to take the average value (this has no meaning in yr app) and add a function to read data off the head of the Queue (add a variable called head that indexes the next unread decoded value.)  

If your queue logic prevented reading and writing to the same location ( i.e. never read from the head if it equals the tail then you can remove the enable/disable interrupt code.

Anyway, good luck with the project.

Oh and post your code. I would like to see how its turned out

lol im really, really going to try and follow that, ill post it when its done with that, but here is the code as it stands right now, I really wanna learn how to use some timer functions, for example something to check elapsed time, so that when I do animations they actually, ya know, work... ah well it will make sense in the code...

Mind you, alot of this isnt my code, and its VERY sloppy, this is the first write
Code:

#define icpPin		8	   // this interrupt handler must use pin 8
#define TICKS_PER_uS	2	    // number of timer ticks per microsecond
#define NUMBER_PULSES     13		  // number of pulses in on frame of sony remote  
#define START_PULSE_LEN   (2400 * TICKS_PER_uS) // start pulse is 2.4ms long (note clock counts in 0.5 us ticks)

int calibrationTime = 10;        
long unsigned int lowIn;        
long unsigned int pause = 5000;  
boolean lockLow = true;
boolean takeLowTime;  
int pirPin = 3;
int motionLED = 11;
int ir_pin = 2;
int powerLED = 12;
int outputLEDS[3];
int debug = 0;
int start_bit = 2000;
int bin_1 = 1000;
int bin_0 = 400;
int LEDAnimation = 0;

boolean playAnimation = false;
int animationStep = 0;
int OutputLED = 12;
boolean Calibrated;
boolean CheckSensor;
volatile unsigned int Pulses[ NUMBER_PULSES+ 1];
volatile uint8_t  PulseCount;

ISR(TIMER1_CAPT_vect){
   if(! bit_is_set(TCCR1B ,ICES1)){ 
	 TCNT1 = 0;
   }
   else {
	  if(ICR1 >= START_PULSE_LEN)
		PulseCount = 0;    
	  if(PulseCount < NUMBER_PULSES) {
	     Pulses[++PulseCount] = ICR1 / TICKS_PER_uS;
	  }
   }    
   TCCR1B ^= _BV(ICES1);
}
void setup(){
  Calibrated = false;
  CheckSensor = false;
  outputLEDS[0] = 10;
  outputLEDS[1] = 9;
  outputLEDS[2] = 7;
  Serial.begin(9600);
  pinMode(pirPin, INPUT);
  pinMode(powerLED, OUTPUT);
  pinMode(motionLED, OUTPUT);
  pinMode(outputLEDS[0], OUTPUT);
  pinMode(outputLEDS[1], OUTPUT);
  pinMode(outputLEDS[2], OUTPUT);
  pinMode(ir_pin, INPUT);
  digitalWrite(powerLED, HIGH);	    //not ready yet
  digitalWrite(motionLED, LOW);
  digitalWrite(outputLEDS[0], LOW);
  digitalWrite(outputLEDS[1], LOW);
  digitalWrite(outputLEDS[2], LOW);
  pinMode(icpPin,INPUT);
  PulseCount = 0;  
  TCCR1A = 0x00;
  TCCR1B = 0x02;
  TIMSK1 = _BV(ICIE1);
  delay(50);
}

int DecodeFrame() {
  int result;  
  cli();
  if(debug == 1) {
    Serial.println("-----");
  }
  for(int i=1;i<NUMBER_PULSES;i++) {
    if (debug == 1) {
	  Serial.print(Pulses[i]);
    }
    if(Pulses[i] > bin_1) {
	Pulses[i] = 1;
    }  else {
	if(Pulses[i] > bin_0) {
	  Pulses[i] = 0;
	} else {
	 Pulses[i] = 2;
	}
    }
  }
  
  for(int i=1;i<NUMBER_PULSES;i++) {
    if(Pulses[i] > 1) {
	return -1;
    }
  }
  result = 0;  
  int seed = 1;						  
  for(int i=1;i<NUMBER_PULSES;i++) {
    if(Pulses[i] == 1) {
	result += seed;
    }
    seed = seed * 2;
  }  
  PulseCount = 0;
  sei();
  return result;

}
void loop(){
  int value;
  if(PulseCount  >= NUMBER_PULSES  ){
     value = DecodeFrame() ;
     Serial.print(value);
  }
  if(value == 43)
  {
    CheckSensor = !CheckSensor;
    if(CheckSensor)
    {
      Serial.println("Powering on...");
      digitalWrite(powerLED, HIGH);
    }
    else
    {
      Serial.println("Powering down...");
      digitalWrite(powerLED, HIGH);
      digitalWrite(motionLED, LOW);
      playAnimation = false;
      Calibrated = false;
    }
  }
  if(value == 2659)
  {
    LEDAnimation ++;
    if(LEDAnimation > 2)
    {
      LEDAnimation = 0;
    }
  }
  if(CheckSensor == true)
  {
    if(Calibrated == true)
    {
      digitalWrite(motionLED, HIGH);
      CheckPIR();
    }
    else
    {
      CalibrateSensor();
      Serial.println("Calibration Complete, starting program...");
      digitalWrite(powerLED, LOW);
      Calibrated = true;
    }
  }
  else
  {
    Calibrated = false;
    digitalWrite(motionLED, LOW);
  }
  delay(100);
}
void CheckPIR()
{
    if(digitalRead(pirPin) == HIGH){
//TURN ON LEDS
    if(lockLow){
	lockLow = false;
	delay(50);
    }
    takeLowTime = true;
  }

  if(digitalRead(pirPin) == LOW){

    if(takeLowTime){
	lowIn = millis();	    //save the time of the transition from high to LOW
	takeLowTime = false;	 //make sure this is only done at the start of a LOW phase
    }
    if(!lockLow && millis() - lowIn > pause){
	lockLow = true;

	//TURN OFF LEDS

	delay(50);
    }
  }
  return;
}
 

axileon wrote on 03.03.2008 at 06:37:58:

This is a cross post! My I suggest that contributions to your request are posted in the other thread here: http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1204020386

(the problem with posting in more than one place is that people seeing only one thread may spend time composing and posting an answer to a question that has already been answered. If you ever find that this happens to you, you will see how annoying it can be  .