Infrared detection

I am making a laser tag system and am working out the firing and hit detecting code. I can send different IR pulses just fine and I can wire the IR receiver to accept the pulses. What I cannot figure out is how to register a specific IR code and where to put the ‘if’ statement to activate say, and LED when the specific IR pulse is detected. This is the code from the adafruit website on receiving IR signals. In the comments at the top it says it can be used to make a receiver but as I stated before i don’t know how to set it to look for a specific series of IR pulses. This is important because the IR LED on the laser tag gun will activate the player’s own IR receiver unless it is looking for a separate IR pulse.

/* Raw IR decoder sketch!
 
 This sketch/program uses the Arduno and a PNA4602 to 
 decode IR received. This can be used to make a IR receiver
 (by looking for a particular code)
 or transmitter (by pulsing an IR LED at ~38KHz for the
 durations detected 
 
 Code is public domain, check out www.ladyada.net and adafruit.com
 for more tutorials! 
 */
 
// We need to use the 'raw' pin reading methods
// because timing is very important here and the digitalRead()
// procedure is slower!
//uint8_t IRpin = 2;
// Digital pin #2 is the same as Pin D2 see
// http://arduino.cc/en/Hacking/PinMapping168 for the 'raw' pin mapping
#define IRpin_PIN      PIND
#define IRpin          2
 
// the maximum pulse we'll listen for - 65 milliseconds is a long time
#define MAXPULSE 65000
 
// what our timing resolution should be, larger is better
// as its more 'precise' - but too large and you wont get
// accurate timing
#define RESOLUTION 20 
 
// we will store up to 100 pulse pairs (this is -a lot-)
uint16_t pulses[100][2];  // pair is high and low pulse 
uint8_t currentpulse = 0; // index for pulses we're storing
 
void setup(void) {
  Serial.begin(9600);
  Serial.println("Ready to decode IR!");
}
 
void loop(void) {
  uint16_t highpulse, lowpulse;  // temporary storage timing
  highpulse = lowpulse = 0; // start out with no pulse length
 
 
//  while (digitalRead(IRpin)) { // this is too slow!
    while (IRpin_PIN & (1 << IRpin)) {
     // pin is still HIGH
 
     // count off another few microseconds
     highpulse++;
     delayMicroseconds(RESOLUTION);
 
     // If the pulse is too long, we 'timed out' - either nothing
     // was received or the code is finished, so print what
     // we've grabbed so far, and then reset
     if ((highpulse >= MAXPULSE) && (currentpulse != 0)) {
       printpulses();
       currentpulse=0;
       return;
     }
  }
  // we didn't time out so lets stash the reading
  pulses[currentpulse][0] = highpulse;
 
  // same as above
  while (! (IRpin_PIN & _BV(IRpin))) {
     // pin is still LOW
     lowpulse++;
     delayMicroseconds(RESOLUTION);
     if ((lowpulse >= MAXPULSE)  && (currentpulse != 0)) {
       printpulses();
       currentpulse=0;
       return;
     }
  }
  pulses[currentpulse][1] = lowpulse;
 
  // we read one high-low pulse successfully, continue!
  currentpulse++;
}
 
void printpulses(void) {
  Serial.println("\n\r\n\rReceived: \n\rOFF \tON");
  for (uint8_t i = 0; i < currentpulse; i++) {
    Serial.print(pulses[i][0] * RESOLUTION, DEC);
    Serial.print(" usec, ");
    Serial.print(pulses[i][1] * RESOLUTION, DEC);
    Serial.println(" usec");
  }
}

Will

You can treat the IR as an asynchronous serial data stream:

Look for a rising edge (the signal going from LOW to HIGH) to signal a start bit Wait 500 microseconds (0.5 milliseconds) to get to the middle of the start bit. Repeat n times (where 'n' is the number of bits in your code) Wait for 1 millisecond Read the signal and shift the value 1 (HIGH) or 0 (LOW) into a variable. Then wait one more millisecond and check that the signal has gone LOW (stop bit)

You may want to add error checking codes to your data to look for interference.

The bits you shifted in are the ID of the sender (gun shooting).

If you have a 16-bit code with 1 start bit and 1 stop bit, that's 18 milliseconds per shot. You should probably send a burst of shots with short random delays between codes to minimize interference. Maybe 30 to 50 milliseconds between codes.

The guns should probably check that the incoming signal has been LOW for several milliseconds before firing to avoid collisions.