IR Control Kit Hookup Guide

Contributors: Jimb0
Favorited Favorite 9

Example 1: Using the Remote

In the first example, we’ll show how you can connect the IR receiver to an Arduino, and control it with the IR remote.

Step 1: Download and Install Ken Shirriff’s IRremote Library

For quickly and easily adding IR control to your Arduino, we recommend you download Ken Shirriff’s IRremote library. You can get it from the GitHub repository (check out our Using GitHub tutorial for help, or click here to grab it directly:

For help installing the library, check out our Installing an Arduino Library tutorial. You’ll need to extract the folder you download into a “libraries” folder within your Arduino sketchbook.

Note: Make sure the folder name that you copy into your "libraries" folder is named "IRremote". Use of the ` - ` in the directory name can lead to errors in compiling the code.

The IRremote library is a powerful tool for adding IR to your project. Whether you want to send IR codes out to an appliance, or transmit IR codes from a remote to your Arduino (or both!). We’ll go over some of the simple stuff you can do with the library. For more help using it, check out Ken Shirriff’s blog.

Step 2: Setup the Hardware

In this first example, we’ll use the IR receiving capabilities of the IRremote library to use the SparkFun IR remote to control an RGB LED. An RGB LED isn’t included with the IR Control Kit, but it might be something you’ve already got in your parts box. If not, any set of three will do. Or you can even just use the serial monitor as your output monitor.

This is how we’ll connect the IR receiver and RGB LED to our Arduino:

Circuit fritzing diagram

The output of the IR receiver connects to D11, but it could be connected to any digital input pin. If you swap pins, make sure you reflect those changes in code!

We don’t have a use for the IR LED yet, so, for now, set that safely aside.

Step 3: Upload the Sketch

Copy and paste the below code into your Arduino IDE. Then upload it to your Arduino to create your very own, remote controlled, RGB LED.

/* RGB Remote Control
   by: Jim Lindblom
   SparkFun Electronics
   date: October 1, 2013

   This sketch uses Ken Shirriff's *awesome* IRremote library:

   RGB Remote Control uses a combination of SparkFun's 
   IR Remote ( and an
   IR receiver diode ( to
   control an RGB LED.

   The IR Remote's power button turns the LED on or off. The A, B, 
   and C buttons select a channel (red, green, or blue). The up
   and down arrows increment or decrement the LED brightness on that channel.
   The left and right arrows turn a channel to min or max, and
   circle set it to the middle.

   Hardware setup:
     * The output of an IR Receiver Diode (38 kHz demodulating
       version) should be connected to the Arduino's pin 11.
       * The IR Receiver diode should also be powered off the
         Arduino's 5V and GND rails.
     * A common cathode RGB LED is connected to Arduino's pins 
       5, 9, and 6 (red, green, and blue pins).

#include <IRremote.h> // Include the IRremote library

/* Setup constants for SparkFun's IR Remote: */
#define NUM_BUTTONS 9 // The remote has 9 buttons
/* Define the IR remote button codes. We're only using the
   least signinficant two bytes of these codes. Each one 
   should actually have 0x10EF in front of it. Find these codes
   by running the IRrecvDump example sketch included with
   the IRremote library.*/
const uint16_t BUTTON_POWER = 0xD827; // i.e. 0x10EFD827
const uint16_t BUTTON_A = 0xF807;
const uint16_t BUTTON_B = 0x7887;
const uint16_t BUTTON_C = 0x58A7;
const uint16_t BUTTON_UP = 0xA05F;
const uint16_t BUTTON_DOWN = 0x00FF;
const uint16_t BUTTON_LEFT = 0x10EF;
const uint16_t BUTTON_RIGHT = 0x807F;
const uint16_t BUTTON_CIRCLE = 0x20DF;

/* Connect the output of the IR receiver diode to pin 11. */
int RECV_PIN = 11;
/* Initialize the irrecv part of the IRremote  library */
IRrecv irrecv(RECV_PIN);
decode_results results; // This will store our IR received codes
uint16_t lastCode = 0; // This keeps track of the last code RX'd

/* Setup RGB LED pins: */
enum ledOrder // Make an enum to add some clarity in the code
  RED,   // 0
  GREEN, // 1
  BLUE   // 2
const int rgbPins[3] = {5, 9, 6}; // Red, green, blue pins respectively
byte rgbValues[3] = {55, 23, 200}; // This keeps track of channel brightness
byte activeChannel = RED; // Start with RED as the active channel
boolean ledEnable = 1; // Start with the LED on.

void setup()
  Serial.begin(9600); // Use serial to debug. 
  irrecv.enableIRIn(); // Start the receiver

  /* Set up the RGB LED pins: */
  for (int i=0; i<3; i++)
    pinMode(rgbPins[i], OUTPUT);
    analogWrite(rgbPins[i], rgbValues[i]);

// loop() constantly checks for any received IR codes. At the
// end it updates the RGB LED.
void loop() 
  if (irrecv.decode(&results)) 
    /* read the RX'd IR into a 16-bit variable: */
    uint16_t resultCode = (results.value & 0xFFFF);

    /* The remote will continue to spit out 0xFFFFFFFF if a 
     button is held down. If we get 0xFFFFFFF, let's just
     assume the previously pressed button is being held down */
    if (resultCode == 0xFFFF)
      resultCode = lastCode;
      lastCode = resultCode;

    // This switch statement checks the received IR code against
    // all of the known codes. Each button press produces a 
    // serial output, and has an effect on the LED output.
    switch (resultCode)
      case BUTTON_POWER:
        if (ledEnable) ledEnable = 0;
        else ledEnable = 1; // Flip ledEnable
      case BUTTON_A:
        activeChannel = RED;
      case BUTTON_B:
        activeChannel = GREEN;
      case BUTTON_C:
        activeChannel = BLUE;
      case BUTTON_UP:
        rgbValues[activeChannel]++; // Increment brightness
      case BUTTON_DOWN:
        rgbValues[activeChannel]--; // Decrement brightness
      case BUTTON_LEFT:
        rgbValues[activeChannel] = 0; // Min brightness (off)
      case BUTTON_RIGHT:
        rgbValues[activeChannel] =  255; // Max brightness
      case BUTTON_CIRCLE:
        rgbValues[activeChannel] = 127; // Medium brightness
        Serial.print("Unrecognized code received: 0x");
        Serial.println(results.value, HEX);
    irrecv.resume(); // Receive the next value

  // Every time through the loop, update the RGB LEDs:
  if (ledEnable)
    for (int i=0; i<3; i++)
      analogWrite(rgbPins[i], rgbValues[i]);
    for (int i=0; i<3; i++)
      analogWrite(rgbPins[i], 0);

Check the comments in the code for help understanding what’s going on. We’re basically looping and checking to see if the IR receiver diode has received a known code from the IR remote. If so, it’ll have some effect on the LED – turning it on/off, turning up or down red/green/blue, etc.

You can also check the output of the serial monitor to make sure the codes are being received. When a known code is received, it’ll print out the corresponding button. When an unknown code is received (which shouldn’t be often, if ever, if you’re only using the SparkFun IR remote) it’ll print that code out in hexadecimal.

Step 4: Play!

That’s all there is to it! Try exploring the code and replacing the RGB LED with other devices you can control. How about a servo motor? Or a relay! There are so many possibilities!

Do you have other IR remotes around? Try them out! As you press a button, check the serial monitor (at 9600 bps) to see what code it spits out. Then add a case for those in the switch statement.