- 8Kb flash (yes, space does matter!)
- 0.5Kb SRAM
- Maximum operating frequency (20Mhz, using an external crystal)

Here’s a picture of this MCU:

To program this MCU you have to use an ISP (In System Programmer) programmer. I own an USBTinyISP produced by Adafruit, which is perfect for this job. There is a minor drawback though: the ATtiny chips are not supported out of the box within the Arduino IDE. However, there is a perfect open source library by the name of arduino-tiny available to support this MCU within the Arduino IDE.

Here’s a picture of my test setup with the USBTinyISP (on the right) connected:

The pins are connected as follows:

• ATtiny Pin 2 to USBTinyISP SCK
• ATtiny Pin 1 to USBTinyISP MISO
• ATtiny Pin 0 to USBTinyISP MOSI
• ATtiny RST pin to USBTinyISP RESET

After getting the connections right, I started my first programming attempt. The test sketch blink, which is the “hello world” for MCU’s compiled correctly but then:

Hmm, nasty java exception there. After some digging around I figured out the incorrect programmer was getting addressed in the boards.txt file coming with the arduino-tiny project. This file is located under in the Arduino hardware/tiny/ folder. In order to make it work with the USBTinyISP, you have to change the following line for each target board (the ATtiny85 at 1mhz is illustrated here):

attiny85at1.upload.using=pololu

Into the following:

attiny85at1.upload.using=arduino:usbtinyisp

After restarting the IDE, I was able to program the sketch!

Debugging

For standard Arduino’s, you can use a built in serial interface to debug. There is no such thing available for ATtiny chips. However, the arduino-tiny library does offer a debug interface. I used the USB-BUB from Modern Device to setup a debug interface. For the ATtiny85 the standard arduino-tiny debug interface is tied to PB3 of the ATtiny.
Once setup, you can use the regular Serial.begin() and Serial.print/println() functions. I connected PB3 to the RX pin of the USB-bub, off course there’s also a ground connection required so I connected the GND of the USB-BUB to the GND of my ATtiny. After that I was ready to start debugging…

So, here we go.. ready to start tinkering!

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.

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 :-)