© Katrin Bpunkt, Photocase.com

Zauberhaft einfach: Mit ein paar Zeilen selbst geschriebener Firmware und einem simplen Perl-Skript lässt Perlmeister Schilli einen seiner Linux-Rechner mit angestöpseltem Arduino-Board elektrische Geräte jeder Art per Relais ein- und ausschalten.

Jeden morgen um vier Uhr früh schaltet das Ubuntu-System in meinem Büro einen uralten Debian-PC in der Ecke mit 6 TByte Plattenplatz an, um per Rsync ein Backup wichtiger Daten zu ziehen. Dazu stellt es per Heim-Vernetzungsprotokoll X10, das in den USA populär ist, über das Stromnetz den Strom am Backup-PC an. Dieser fährt selbsttätig hoch, da in seinem Bios die Option »After Power Loss« auf »On« gesetzt ist. Sobald der SSH-Server des gestarteten Debian-Systems antwortet, startet das Backup. Nach dem Schlussakkord fährt der PC wieder herunter und der steuernde Rechner entzieht ihm wieder den Strom.

Da mein X10-Setup aber aus unerfindlichen Gründen in geschätzt einem von 100 Fällen versagt, habe ich die PC-an/PC-aus-Steuerung auf ein Arduino-Board (rund 20 Euro) mit angeschlossenem Relaisboard (5 bis 10 Euro) umgestellt. Über den USB-Port schickt der steuernde Ubuntu-Rechner ein Kommando zu dem an einer seriellen Schnittstelle lauschenden Microcontroller.

Dessen Firmware schaltet den Pegel auf einem Ausgangs-Pin um, den ich mit einem von zwei Relais einer extra Platine verbunden habe [2]. Abbildung 1 zeigt die mit einem so genannten Breadboard aufgebaute simple Schaltung, die zu Testzwecken auch noch per Leuchtdiode anzeigt, ob ein bestimmter Ausgangs-Pin des Arduino an oder aus ist.

Das ans Stromnetz angeschlossene Relais zieht mit einem Klicken an, der am anderen Ende des Relais verkabelte Stecker bekommt Netzspannung und der dort eingesteckte Verbraucher erwacht. Das verwendete Relais verträgt bis zu 5 Ampere bei 250 Volt (Abbildung 2).

Abbildung 1: Versuchsaufbau der Schaltung mit Arduino, Leuchtdiode und netzspannungstauglichem Relaisboard.

Abbildung 2: Das Schaltboard mit zwei Relais, die Geräte bis 5 Ampere bei 250 Volt steuern können.

Einfach programmierbar

Anders als Industrie-übliche Microcontroller lässt sich das Arduino-Board direkt über ein USB-Interface programmieren. Ein PC oder Mac schickt kompilierten, C-ähnlichen Code rüber, den der Arduino speichert. Dank seines Urladers läuft diese eingespielte Firmware bis zum Sankt-Nimmerleins-Tag.

Der USB-Port versorgt das Board nicht nur mit Signalen zum Steuern der Firmware, sondern auch mit der nötigen Betriebsspannung zum Betrieb der Elektronikkomponenten. Das Board und die Relaisplatine benötigen also keine externe Spannungsquelle. Nach jedem Kaltboot fängt der Code sofort wieder an zu laufen. Um die Pins des Arduino von einem PC aus an- und auszuschalten, muss auf dem Arduino ein Programm auf Befehle von der USB-Schnittstelle horchen und diese ausführen.

Wenn nicht Stangenware, dann eben Maßanzug

Als Fertiglösung käme statt eines selbst geschriebenen Programms auch Firmata [3] in Betracht, eine freie, generell verwendbare Firmware. Einmal auf den Arduino geladen, erwartet sie Kommandos über das USB-Interface nach dem Firmata-Protokoll, manipuliert auf Anfrage den Strom auf den Pins oder liest ihre Werte aus und liefert Antworten zum anfragenden Hostrechner zurück.

Allerdings operiert das gekaufte Relaisboard von der Firma Sainsmart [2] im Low-Active-Modus, das Relais schnappt also zu, falls die Spannung am Eingang abfällt, und lässt los, falls 5 Volt anliegen. Da Firmata die Ausgangs-Pins aber beim Hochfahren immer auf Low stellt, würde das jedes Mal nach dem Einstöpseln des USB-Steckers den elektrischen Verbraucher einschalten, bevor ein Programm die Kontrolle übernehmen könnte.

Mein selbst geschriebener Arduino-Sketch – so nennt die Arduino-Community Sourcecode für die Firmware – in Listing 1 setzt deswegen in der Funktion »setup()« die Ausgangsspannung am Pin 11 mit

digitalWrite( 11, HIGH );

sofort auf 5 Volt, sobald der Arduino hochfährt. Später, in der Hauptschleife »loop()« , prüft die Methode »available()« des Moduls »Serial« , ob Daten an der seriellen Schnittstelle des Arduino anliegen. Falls ja, liest »Serial.read()« ein anliegendes Byte aus und speichert es in der Variablen »val« . Hat der Host das Zeichen »1« geschickt (Ascii-Code 49), setzt die Firmware Pin 11 auf Low – und auf der dort angeschlossenen Relaisplatine zieht das Relais an.

01 /* Simple relay controlling firmware
02  * Mike Schilli, 2013 (m@perlmeister.com)
03  */
04
05 void setup() {
06   Serial.begin(9600);
07   pinMode(11, OUTPUT);
08   digitalWrite( 11, HIGH );
09   pinMode(13, OUTPUT);
10   digitalWrite( 13, LOW );
11 }
12
13 void loop() {
14   while( Serial.available() > 0 ) {
15     int val = Serial.read();
16     Serial.print( val );
17     if( val == '1' ) {
18       digitalWrite( 11, LOW );
19       digitalWrite( 13, HIGH );
20     } else {
21       digitalWrite( 11, HIGH );
22       digitalWrite( 13, LOW );
23     }
24   }
25 }

USB oder seriell

Microcontroller hören traditionsgemäß auf Kommandos, die vom Host über eine serielle Schnittstelle ankommen. Doch bieten PCs seit vielen Jahren schon keine 9-Pin-Buchsen mehr an, sondern eine Reihe von USB-Steckplätzen. Das ist auch nicht weiter schlimm, denn USB und das serielle Interface lassen sich leicht mit einem Chip (USB-to-Serial Converter) ineinander umwandeln.

Auf alten Arduino-Boards steckt deswegen noch ein extra Chip, der die USB-Signale in serielle Kommandos umwandelt, die der Microcontroller versteht. Der relativ neue Arduino Leonardo kommt erstmals mit einem Microcontroller daher, der von Haus aus USB versteht. Der Host schickt aber weiterhin serielle Signale.

Auf dem Breadboard in Abbildung 1 habe ich auf Pin 13 auch noch eine Leuchtdiode mit 220-Ohm-Widerstand angeschlossen, und da die Firmware Pin 13 entsprechend dem eingegangenen Kommando setzt (also invers zum Relais-Ausgangs-Pin), schaltet sich die LED an, wenn das Relais aktiv ist.

Mit der in Java geschriebenen Arduino-IDE ([3], [4]) lässt sich die Firmware nun hochladen, wie in Abbildung 3 zu sehen ist. Die IDE findet an ein Linux-System angeschlossene Arduinos normalerweise selbstständig, allerdings ist zu beachten, dass manche älteren Arduino-Boards andere Device-Schnittstellen verwenden: Die serielle Schnittstelle eines relativ aktuellen “Arduino Uno”-Board ist auf dem Hostsystem so unter »/dev/ttyACM0« zu erreichen, während ein schon etwas in die Jahre gekommener “Arduino Duemilanove” auf »/dev/ttyUSB1« horcht.

Die IDE unterstützt alle jemals herausgekommenen Boardversionen, und der User kann das aktuell verwendete Board in einem Drop-Down-Menü auswählen.

Listing 1. Der speichert das Programm auf Dauer.” width=”263″ height=”300″ /> Abbildung 3: Die Arduino-IDE lädt die Firmware in den Microcontroller, hier das Skript aus Listing 1. Der speichert das Programm auf Dauer.

Klick and dirty

Zum schnellen Testen der Firmware eignet sich der »Serial Monitor« im »Tools« -Menü der IDE, der Zeichen zum Arduino sendet und die Antwort der Firmware im Textfenster darstellt. Der Sketch in Listing 1 schickt jedes empfangene Zeichen mittels »Serial.print()« wieder an den Host zurück. Abbildung 4 zeigt, wie ich das Zeichen 1 an den Arduino sende und von der Firmware mittels »Serial.print()« den Ascii-Code 49 zurückerhalte. Gleichzeitig zieht das Relais an und die LED leuchtet.

Was nun noch fehlt, ist ein Perl-Skript, das sich an der seriellen Schnittstelle am USB-Port andockt und dem Arduino Kommandos schickt: Listing 2. Es nimmt von der Kommandozeile entweder »on« oder »off« entgegen. Das über das serielle Interface zu übermittelnde Zeichen ist also 1 oder 0, das Zeile 31 an den mit dem CPAN-Modul Device::SerialPort gebundenen Port schickt.

Um zu verifizieren, dass der Arduino das Kommando auch erhalten und den gewünschten Ausgangs-Pin gesetzt hat, liest das Skript in Zeile 35 mit »read()« die von der Firmware zurückgeschickten Daten. Kommt nichts an, geht das Skript mit »redo« in die nächste Runde und unternimmt einen weiteren Schreibversuch. Wie Abbildung 5 zeigt, können einige Durchgänge nötig werden, insbesondere wenn ich den Arduino gerade erst eingestöpselt habe. Das Skript nutzt Log4perl im »$DEBUG« -Modus; wer es weniger geschwätzig mag, sollte Zeile 6 dahingehend modifizieren, dass der Loglevel »$ERROR« beträgt.

Abbildung 4: Auf der seriellen Konsole der IDE schickt der Host-Benutzer Kommandos zum Ein- und Ausschalten des Relais.

Abbildung 5: Nach dem vierten Write-Kommando kommt die Antwort des Arduino zurück.

01 #!/usr/local/bin/perl -w
02 use strict;
03 use Device::SerialPort;
04 use Pod::Usage;
05 use Log::Log4perl qw(:easy);
06 Log::Log4perl->easy_init($DEBUG);
07
08 my( $cmd ) = @ARGV;
09
10 if( !defined $cmd ) {
11     pod2usage();
12 }
13
14 my $byte;
15
16 if( $cmd eq "on" ) {
17     $byte = "1";
18 } elsif( $cmd eq "off" ) {
19     $byte = "0";
20 } else {
21     pod2usage();
22 }
23
24 my $dev = Device::SerialPort->new(
25    "/dev/ttyACM0",
26   1,
27 );
28
29 {
30     DEBUG "Writing ...";
31     $dev->write( $byte );
32
33     DEBUG "Reading ...";
34     my $bytes = 2;
35     my( $count, $data ) = $dev->read( $bytes );
36
37     DEBUG "Got $count bytes";
38
39     if( $count != $bytes ) {
40         sleep 1;
41         redo;
42     }
43     DEBUG "Received: \"$data\"\n";
44 }
45
46 $dev->close();
47
48 __END__
49
50 =head1 NAME
51
52     relay - Switch relay on and off
53
54 =head1 SYNOPSIS
55
56     relay on|off
57
58 =head1 AUTHOR
59
60 2013, Mike Schilli <m@perlmeister.com>

Netzspannung einhegen

Da am Relais saftige 230 Volt Wechselspannung anliegen, habe ich die endgültige Version meines Selbstbauprojekts ohne das Breadboard mit einem stabilen Gehäuse umhüllt und die Niedervolt-Platine sauber von herumbaumelnden Netzkabeln getrennt (Abbildung 6). Die Relaisplatine verfügt zum Glück über stabile Schraubklemmen, um die Netzkabel mit dem Relais zu verbinden.

Wer mit verpolungssicheren Steckern hantiert, sollte mit dem Relais die Phasenleitung schalten, nicht etwa den Nullleiter. Softwerker, die sich nicht ganz sicher sind oder nicht genug Erfahrung beim Arbeiten mit Netzspannung haben, sollten einen Fachmann hinzuziehen statt Experimente auf gut Glück anzustellen – das Linux-Magazin will seine Leserschaft nicht durch Herzkammerflimmern dezimiert sehen.

Abbildung 7 zeigt die amerikanische Version des USB-Schalters, mit den in den USA üblichen 110-Volt-Flachsteckern. Auch verwenden amerikanische Elektriker keine Lüsterklemmen zum Verbinden von Litzenkabeln, sondern schrauben pragmatisch farbige Hütchen mit innenliegendem Metallgewinde auf, die “Twist-on Wire Connectors” [6].

Das robuste Gehäuse aus dem Baumarkt ist eigentlich für die wetterfeste Verdrahtung von Stromkabeln im Haus gedacht und verleiht meinem Hobbyprojekt einen rustikal-industriellen Touch – vielleicht ist ja einer der Einkäufer bei Manufactum (“Es gibt sie noch, die guten Dinge”) unter den Linux-Magazin-Lesern?

Abbildung 6: In ein Gehäuse frisch aus dem Baumarkt eingebaut …

Abbildung 7: … ergibt sich eine Art industrielles Design.

Ein großes Reich für König Arduino

Mein Schalt-den-Debian-an-Aufbau siedelt am unteren Ende der Möglichkeiten der Arduino-Technik. Die Zahl der Selbstbauprojekte mit der günstigen Platine ist nicht nur über die Jahre enorm angewachsen, es hat sich auch ein sympathisches Ökosystem aus Erfindern und Produktanbietern entwickelt.

Wer Details zur Arduino-Programmierung sucht, dem bietet [7] eine ausgezeichnet fundierte und detaillierte Einführung. Der Name des Open-Source-Boards soll übrigens gastronomischen Ursprungs sein: In der norditalienischen Kleinstadt Ivrea gibt es die “Bar di Re Arduino” (Bar des Königs Arduin, [8]), die den Arduino-Erfindern wohlbekannt ist.

Der Autor

Michael Schilli arbeitet als Software-Engineer bei Yahoo in Sunnyvale, Kalifornien. In seiner seit 1997 laufenden Kolumne forscht er jeden Monat nach praktischen Anwendungen der Skriptsprache Perl. Unter mailto:mschilli@perlmeister.com beantwortet er gerne Fragen.