Here’s the schematic I used (all at 5V, USB power):

Using this schematic I doubled the range of my IR LED, the power drawn in the circuit is now 37mA. My former circuit, without using a NPN transistor drew 20mA (JeeNode max per digital pin). So that’s almost twice the power.
You could increase this even further using smaller valued resistors, but that would push the boundaries of the LED and transistor. I didn’t need any bigger range anyway as I use IR emitter cables attached to my devices.
Now that I’m satisfied with the hardware part of sending I can start looking at the software side!

p.s: here’s a picture of the box right now.. cables anyone?

The main ingredients to get this going are:

• Hot glue (love that stuff)
• Solder
• Some wires
• A Jeelabs carrier board with case
• A drill
• A lot of patience…

I started out drilling a hole for the power supply. I used an USB cable to power the Jeenode (I cut the unused wires). USB is on a lot of devices nowadays (media boxes, media tanks, sat receivers you name it) so this is an ideal power source for my IR box.

Here is the hole in place (one part of the box is shown):

And here is the result of the closed box:

The next step I took was to give the IR receiver a nice position, I choose the opposite of the power connector. I did this because I want the power connector, and other connectors out of sight.
Once again I drilled a hole, inside the box I had to make a little piece of plastic tube to lift the IR sensor (I soldered it to a little hobby print board)

Here’s a picture of the plastic tube, and the IR sensor soldered on the hobby print board:

And here is it glued to the box (I am a sloppy solderer, but hey it’s inside a box anyway :-) )

And this is how it looks on the outside:

Next up was wiring the cables the same way as on the breadboard, this was more work then I expected it to be. Took me quite a while to get everything wired up.
Here’s the result of the wiring inside the box:

And this is how it looks from the outside:

That’s it! The receiver has been put inside the box, I need some more time to fit the sender inside the box. I have some different idea’s for that instead of drilling holes.
This step in the project required quite some different skills (drilling, glue’ing, soldering etc)

• A Jeelink containing a sketch which translates serial commands to IR codes and sends them over the air;
• A Jeenode on the receiving side, which receives the IR commands and sends them out to an IR led;
• A python script to send commands to the serial port, to create a basic zapping demo.

Here’s a little video demonstrating the sketches and python script below:

The Jeelink has the following sketch:

/*
 * mdRFReceive - Generic home automation RF12 receiver.
 * Version 0.1 June, 2010
 * Copyright 2010 Maarten Damen
 * http://www.maartendamen.com
*/
#include <Ports.h>
#include <RF12.h>

#define MAX_STRING_LEN  20

byte needToSend;
long unsigned int sendbuf;
char buffer[MAX_STRING_LEN];
int bufferIndex = 0;

void setup() {
  Serial.begin(57600);
  rf12_config();
}

static void sendIR(long unsigned int code) {
  sendbuf = code;
  needToSend = 1;
}

char* subStr (char* str, char *delim, int index) {
   char *act, *sub, *ptr;
   char output;
   static char copy[MAX_STRING_LEN];
   int i;

   // Since strtok consumes the first arg, make a copy
   strcpy(copy, str);

   for (i = 1, act = copy; i <= index; i++, act = NULL) {
	sub = strtok_r(act, delim, &ptr);
	if (sub == NULL) break;
   }
   return sub;
}

unsigned long long conv64(char* str)
{
    unsigned long long res = 0;

    // remove 0x or 0X part
    if((strstr(str, "0x") == str) || (strstr(str, "0X") == str))
        str += 2;

    // do the conversion...
    for(; *str != 0; str++)
    {
        // multiply by 16 (remember, hexadecimal == base 16)
        res <<= 4;
        if(strchr("0123456789", *str) != NULL) // if within 0-9...
            res |= *str - '0';
        else if(strchr("ABCDEF", *str) != NULL) // if within A-F...
            res |= *str + 10 - 'A';
        else if(strchr("abcdef", *str) != NULL) // if within a-f...
            res |= *str + 10 - 'a';
        else
        {
            res >>= 4;
            break;
        }
    }

    return res;
}

static void handleInput (char* command, char* argument) {
  if (strcmp(command, "send_tv")  == 0)
  {
    long unsigned int test = conv64(argument);
    sendIR(test);
  }
}

void loop() {
    if (Serial.available())
    {
      char ch = Serial.read();
      if (ch == '\n')
      {
        bufferIndex = 0;
        handleInput(subStr(buffer, " ", 1), subStr(buffer, " ", 2));
      } else {
        buffer[bufferIndex++] = ch;
      }
    }

  if (rf12_recvDone() && rf12_crc == 0) {
    byte n = rf12_len;
    Serial.println("Packet CRC OK");
    Serial.print((int) rf12_hdr);
    for (byte i = 0; i < n; i++) {
      Serial.print(' ');
      Serial.print((int) rf12_data[i]);
    }
    Serial.println();
  }

  if (needToSend && rf12_canSend()) {
    needToSend = 0;
    rf12_sendStart(0, &sendbuf, sizeof sendbuf);
  }
}

The Jeenode has the following receiving sketch:

/*
 * mdIR - IR interface for home automation.
 * Version 0.1 May, 2010
 * Copyright 2010 Maarten Damen
 * http://www.maartendamen.com
*/

#include <RF12.h>
#include <Ports.h>
#include <IRremote.h>

IRsend irsend;

int RECV_PIN = 4;
IRrecv irrecv(RECV_PIN);

MilliTimer sendTimer;

byte needToSend;
decode_results results;

long unsigned int sendbuf;
long unsigned int received;

struct {
    byte decode;     // IR decode
} payload;

void setup () {
    Serial.begin(57600);
    Serial.println(57600);
    Serial.println("mdIR started...");
    rf12_config();
    irrecv.enableIRIn(); // Start the IR receiver
}

void loop () {
    if (irrecv.decode(&results)) {
      needToSend = 1;
      sendbuf = results.value;

      Serial.println(results.value);
      Serial.println(results.value, HEX);
      irrecv.resume(); // Receive the next value
    }

    /* TODO: rf12_canSend doesn't work if I remove this... (needs to check incoming packets?) */
    if (rf12_recvDone() && rf12_crc == 0 && (int) rf12_hdr == 10) {
      byte n = rf12_len;
      Serial.println("Packet CRC OK");
      Serial.println((int) n);
      for (byte i = 0; i < n; i++) {
        Serial.print(' ');
        Serial.print((int) rf12_data[i]);
      }
      Serial.println();

      received = ( ((long) rf12_data[3] << 24)
                       + ((long) rf12_data[2] << 16)
                       + ((long) rf12_data[1] << 8)
                       + ((long) rf12_data[0] ) );

      irsend.sendSamsung(received, 32);
      /* Re-enable receiving mode */
      irrecv.enableIRIn();
      Serial.println();
    }

    if (needToSend && rf12_canSend()) {
        needToSend = 0;
        Serial.println("need to send");
        rf12_sendStart(0, &sendbuf, sizeof sendbuf);
    }
}

The python scripts looks like this:

from twisted.internet.serialport import SerialPort
import sys
from twisted.protocols import basic
if sys.platform == 'win32':
    from twisted.internet import win32eventreactor
    win32eventreactor.install()
from twisted.internet import reactor

class IRProtocol(basic.LineReceiver):
    def __init__(self):
        # Power on the tv
        reactor.callLater(10.0, self.send_tv, "0xE0E040BF")

        # Zap a bit
        reactor.callLater(15.0, self.send_tv, "0xE0E020DF")
        reactor.callLater(20.0, self.send_tv, "0xE0E0A05F")
        reactor.callLater(25.0, self.send_tv, "0xE0E0609F")
        reactor.callLater(30.0, self.send_tv, "0xE0E010EF")
        reactor.callLater(35.0, self.send_tv, "0xE0E0906F") 

    def lineReceived(self, line):
        """ Do nothing with received lines yet """

    def send_tv(self, command):
        """
        Send's an IR command.
        """
        self.transport.write('send_tv ' + command + '\n')            

SerialPort(IRProtocol(), 6 , reactor, '57600')
reactor.run()

I modified my existing source code to enable wireless transmitting:

/*
 * mdIR - IR interface for home automation.
 * Version 0.1 May, 2010
 * Copyright 2010 Maarten Damen
 * http://www.maartendamen.com
*/

#include <RF12.h>
#include <Ports.h>
#include <IRremote.h>

int RECV_PIN = 4;
IRrecv irrecv(RECV_PIN);

MilliTimer sendTimer;

byte needToSend;
decode_results results;

long unsigned int sendbuf;

struct {
    byte decode;     // IR decode
} payload;

void setup () {
    Serial.begin(57600);
    Serial.println(57600);
    Serial.println("mdIR started...");
    rf12_config();
    irrecv.enableIRIn(); // Start the IR receiver
}

void loop () {
    if (irrecv.decode(&results)) {
      needToSend = 1;
      sendbuf = results.value;

      Serial.println(results.value);
      Serial.println(results.value, HEX);
      irrecv.resume(); // Receive the next value
    }

    /* TODO: rf12_canSend doesn't work if I remove this... (needs to check incoming packets?) */
    if (rf12_recvDone() && rf12_crc == 0) {
    }

    if (needToSend && rf12_canSend()) {
        needToSend = 0;
        Serial.println("need to send");
        rf12_sendStart(0, &sendbuf, sizeof sendbuf);
    }
}

Here’s a screenshot of my Jeelink receiving the packets send by the Jeenode receiving the infrared signals:

Image 1: Jeelink receiving IR signals send by another Jeenode. Notice the different buttons pressed.

So, in my opinion an ideal remote has integration with my home automation system, and keeps tracking of device statuses (I can use Plugwise for example to determine if my TV is powered on or off)
And what to think about turning on the TV on at your preferred time on your preferred channel? (imagine waking up, stepping inside the living room and have the morning news ready for you.. )
Enough introduction, let’s dive into the hardware…

Hardware used

1 x Jeenode
1 x USB-BUB
1 x Vishay TSOP 1838 IR receiver (datasheet: http://www.datasheetcatalog.org/datasheets/134/301155_DS.pdf)
1 x Breadboard
Some jumper cables, to connect stuff around…

Here’s a picture of my initial setup:

Image 1: Jeenode connected to IR receiver module.

Software

I quickly wanted to get started, so I google’ed around a bit.. until I found this nice IR library: http://www.arcfn.com/2009/08/multi-protocol-infrared-remote-library.html (nice work Ken!)
This library provides a few basic IR protocols (NEC, Sony and RC5+6)
There is a test sketch included with the IR library called IRrecvDump which is nice for debugging.
I tested out several remotes I had laying around here (logitech, xtreamer, samsung tv, dreambox sat receiver) unfortunately only the xtreamer remote uses the standard IR protocol.

My main goal is to control my TV so I started ‘hacking’ on that IR protocol first…

Samsung IR protocol

My TV remote is a Samsung BN59-00609A, I had some luck that this remote is included within LIRC (http://www.lirc.org) which has an excellent library of remotes.
“All” I had to do is modify some of the existing IRlibrary code. This took me well over 2 hours :-(

This is the modified routine to receive the Samsung IR protocol (it looks like an extended NEC protcol):

long IRrecv::decodeSamsung(decode_results *results) {
 long data = 0;
 int offset = 1; // Skip first space
 // Initial mark
 if (!MATCH_MARK(results->rawbuf[offset], SAMSUNG_HDR_MARK)) {
 return ERR;
 }
 offset++;

 // Check bits
 if (irparams.rawlen < 2 * SAMSUNG_BITS + 4) {
 return ERR;
 }

 // Initial space
 if (!MATCH_SPACE(results->rawbuf[offset], SAMSUNG_HDR_SPACE)) {
 return ERR;
 }
 offset++;
 Serial.println("OFFSET");
 Serial.println(offset);

 for (int i = 0; i < SAMSUNG_BITS; i++) {
 if (!MATCH_MARK(results->rawbuf[offset], SAMSUNG_BIT_MARK)) {
 return ERR;
 }
 offset++;
 if (MATCH_SPACE(results->rawbuf[offset], SAMSUNG_ONE_SPACE)) {
 data = (data << 1) | 1;
 }
 else if (MATCH_SPACE(results->rawbuf[offset], SAMSUNG_ZERO_SPACE)) {
 data <<= 1;
 }
 else {
 return ERR;
 }
 offset++;
 }
 // Success
 results->bits = SAMSUNG_BITS;
 results->value = data;
 results->decode_type = SAMSUNG;
 return DECODED;
}

And here are the used variables:

#define SAMSUNG_HDR_MARK 4500
#define SAMSUNG_BITS 32
#define SAMSUNG_HDR_SPACE 4500
#define SAMSUNG_BIT_MARK 560
#define SAMSUNG_ONE_SPACE 1600
#define SAMSUNG_ZERO_SPACE 600

Here is an example decoded button press (on/off button):

Image 2: Example key press in Arduino serial monitor.

According to the LIRC file 40BF maps to:

POWER            0x40BF

Voila! We got a match.
Next up is actually sending out the actual commands for my remote, to completely replace it. To be continued!

I have one of these recycle bins:
http://www.easybin.nl/Easybin_2009-2010/assortiment.html
(deluxe 50)

The cover automatically opens when it detects motion over it.. this is nice and hygienic.

I decided to open up my bin. Once opened I quickly notices the most interesting part of the bin.. the motion sensor and the LED that flashes when the bin is in the open state.

The LED has the following states:

• Short red flashes when the device is alive;
• constantly green lid when the cover is open;
• constant red lid when the cover is closing.

This led is a so called bi-color LED. It has 3 pins, one pin supplies power for the green color.. the other pin supplies power for the red color. The middle pin is the neutral/GND pin.
Using a multimeter I measured the voltages on the pins.. turns out there was 2 volt on it. Great! This could be connected to the analog ports of the JeeNode.

I soldered some leads on the existing sensorbin board:

Image 1: the sensorbin board with additional wires connected.

The orange wire is the green led color, the middle wire is the ground and the blue wire is the red color.
Now that I connected the leads to the exisiting board I connected the orange wire to analog port 1 of the jeenode. The middle wire to ground port 1. And the blue wire to analog port 2.

I was now ready to go ahead and upload a ‘sketch’ (this is a program that runs on the microprocessor) to my JeeNode.
This is what I came up with:

#include <Ports.h>
#include <RF12.h>

Port input (1);

/* is the bin open? */
byte isopen = 0;

void setup () {
 // initialize the serial port and the RF12 driver
 Serial.begin(57600);
 Serial.print("\n[SensorBin]");
 rf12_config();
 // set up easy transmissions at maximum rate
 rf12_easyInit(0);
}

void loop () {
 int state = input.anaRead();

 if (state > 600 && isopen == 0) {
 Serial.print("Cover is opened!");
 Serial.println();
 isopen = 1;
 } else if (state < 600 && isopen == 1) {
 Serial.print("Cover is closed again..");
 Serial.println();
 isopen = 0;
 }

 delay(1000);
}

And here is the test result:

Image 2: output log from Arduino serial port monitor

Excellent! So, I can now read the status of my recycle bin.. is this life saving? No.. not really but atleast it gave me some insight on the JeeNode and Arduino platform.
I want to extend this concept with the following:

• Sending the status of RF;
• reading out the battery status (percentage left) of the recycle bin (this is handy to get e-mail notifications from home automation software);
• putting in a light sensor so I can read the light status of the room the recycle bin is placed in;
• putting in a motion sensor so I can get the motion status of the room the recycle bin is placed in;
• etc.

Oh btw.. just for for fun.. this is my test setup (JeeNode connected to USB-BUB in front, sensorbin hardware board in the back):

Image 3: test setup in action :-)