I'm trying to understand a few things about this code.

  1. Why is digitalRead() slower than IRpin_PIN & (1 << IRpin)?
  2. What does IRpin_PIN & (1 << IRpin) mean? I translated it to numbers and I figured out it's actually PIND & (0b100). What does PIND translate to and why is bitwise-and with 0b100 performed on it?
  3. Why is the 20-microsecond delay (RESOLUTION) necessary?
  4. What does _BV in while (! (IRpin_PIN & _BV(IRpin))) mean?

/* 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.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
     // 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)) {
  // we didn't time out so let's stash the reading
  pulses[currentpulse][0] = highpulse;
  // same as above
  while (! (IRpin_PIN & _BV(IRpin))) {
     // pin is still LOW
     if ((lowpulse >= MAXPULSE)  && (currentpulse != 0)) {
  pulses[currentpulse][1] = lowpulse;
  // we read one high-low pulse successfully, continue!

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");
  // print it in a 'array' format
  Serial.println("int IRsignal[] = {");
  Serial.println("// ON, OFF ");
  for (uint8_t i = 0; i < currentpulse-1; i++) {
    //Serial.print("\t"); // tab
    Serial.print(pulses[i][1] * RESOLUTION , DEC);
    Serial.print(pulses[i+1][0] * RESOLUTION , DEC);
  //Serial.print("\t"); // tab
  Serial.print(pulses[currentpulse-1][1] * RESOLUTION, DEC);
  • 1
    I expect the source for digitalRead() will explain a lot about why it's slower. – Brian Drummond Jan 7 '17 at 10:57
int digitalRead(uint8_t pin)
    uint8_t timer = digitalPinToTimer(pin);
    uint8_t bit = digitalPinToBitMask(pin);
    uint8_t port = digitalPinToPort(pin);

    if (port == NOT_A_PIN) return LOW;

    // If the pin that support PWM output, we need to turn it off
    // before getting a digital reading.
    if (timer != NOT_ON_TIMER) turnOffPWM(timer);

    if (*portInputRegister(port) & bit) return HIGH;
    return LOW;

1) so it

  • calls function digitalRead() (puts value on stack, jumps, prepare function frame - each cost some time)
  • calls 3 other functions (with all the same problems)
  • check for sanity of value
  • check for PWN (and eventually calls another function)
  • does the PIND & (0b100)
  • returns from function (so read stack, clear the frame, jumps, set the result)

just to obtain the same functionality

  • typical for library functions, that each call makes sure the environment is sane and expected each and every time it is called - in close loop you can check it onece before and then just do not broke it
  • translates parameter from nice arduino numbers to real addresses and bits each and every time again

2) it access the PORT D (see AVR (the processor) internal construction) and reads value of its 3. bit (which maps to the relevant pin of the chip/Arduino board

3) see following comment - it is expected length of the pulse (maybe with some safety limit)

4) _BV is for BitValue - shift 1 to position given by arg (that is macro doind 1 << IRpin) maybe more nice/readable version, compiles to the same. (the ! is ofcourse negaition)

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy