A stack on the Arduino

 I have put together a collection of Python scripts which allow me to build proper C++ programs for the Arduino Uno and Mega 2560 from the command line, and upload them all in one go. At the moment, these are only working in Linux but I think I know enough now that in principle I could get this going on Windows, possibly within Dev-C++ - a project for after Christmas, I think.

Home Made

I used to be really, really terrible at soldering things. Thank goodness for instructional videos on YouTube. The board was programmed by the method described in the previous post.

Bypassing the IDE

A colleague has objected, justifiably, that the Arduino can't be used for teaching C/C++ as it stands because of the way the environment works (hiding the main function, and confusing issues of scope, global variables, etc).  Judging by a conversation I had this afternoon there is probably no money in the equipment budget to buy fifty of the things for next year's programming course anyway, but it would be nice to try.  There are various tutorials on the web dealing with using the avr-gcc compiler directly, mainly reliant on using modified makefiles.  The Arduino 1.0 release seems to have broken these (some of the files are now in different directories, some have disappeared), so I tried looking at the output if you ask the Arduino environment to give detailed output on compilation and upload (in File / Preferences).

Arduino classes

Underneath the Arduino programming environment is C++, but I didn't think I'd be trying to find my copy of Leendert Ammeraal's C++ for Programmers this Friday afternoon (I have Stroustrup, of course, but it's not a book to find a quick and easy solution in).  I hooked up four of the RGB LED units to the Arduino Mega's 12 PWM pins, and wanted to implement a little algorithm I had run with one unit earlier in the week - set a random "target" value for the RGB values, gradually increase (or decrease) the intensity to reach the target, and then set a new random target.  The effect is to gradually change the colour and intensity of each unit, but in a pleasant drifting manner rather than jumping around all over the place.  Once I had written the code, I looked for ways to make it simpler - first using a struct, but there are difficulties writing functions for the Arduino which take a struct as a parameter (as I understand it, the pre-processor shuffles the code around so that your function ends up before the struct declaration, which means the compiler doesn't recognise the struct when it comes to compile the function).  The answer was to go straight to writing a C++ class, which turned out to be fairly simple (though I did try writing a proper constructor function, and was reminded what a complete bloody nightmare that can be especially on a Friday afternoon in a very warm office when you haven't written any O-O C++ code for about a decade - once you start dabbling in constructors, you need to think hard about copy constructors, destructors, deep and shallow copies, all that stuff).

Arduino Mega and ethernet shield

I bought an Arduino Mega 2560 to reward myself for doing well in a philosophy module.  To connect it to the ethernet shield, the solution in the Arduino forum works - connect pins 11, 12 and 13 on the ethernet shield to 51, 50 and 52  on the Mega (in that order, of course).

Edit: the Mega sorted out the problems I'd been having with getting a web server to read off the SD card - with the Arduino Uno it kept falling over and resetting the board, with the same code on the Mega I was able to run a slow, but quite usable, server.

Scrolling text with shift registers

Using a couple of 74HC595 shift registers, I have done away with most of the wires leading from the Arduino to the breadboard. This also simplifies the code - simply send a couple of bytes to the first shift register, and the data sorts itself out (the first byte is displaced by the second one and flows into the second shift register - I will probably add a third to the chain, to control the green LEDs).  The text is now proportionally-spaced, rather than using 8 pixels per character.

Edit: adding a third shift register to the chain worked, but at the price of making the display rather dim (because of the time spent transferring all the data, I suspect).  The green LEDs aren't as bright as the red ones, which made the effect worse - the red ones were just about acceptable.

Space invaders!

This is heavily adapted from the code on the Oomlout web site. I'm defining "sprites" called invader1, invader2 and blank, then in the loop() function I have an array of pointers to these sprites. There is an array led_state which stores the current state of the LED array, and at each cycle I am shifting every row rightwards and overwriting with the relevant portion of the next sprite. There is a lot of bit-masking and shifting going on. The next project is to replace the unwieldy wiring by using the shift register chips which are visible on the bottom right of the video - as described on the Arduino website.

Another web server

Still not much of a server - it is simply sending back the same page whatever the client requests.  But I have set it up so that the values of the three potentiometers change the colour of the background of the page, and it displays the values of the temperature sensor and light sensor. Apologies for the blurriness of some of this - the Flip camera doesn't do close-ups very well (or maybe I haven't worked out how to make it do close-ups).

My own web server

This is adapted to some extent from the web server and SD code examples. As with the web server example, this is currently interpreting any HTTP request as GET / HTTP/1.1 - the twist is that it is reading index.htm from the SD card, and serving that. If it can't open and read index.htm, it sends a 404 response. I've also written a function which reads in the request headers one line at a time, and the server then prints them to the serial console (a little like the error log on a full-sized server, and I'm intending to try to use that information later on).

Arduino web server

Considering I had no experience using these things this morning (although I read Massimo Banzi's Getting Started with Arduino while on strike yesterday), I think this is pretty good.

LED matrix

What the life of man is like in the state of nature according to Thomas Hobbes. I had to make minor modifications to the code (renaming a variable from A3 to A33), but this is entirely from http://oomlout.com/LEDMS including the wiring. I am impressed that I managed to wire it all up correctly first time, though. Hobbes's life was none of these things, of course.

Here are buried the bones of Thomas Hobbes of Malmesbury who for many years served the two Earls of Devonshire, father and son. A sound man and well known at home and abroad for the renown of his learning. He died in the year of our lord 1679 on the 4th day of the month of December in the 91st year of his age.

Arduino

Not the most impressive program I have ever written, but considering the Arduino only arrived this morning it's not a bad start (I also have an 8x8 LED array which I will be playing around with later). Setting up the Arduino development environment on Linux was simple: downloaded and unzipped the IDE, installed the gcc-avr and avr-libc packages, and added myself to the dialout group (sudo usermod -aG dialout nja) as described on this page. [Edit: on my home netbook, running Ubuntu 11.10 rather than Linux Mint, I had to edit /hardware/arduino/cores/arduino/wiring.h and comment out the line starting #define round (line 79), as described here]

const int RED_LED = 9;
const int AMBER_LED = 10;
const int GREEN_LED = 11;
const int ON = 0xFF;
const int OFF = 0x00;

void setup()
{
  pinMode(RED_LED, OUTPUT);
  pinMode(GREEN_LED, OUTPUT);
  pinMode(AMBER_LED, OUTPUT);
}

void loop()
{
  analogWrite(AMBER_LED, OFF);
  analogWrite(RED_LED, ON);
  delay(1000);
  analogWrite(AMBER_LED, ON);
  delay(1000);
  analogWrite(RED_LED, OFF);
  analogWrite(AMBER_LED, OFF);
  analogWrite(GREEN_LED, ON);
  delay(1000);
  analogWrite(AMBER_LED, ON);
  analogWrite(GREEN_LED, OFF);
  delay(1000);  
}