The AVR chip I’m using in this tutorial is the ATMega48, which I’m programming using the USBTinyISP, which I bought in kit form from Adafruit.  Below is a photograph of my setup.

My USBTinyISP wired to my ATMega48 chip

The black component you can see to the left of the breadboard is a ZIF socket I soldered to some header sockets, which allows me to easily program the chip and plug other wires into, of course, if you want to, you can simply plug the chip straight into some breadboard (but this puts a fair amount of force on the legs).  Below is a picture of how to wire the chip up to your programmer.

Wiring diagram for connecting the ATMega48 to your ISP

I’ll assume you have your programmer installed working.  In order to compile the code we write for AVR, you’ll need the avr flavour of gcc, and also avrdude (to upload the code).  For all the windows users out there, there’s WinAVR, which will install all of the tools you need to compile and upload your code to the AVR chip.  I’m also using the AVR Eclipse Plugin, which makes compiling and up loading much simpler — in their getting started guide they also walk you through compiling and uploading the code, so its a handy resource for people who would like to learn more about this.

Bitwise Operations

This code is a lot more low-level than what you’d use for the Arduino.  It makes fairly heavy use of bitwise operations so here’s a quick overview of the main ones we use.

Bitwise OR

The | character represents the bitwise OR.  It compares each bit of its parameters, and if one of those bits is 1, the output bit is 1, as is shown in the truth table below.

So the operation 010 | 101 would output 111, and the output 001 | 000 would output 001.  This is useful for switching bits on when you don’t want to affect any other bits in the register.

Bitwise AND

The & character represents the bitwise AND.  It compares each bit of its parameters, and will output a 1 only if both bits are 1, as can be seen in the truth table.

The operation 010 & 101 would output 000, and 111 & 010 would output 010.  A common use of the AND operator is to apply masks to values — to ensure some bits are always off.  For example if we wanted the first and third bits of a register always to be 0 (maybe setting them to 1 could signal the end of the world), when setting that register with a certain value we can simply & it with the mask 010.

Bitwise XOR (eXclusive OR)

I’m not actually using this operator in this tutorial, but I thought I’d include it anyway, it has interesting uses — one of which is a simple encryption algorithm, which if used correctly is impossible (I believe) to break.  The ^ character represents a bitwise XOR in C, and it is similar to the OR operator above except that its output is only 1 if only one of the two input bits is 1.  See the table below.

Left Shift Operator <<

This operator simply shifts the bit in a variable by some number of places.  For example the operation 0001 << 1  would result in the number 0010, and the number 0001 << 2 would result in 0100.  If you shift a bit too far, the value will ‘overflow’ 0001 << 4  results in 0000 (assuming we’re using some 4-bit data type).  This is generally not something you want to do…  Incidentally there is also a >> operator, which shifts the bits of the left parameter right — i.e 0100 >> 1 outputs 0010.

Flashing LEDs!

Right, now we’ve got that over and done with, lets get our flash on.  Firstly, we’ll do this without the use of a timer (i.e. we’ll hack it out with some loops), then, in a later blog post (which should be coming soon — I just split it off from this one in order to reduce the length).

If you look at the Atmel spec sheets for the ATMega48, you can see that the pins on the chip are divided into 3 ports — B, C and D.  Each port, except for some reason port C, has 8 pins (C has only 7) numbered 0 to 7.   The pins are arranged as shown in the picture below (note that pins are labelled with their port letter then their pin number).

The pins on an ATMega 48 chip

Wire your LEDs to a breadboard (don’t forget your resistors), and connect their grounds to one of the spare ground pins on your programmer (see the diagram above).  We’re going to make these two LEDs flash alternately.  Connect the positive leg of one LED to C5, and the positive leg of the other LED to B1.

Create a C file and include the header file avr/io.h  Next create a main function that returns an int and no parameters.  In this function create a local variable int “next” and set that equal to 1.

The first thing we’ll need to do is to tell the chip that we want pins B1 and C5 to be outputs (similar to the pinMode function in arduino).  To do this we need to set their ‘Data Direction’ in the Data Direction Register on the chip (DDR).  We do this by shifting a 1 bit into the “DDB1″ bit of the DDRB register, and a 1 bit to the DDC5 bit of the DDRC register.  These register names take the form DDR<Port Letter> and the individual bits of those registers DD<Port Letter><Leg Number>.

Next, create an infinite while loop in which we’ll place the code to make the LEDs flash.  To turn a pin on, you set the corresponding bit in its port’s register to 1 (and to turn it off you set it to 0).   See the next lump of code to see how you do this.

#include <avr/io.h>

int main(void)
{
	int next = 1;
	/*Make Pin 1 of port B an output*/
	DDRB = 1 << DDB1;
	/*Make Pin 5 of port C an output*/
	DDRC = 1 <<DDC5;

	__asm__ volatile ("nop");

	while(1)
	{
		PORTB = next << PB1;
		PORTC = (1-next) << PC5;

		/* Put in a delay (we could use the AVR
		 * function for this).  The ASM instruction "nop"
		 * tells the CPU to do nothing for one clock cycle.
		 * The volatile keyword tells the compiler not
		 * to optimise this instruction out.
		 */
		for(int a = 0; a < 100; a++)
			for(int b = 0; b < 1000; b++)
				__asm__ volatile ("nop");
		next = 1-next;
	}

	return 1;
}

The above code is all you need for some flashing LEDs.  The first two instructions in the while loop are the ones that do most of the work — they shift bits into the correct registers in order to turn the LED on or off.  Again the registers are named PORT<Port Letter> and the individual pin data bits P<Port Letter><Pin Number>.  When coding these chips, remember that ints are only 8 bits long, don’t do as I did and have this count to 1000 000 in the delay as the number will overflow before it ever gets there (resulting in the program sitting there, spinning forever).

Anyway, that’s it for now, if you have any questions be sure to leave a comment below — I’m no expert, but I’ll do my best to answer your questions.  If you have suggestions as to how I can improve this code, or tools I can use to speed up development, then please comment.  Keep checking back because another tutorial on how to use timers is imminent.

Modes are changed by sending characters to the arduino over the serial connection, so that’s fairly easy.  In fact I decided that was too easy, and also too inconvenient for me (I don’t want to have to echo characters to the lamp every time I want to turn it on).  Therefore, to make changing modes easier I wrote a web interface, which contained some PHP code that echoed characters to the lamp based on which button had been pressed by the user.    This was all hosted locally to the lamp, so echoing characters to it was fairly easy.  The next step was to let users control the lamp remotely (i.e. across the internet).  This turned out to be a lot more challenging (or at least I overcomplicated it to the point that it became challenging), and this is the main focus of the article.

Simply allowing users to change the mode of my lamp over the internet would normally be really simple – open up port 80 on the server that’s hosting my lamp to the internet – however shamefully I’m on a network whose firewall blocks pretty much every inbound port, so hosting the interface locally isn’t an option.

Another simple option would be to have the lamp periodically poll a location on the internet to decide which mode to use, that way the web interface can just set the value of a file, then when the lamp reads that file, it will set its mode appropriately.  The downside with this is that the update time for the lamp would be quite slow and it would create a lot of http requests to the server.

So, to summarise

• The connection has to originate from behind the firewall
• Responses to users actions should be fast, and should ideally be fetched through a single, persistent connection

I’ve done work with chat bots before, and I just so happen to have access to a Jabber server so I decided I’d try to allow users to communicate with the lamp through Jabber.   This was actually fairly easy, although I admit I’m cheating in so far as the actual Jabber code isn’t running on the arduino, but instead a SheevaPlug (plug computer that runs linux).

The Client

The client side code is pretty simple – just a quick PERL script.  Jabber communication was enabled through the Net::Jabber.

#!/usr/bin/perl -w

use strict;

use Net::Jabber;

my $server = "-----";
my $port = 5222;
my $username = "-----";
my $password = "-----";

my $client = new Net::Jabber::Client();
my $device = '/dev/ttyUSB0';

my $allowFork = 1;

my $allowFaffage = 1;

#Try to fork the process, then kill the parent process
#leaving only the child process running.   This detaches
#the process from the terminal.
if($allowFork == 1 && fork())
{
    exit();
}

#Tells the XMPP librabry which functions should be
#called when certain events happen.
$client->SetCallBacks(message=>\&msgReceived, onauth=>\&authenticated);

#Connect to the server
$client->Execute(hostname=>$server,
                tls=>0,
                username=>$username,
                password=>$password,
                resource=>"lamp",
                register=>0);

#Sends a message to a user
sub send { my($to,$body) = @_;
                $client->MessageSend(to=>"$to",subject=>"Cheese",body=>"$body");
}

sub sendHelp { my($to) = @_;
                my $body = <<END;
I'm Harry's Lamp    Talking to me turns me on, and makes me change colours etc.  Here are the commands that are enabled atm.

    white - Just boring, white light
    random - Makes me randomly fade to colours
    fade - Makes me fade in and out with random colours
    off - Turns me off
END
    &send($to, $body);
}

#Once the lamp bot is up and ready,
#send a message to the owner to tell them.
sub authenticated{
    &send('admin@-----','Lamp bot online');
}

sub msgReceived { my ($err,$message) = @_;
    my $body = $message->GetBody();
    my $from = $message->GetFrom();

    $from =~ s#/.*$##; #Get rid of anything after bleh@wahtever.com
    $body =~ s/[^a-zA-Z0-9]//g;  #Get rid of characters that arent alphanumeric
    $body = lc($body);        #Make $body all lower case.

    if($body eq "?" or $body eq "help")
    {
        sendHelp($from);
    }
    elsif($allowFaffage == 1)
    {
        if($body eq "random")
        {
            `echo 'r' > $device`;
        }
        elsif($body eq "white")
        {
            `echo w > $device`;
        }
        elsif($body eq "off")
        {
            `echo o > $device`;
        }
        elsif($body eq "fade")
        {
            `echo i > $device`;
        }
    }

    #Admin things...  Enable and disable the lamp
    #so people can't wake you in your sleep.
    if($from eq 'admin@-----')
    {
        if($body eq "quit")
        {
            exit();
        }
        elsif($body eq "enable")
        {
            $allowFaffage = 1;
            &send($from,'Faffing enabled');
        }
        elsif($body eq "disable")
        {
            $allowFaffage = 0;
            &send($from,'Faffing disabled');
        }
    }
}

If you’re unfamiliar with PERL, the above script might be pretty horrific, but hopefully the comments in the code will help you work out what’s going on. If you’d like to learn more about programming in PERL, there’s a ton of information on the internet, including the PERL documentation.

Most of the logic is in the msgReceived function, which is executed whenever a message is received. The algorithm is very basic – get the body of the message we just received, then sanitise it, then compare it to various strings until we know what the user wants to happen. Simple… The above code runs locally on my plug computer, next I’ll take you through the code that runs on the server.

The Server

The server is actually running two pieces of code – a PERL script, which is similar to the one above and is used to communicate with the client over Jabber; and a PHP script which generates the user interface, and communicates with the PERL script when users choose to perform an action.

This might seem (and probably is) over complicated, but I’ll quickly explain my reasons for choosing this architecture.

• Firstly, PHP is stateless, i.e. variables aren’t stored between page loads (unless using sessions, or cookies), and usually when a script is finished executing any connections that it has opened are closed.  If I were to use just a single PHP script for generating the interface then communicating with the lamp, every time the script is loaded, a new connection to the Jabber serer would have to be made.  This slows down the load time of the page, and increases the load on both the web server and the jabber server.
• Secondly, there is a good chance that two requests could be made to the server at the same time, if this were to happen, there would be two attempts to connect to the jabber server with the same user (which isn’t allowed).

To fix this I decided that it would be nice to have a single script that is always connected to the jabber server, and can be communicated with using local Unix sockets.

The PERL

This code is fairly similar to the code above, so I won’t explain too much about it. I’ll jump straight to talking about the well named ‘doyourshiz’ subroutine. Avert your gaze if you are of a nervous disposition.

#!/usr/bin/perl                                       

use Net::Jabber;
use Data::Dumper;
use Socket;      

my $server = "-----";
my $port = 5222;
my $username = "-----";
my $password = "-----";           

my $client = new Net::Jabber::Client();

my $allowFork = 0;

my $insockpath = "/home/freud/lampsocket";

#Detatch from the terminal if we're allowed to.
if($allowFork == 1 && fork())
{
        exit();
}                                              

$client->SetCallBacks(message=>\&msgReceived, onauth=>\&authenticated);

$client->Execute(hostname=>$server,
          tls=>0,
          username=>$username,
          password=>$password,
          resource=>"lamp",
          register=>0);                                                   

sub send { my($to,$body) = @_;
        $client->MessageSend(to=>"$to",subject=>"Cheese",body=>"$body");
}                                                                                                                 

sub msgReceived{
        print Dumper @_;
}                       

sub authenticated{
        print "Authenticated";
        #We're ready to send messages to the lamp,
        #Start listening for incomming comands from
        #the local socket.
        &doyourshiz();
}                                                   

sub doyourshiz{
        #Create a socket
        socket(INSOCKET, PF_UNIX, SOCK_STREAM, 0) or die("$!");

        unlink($insockpath); #Delete the file we're binding to if
                             #it already exists...

        bind(INSOCKET,sockaddr_un($insockpath)) or die("$!");
        listen(INSOCKET,SOMAXCONN) or die("$!");

        #accept blocks (makes the program wait) until someone
        # connects to the socket.
        for( ;accept(Client,INSOCKET); close Client)
        {
                open(INPUT, "<&Client");
                #Open the client's input stream to 'INPUT' then
                # read from INPUT and send it to the lamp until we've
                # read everything that was sent to us.
                while(defined($line = <INPUT>))
                {
                        chomp $line;
                        &send('lamp address',$line);
                }
                close(INPUT);
                #close the input. (the Client connection is closed in the for loop
                # definition above.).
            }
}

OK… The doyourshiz subroutine contains the main application loop. To start with it opens a Unix Socket, which appears as a special file on your file system (in the example above it has the path /home/freud/lampsocket). Any applications wanting to communicate with the above script can connect to that socket by using that special file (this will become clearer when I show you the PHP). The socket is identified inside the script by it’s identifier INSOCKET (the first argument to the socket command).

Whenever anything connects to that socket the script just relays whatever is sent to it to the lamp via Jabber. Note that at the moment, the code above will only actually accept one connection at a time (which I realise conflicts with one of my requirements above), ideally the code within the for loop above would be executed in a new thread to allow new users to connect. I’ll probably implement this soon…

Now you’ve seen the server’s PERL (which is by far the most complicated bit), it’s time to look at the PHP code.

The PHP

I started by writing a wrapper class that handled connecting and sending to the socket for me, keeping the main bulk of PHP free from socket code.

<?php
        class HSocket
        {
                private $socket;

                public function __construct($path)
                {
                        $this->socket = socket_create(AF_UNIX,SOCK_STREAM,0);
                        socket_connect($this->socket,$path);
                }

                public function __destruct()
                {
                        socket_close($this->socket);
                }

                public function send($data)
                {
                        socket_write($this->socket,$data,strlen($data));
                }
        }

?>

As you can see, the code is fairly simple. It’s pretty much the same as the PERL code above. The constructor takes an argument, which is the path to the socket you’re connecting to, and (dis)connecting is all done for you when instantiating and destroying objects from that class.

When sending data to the socket, we use the command socket_write, which takes three parameters – the socket you’re sending to, the data to be sent, and the size of the data in bytes. If you’d like to read more about socket programming in PHP check out the PHP Documentation and for those of you who would like to learn more about PHP, a good place to start is the PHP Manual, and of course Google.

Finally, the code that the user actually executes is below. This contains the buttons the user presses and it also processes the user’s actions to determine what values should be sent to the PERL script (and ultimately the lamp).

<?php
        if(isset($_GET['do']))
        {
                include('HSocket.php');
                $s = new HSocket("/home/freud/lampsocket");

                //This switch statement makes sure we don't send anything
                //malicious to the lamp.
                switch(strtolower($_GET['do']))
                {
                case "off":
                case "white":
                case "random":
                case "fade":
                        $s->send($_GET['do']);
                break;
                }
        }
?>

<html>
        <head>
                <title>
                        Light Controls
                </title>

        </head>

        <body>
                <h1>Mood Lamp</h1>
                <form action='index.php' method='get'>
                <input name='do' type='submit' value='Off'  />
                <input name='do' type='submit' value='White'  />
                <input name='do' type='submit' value='Random'/>
                <input name='do' type='submit' value='Fade'  />
                </form>
        </body>
</html>

You’ll probably be overjoyed to notice that the code above is really quite simple. It creates a socket with the same path as was used in the PERL script above, and then sends data to it depending on the value of the ‘do’ GET variable. The switch statement helps to make sure that a malicious user can’t send data to the lamp that could be used to compromise either the server, plug, or lamp.

And there you have it. If you’d like to see the code in action, check out the online control panel. Currently you can’t see the state of the light (so you’ll just have to trust me that its working), but my next step is to get a webcam pointed at it, and also to add a feature to allow users to pick a specific colour for the lamp.

If you have any questions, or any suggestions as to what I can do next, please feel free to comment below. I’ll try to respond as soon as I can. If you want to steal any of the code above, then go ahead (it would be nice if you linked back to this post).

For this project I used the Ikea Grönö, which was £4.99 when I bought it.  It quite a nice matt glass finish, which helps to diffuse light, and also it comes with the glass shade and the actual light fitting separate from one another (I put the light fitting to one side as I won’t be using it in this project).

As well as that I used…

• 3 x NPN Transistors – TIP122 5A
• 3 x 47 Ohm Resistors
• 1 x 100 Ohm Resistor
• 2 x 330 Ohm Resistors
• 2 x RJ45 connectors
• 2 x 16000mcd Red LEDs
• 2 x 18000mcd Green LEDs
• 2 x 9000mcd Blue LEDs
• 1 x Arduino Duemilanove
• Some breadboard, wire and solder…

The brightnesses above were only chosen because they were the highest that were available at a fairly reasonable cost.  It might be better to match the brightnesses of all LEDs, although if memory serves, human eyes aren’t as sensitive to blue light as they are red and green, so it might be worth getting a brighter blue LED (I advise doing some more research).

Anyway, on with the build…

Firstly, LEDs tend to be highly directional (i.e most light goes in front of the led).  There seem to be lots of diffusing and mixing lenses available at various shops, but I decided I’d have a go at just scuffing the LEDs with some sandpaper.  I was quite happy with the diffusion of light after having done that, so my next step was to breadboard the LEDs out.  I arranged them into a triangular shape with a common ground rail on the breadboard, and individual positive rails for each diode.

In this project I’ve used the 5V supply from the arduino, my LEDs however were expecting

• Red: 1.9V 50mA
• Green, Blue: 3.4V 20mA

Therefore resistors must be added to stop the components from being ‘popped’ (trust me, blown up LEDs stink).  The required resistance can be easily calculated using Ohms Law – V = IR.

V = The potential difference across the resistor (Volts).

I = The current in the circuit in series with the resistor (Amps).

R = The resistance of the resistor (Ohms).

So, we need the following values.

• Red: R = V/I = (5.0 – 1.9) / .050 = 3.1 / .050 = 62 Ohms
• Green, Blue: (5.0 – 3.4) / .020 = 1.6 / .02 = 80 Ohms

Simple… Here’s a video of the lamp shade placed over the breadboarded leds.

Although you can’t see it in that video, with only one LED of each colour it was far too hard to see when the surrounding light levels were high so I decided I’d add another led of each colour so they were arranged as in the following diagram.

LED Arrangement in Arduino mood lamp

I used three TIP122 NPN Transistors to allow the LEDs to draw more current than if I were just feeding them directly from the PWM outputs on the Arduino. The diagram below shows the circuit design as it was breadboarded out.  This is in fact basically the same as the final circuit diagram (except with an Cat 5 patch cable separating the transistors from the resistors and LEDs).

The breadboarded mood lamp circuit. Numbers in circles correspond to the digital output pins on the Arduino. R1 = 100 Ohms, R2 = 47 Ohms, R3 = 330 Ohms.

Note the resistors and LEDs in parallel.  Now that the LEDs are in parallel, the series part of the circuit must have twice the current required by the LEDs (Red: 100mA, Green and Blue 40mA).  Therefore we require the following resistances.

• Red: 31 Ohms
• Green, Blue: 40 Ohms

You could of course just go to the next resistor size up, but I like to make things complicated so I decided I’d try to get as close as I can with the resistors that I had at my disposal.  When combining resistors in parallel, the total resistance of the resistors in parallel is  1/R = 1/R1 + 1/R2 + … + 1/Rn

In the above diagram, R1 = 100 Ohms, R2 = 47 Ohms, R3 = 330 Ohms, meaning that the resistances above are

• Red: 1/R = 1/100 + 1/47.  R = 32 Ohms
• Green, Blue: 1/R = 1/47 + 1/330.   R = 41 Ohms

So, after breadboarding that and finding everything worked, I soldered everything to two breadboards.  One containing the LEDs and Resistors, another containing the transistors and leads to connect to the arduino.  I also soldered some RJ45 sockets on to the boards, to allow me to connect the two components together over long distances (I could have used other means, but I have miles of patch cable lying around).  Something to remember when soldering the RJ45 sockets is that if you don’t plan on using crossover cable, you should solder the two sockets in reverse to one another as in the diagram below.

An example of how you could solder the connections on your RJ45 sockets.

Once you’ve done that, connect everything up and make sure everything works before glueing the LEDs to the bottom of your lamp.  Then you’re pretty much done (except for coding the actual Arduino).  The code I have so far is very simple, it simply fades between colours.

const int led[] = {3,5,6};
const int delayTime = 10;
#define RG 0
#define GB 1
#define BR 2
void setColour(const int * led, const int * colour)
{
    for(int i = 0; i < 3; i ++)
    {
        analogWrite(led[i],colour[i]);
    }
}
void cycle(int which, const int * led)
{
    int a;
    int b;
    switch(which)
    {
        case RG:
            a = led[0];
            b = led[1];
        break;
        case GB:
            a = led[1];
            b = led[2];
        break;
        default:
            a = led[2];
            b = led[0];
    }
    for(int i = 0; i <= 255; i ++)
    {
        analogWrite(b, i);
        analogWrite(a, 255 - i);
        delay(delayTime);
    }
}
void setup()
{
    for(int i = 0; i < 3; i++)
    {
        pinMode(led[i],OUTPUT);
    }
}
void loop()
{
    cycle(RG, led);
    cycle(GB, led);
    cycle(BR, led);
}

And the moment you’ve all been waiting for – a video of the final product…