Like Magic

Every morning at four o'clock, the Ubuntu system in my office switches on an ancient Debian PC with 6TB of disk space to grab a backup of important data via rsync. It uses the popular home networking protocol X10 to switch on the power on the backup PC via the power grid. The backup PC boots automatically, because its Boot After Power Loss BIOS option is set to On. Once the SSH server on the running Debian system responds, the backup starts. After the final act, the PC shuts down, and the controlling Ubuntu box cuts the power.

Because my X10 setup fails for some reason in an estimated 1 out of 100 cases, I have now converted the PC on/off control to an Arduino board (around US$ 20) with an attached Relay Board (US$ 12). The controlling Ubuntu machine uses the USB port to send a command to the microcontroller, which listens on a serial interface.

The microcontroller's firmware switches the signal on an output pin, which I have connected to one of two relays on an extra board [1]. Figure 1 shows the set up with a simple circuit on a breadboard. For test purposes, it even uses light-emitting diodes to indicate whether a specific output pin on the Arduino is on or off.

Figure 1: Experimental circuit setup with the Arduino, LED, and power grid-capable relay board.

The grid-connected relay actuates with a click; the main power connector wired to the other end of the relay switches on, and the consumer plugged into it wakes up. The relay I use can handle up to 10 amps at 250 volts (Figure 2) – more than enough to operate a regular home PC.

Figure 2: The circuit board with two relays that can control devices up to 10 amps at 250 volts.

Easily Programmable

Unlike industry-standard microcontrollers, the Arduino board can be programmed directly via a USB interface. A PC or Mac uploads compiled, C-like code that the Arduino then stores permanently. Thanks to its bootloader, the firmware installed in this way runs infinitely after the board is plugged in.

The USB port provides the board not only with signals for controlling the firmware but also with the required supply voltage for operating the electronic components. The board and the relay board do not need an external power source. After each cold boot, the code immediately starts to run. To switch the Arduino pins on and off from a PC, the uploaded Arduino firmware listens for commands from the USB port and switches its output pins accordingly.

Off-the-Shelf vs. Tailor-Made

As a turnkey solution, you could use Firmata [2], free, general-purpose firmware, instead of writing a firmware program yourself. Once loaded on the Arduino, the firmware awaits commands via the USB interface in line with the Firmata protocol, manipulates the voltage on the board's digital output pins as needed (or reads their values), and provides feedback to the requesting host.

However, the relay board that I purchased from SainSmart [1] operates in low-active mode. In other words, the relay closes if the input voltage drops off and opens if a 5-volt supply is provided. Because Firmata always sets the output pins to low at startup, this approach would switch on the electric consumers every time the USB connector was plugged in – before a program could take control.

Consequently, my do-it-yourself Arduino Sketch  – which is what the Arduino community calls firmware source code  – uses the setup() function in Listing 1 [3] to set the output voltage at pin 11 immediately to 5 volts when the Arduino boots up:

digitalWrite( 11, HIGH );

Later, in the main loop(), the Serial module's available() method checks whether data exists on the Arduino's serial port. If so, Serial.read() reads an incoming byte and stores it in the val variable. If the host has sent a 1 (ASCII code 49), the firmware sets pin 11 to low, and the relay is energized on the relay board connected to it.

Serial via USB

Microcontrollers traditionally listen for commands that arrive from the host via a serial interface. Unfortunately, PCs did away with nine-pin sockets years ago in favor of a number of USB slots. That's not too much of a problem, though, because the USB and serial interfaces can be converted easily both ways using a chip (USB-to-serial converter).

This bit of history explains why there is still an extra chip that converts the USB signals into serial commands, which the microcontroller understands, on the old Arduino boards. The relatively new Arduino Leonardo is the first to use a microcontroller that natively understands USB. However, the host continues to send serial signals.

On the breadboard in Figure 1, I have also connected an LED with a 220-ohm resistor to pin 13. And, because the firmware sets pin 13 to reflect the incoming command (i.e., it does the opposite of the relay output pin), the LED lights up when the relay is active.

Using the Arduino IDE written in Java [4] [5], the firmware can now be uploaded as shown in Figure 3. The IDE normally discovers Arduinos connected to a Linux system without any help; however, some older Arduino boards use different device interfaces. The serial interface on a relatively recent "Arduino Uno" board, for example, is accessed on the host system as /dev/ttyACM0, whereas the fairly ancient "Arduino Duemilanove" still goes by the name /dev/ttyUSB1.

Figure 3: The Arduino IDE loads the firmware into the microcontroller. In this case, it's the script in Listing 1. The board stores the program permanently.

The IDE supports all board versions ever to have been released, and the user can select the board currently used from a drop-down menu.

Click and Dirty

For quick testing of the firmware, you can use the Serial Monitor in the Tools menu of the IDE; it sends characters typed into the input field to the Arduino and displays the response from the firmware in the text window below. The sketch in Listing 1 uses Serial.print() to echo each character it receives back to the host. Figure 4 shows me sending the character 1 to the Arduino, which uses the Serial.print() firmware to return ASCII code 49. At the same time, the relay is energized and the LED lights up.

Figure 4: Working at the serial console of the IDE, the host user sends commands to turn the relay on and off.

Still missing from the setup is a Perl script that attaches itself to the serial port of the controlling host and sends commands to the Arduino (Listing 2). It accepts either on or off on the command line. The information to be transmitted via the serial interface character is then translated to be either 1 or 0, which line 31 then sends to the port bound by the script, courtesy of the CPAN Device::SerialPort module.

To verify that the Arduino has received the command and set the desired output pin, the script uses read() in line 35 to read the data returned by the firmware. If nothing arrives, the script uses redo to re-enter the loop and make a further attempt to write. As Figure 5 shows, a number of cycles may be necessary, especially if you have just plugged in the Arduino. The script uses Log4perl in $DEBUG mode; if you prefer something less chatty, modify line 6 to change the log level to $ERROR.

Figure 5: After the fourth write command, the Arduino returns a response.

Fencing in the Mains Voltage

The relay switches 120 volts AC in the United States, so I wrapped the final version of my DIY project without the breadboard in a stable housing and clearly isolated the low-voltage board from the power cables (Figure 6). The relay board has stable screw terminals to connect the power cable to the relay.

Figure 6: Freshly installed in an enclosure from the hardware store …

People who use reverse polarity-protected plugs should switch the phase line with the relay, not the neutral. Software specialists who are not sure, or do not have enough experience in working with mains voltage, should call in a specialist instead of relying on luck in their experiments – Linux Pro does not want to see its readership decimated by ventricular fibrillation.

Figure 7 shows the US version of the USB switch with typical US-style 110-volt flat connectors. American electricians do not use European-style chocolate strip for connecting stranded wire; they pragmatically bolt on colored screw caps with internal metal thread, so-called "twist-on wire connectors" [6]. The robust housing from the hardware store is designed to weatherproof power cable wiring in the home and gives my hobby project a rustic and industrial touch.

Figure 7: … the project aspires to a kind of industrial design.

A Great Empire for King Arduin

My switch setup is pretty low-end compared with the possibilities of Arduino technology. The number of DIY projects with the inexpensive board has grown enormously over the years and has given rise to a sympathetic ecosystem of inventors and component manufacturers.

If you are looking for details of Arduino programming, an excellent and detailed introduction is available in Jeremy Blum's Exploring Arduino book [7]. Incidentally, the name of the open source board is said to come from the field of catering: In the northern Italian town of Ivrea is the "Bar di Re Arduino" (Bar of King Arduin [8]), which is well known to the Arduino inventors.