Einen Arduino Mikroprozessor programmiert man auf einem Mac mit der kostenfreien Arduino Software. C dient als Programmiersprache für die Sketches genannten Arduino-Programme. Wie einfach das geht, soll ein kleines Beispielprojekt zeigen: Die Nearly Useless Paper Machine 01 (NUP-M01) besteht (fast) komplett aus Pappe. Ein Arduino Uno R3 steuert einen sehr einfachen Drei-Achsen-Roboterarm an, der einen Kaffee oder Tee in einer Tasse umrührt.
Material und Werkzeug
Die Materialien zum Bau der NUP-M01-Umrührmaschine sind überschaubar: Neben einem Arduino Uno R3 Mikroprozessor benötigt man ein 9-Volt-Netzteil, ein Breadboard, ein paar Steckkabel, drei Servos, eine Infrarot-Empfänger-Diode, eine IR-Fernbedienung, etwas Bastel-Leim, zwei Büroklammern, eine Wäscheklammer, ein paar alte Versandkartons und etwa sechs Stunden Zeit. Eine Schere, ein Bastelmesser, ein Lineal, ein Bleistift, ein kleiner Kreuzschlitz-Schraubendreher sowie eine Spitzzange benötigt man zum Anfertigen der Einzelteile und den Zusammenbau. Ein Mac mit OS X Betriebssystem dient als Programmier-Plattform, die passende Programmier-Software gibt es für lau auf der Arduino Webseite.
Aus Pappe, aber nicht von Pappe
Pappe als Bastelmaterial hat gegenüber Holz und Metall einen entscheidenden Vorteil: Es lässt sich sehr einfach verarbeiten. Eine Schere und ein Bastelmesser genügen, um auch komplexe Formen ohne großen Aufwand auszuschneiden. Da in fast jedem Haushalt alte Versandkartons rumliegen dürften, ist es außerdem sehr preiswert. Wenn man sich mal verschneidet, muss man sich also nicht ärgern, teures Material verschwendet zu haben.
Über mangelnde Festigkeit muss man sich bei Pappe keine Sorgen machen. Versandkartons sind von Haus aus durch die eingearbeitete Wellenstruktur recht stabil. Durch geschicktes Verkleben mehrerer Pappschichten in Sandwich-Bauweise kann man sehr stabile Bauteile erstellen. Ein Bastelkleber gibt zusätzlichen Halt.
Aufbau des Roboterarms
Die NUP-M01 besteht hauptsächlich aus einem Roboterarm, der aus einem einzelnen Pappstück gefertigt ist. Als Gelenke dienen einfache Falze. Der Arm ist durch Pappstreben verstärkt und auf einer drei-lagig verklebten dickeren Pappe geklebt. Zwei Servos mit einer Zugkraft von bis zu 2 kg steuern die Bewegungen der beiden Achsen. Das Servo zum Kippen des gesamten Roboterarms ist an zwei Blöcken angeschraubt, die aus mehreren Pappschichten aufgebaut sind. Verklebt ist nichts, damit man das Servo austauschen kann.
Auch das zweite Servo ist geschraubt. Es sitzt in einer Aussparung des Roboterarms. Pappverstärkungen nehmen die Schrauben auf und sorgen für festen Halt. Damit die Arme von den Servos bewegt werden können, fertigt man aus Büroklammern zwei Steuerstangen an, die in den Ruderhörnern und den Hörnern am Roboterarm eingehängt werden. Die selbstgebastelten Hörner muss man gegebenenfalls abstützen, damit sie durch die Belastung nicht abknicken.
Eine Pappscheibe aus mehreren Schichten nimmt eine Papphalterung auf, in der eine Wäscheklammer aus Holz steckt. In die Wäscheklammer klemmt man einen Kaffeelöffel ein. So lässt er sich nach Benutzung einfach austauschen. Die Scheibe ist mit einem Servohorn verbunden, das auf ein drittes Servo geschraubt ist. Es dient dazu, den Löffel eine Rührbewegung vollziehen zu lassen. Zwei Schrauben verbinden das Servo mit dem Roboterarm.
Schaltungsaufbau mit dem Arduino
Ein Arduino Uno R3 steuert die Servos über digitale Ausgänge an. Ein vierzeiliges LC-Display mit I2C-Port dient zur Anzeige von Statusinformationen wie etwa die gewählte Tassengröße. Die kann man über eine Infrarot-Fernbedienung anwählen, die einen IR-Sensor steuert, der an einen analogen Eingang angeschlossen ist. Je nach gewählter Tassengröße bewegt der Roboterarm den Löffel passgenau in die Tasse. Ein Piezo-Lautsprecher gibt Warntöne aus, sobald der Rührvorgang startet.
Programmierung
Die Programmierung erfolgt über die Arduino-Software in der Programmiersprache C. Etwas trickreich ist die Ansteuerung des LC-Dispays über den I2C-Port. Es gibt zwar eine Open Source Programmbibliothek, über die das Display einfach angesprochen werden kann, allerdings klappt das nur bei bekannter Adresse, die je nach Display unterschiedlich ausfällt. Mit einem kleinen Programm lässt sie sich aber ermitteln. Danach ist die Ansteuerung des Displays ein Kinderspiel.
Der Infrarot-Sensor empfängt seine Steuerbefehle in Abhängigkeit von der gedrückten Taste auf der IR-Fernbedienung. Die Werte der Codes hängen von der verwendeten Fernbedienung ab und können variieren. Deshalb liest man sie zunächst aus und zeigt sie in der Konsole an. Hat man die Werte den jeweiligen Tasten zugeordnet, kann man sie im Programm-Code abfragen und den Tassengrößen zuordnen. Außerdem wird mit der Fernbedienung der Umrührprozess gestartet.
#include <Wire.h>
#include <IRremote.h>
#include <LiquidCrystal_I2C.h>
#include <Servo.h>
boolean start = false;
int sound = 5;
int remotepin = 11;
int pottgroesse = 1;
int ruehren = 0;
int achse1 = 0;
int achse2 = 160;
int loeffelmin = 70;
int loeffelmax = 110;
int achse1abtropf = 10;
int achse2abtropf = 135;
int loeffelabtropfmin = 155;
int loeffelabtropfmax = 90;
Servo servoachse1;
Servo servoachse2;
Servo servoloeffel;
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
IRrecv irrecv(remotepin);
decode_results results;
void setup()
{
Serial.begin(9600);
irrecv.enableIRIn();
lcd.begin(20,4);
servoachse1.attach(6);
servoachse1.write(90);
servoachse2.attach(7);
servoachse2.write(90);
servoloeffel.attach(8);
servoloeffel.write(90);
pinMode(sound,OUTPUT);
}
void loop()
{
lcd.setCursor ( 0, 0 );
lcd.print("NUP-M01 Umruehren ");
lcd.setCursor ( 0, 1 );
lcd.print ("Pottgroesse waehlen:");
lcd.setCursor ( 0, 2 );
switch(pottgroesse)
{
case 0: lcd.print ("Klein "); break;
case 1: lcd.print ("Mittel "); break;
case 2: lcd.print ("Gross "); break;
default: lcd.print ("Mittel "); break;
}
lcd.setCursor ( 0, 3 );
lcd.print ("Startknopf druecken!");
while (!start)
{
if (irrecv.decode(&results))
{
Serial.println(results.value, DEC);
if (results.value == 16724175)
{
pottgroesse = 0;
achse1 = 0;
achse2 = 180;
loeffelmin = 70;
loeffelmax = 110;
achse1abtropf = 25;
achse2abtropf = 180;
loeffelabtropfmin = 145;
loeffelabtropfmax = 90;
lcd.setCursor ( 0, 2 );
lcd.print ("Klein ");
}
if (results.value == 16718055)
{
pottgroesse = 1;
achse1 = 0;
achse2 = 160;
loeffelmin = 70;
loeffelmax = 110;
achse1abtropf = 10;
achse2abtropf = 135;
loeffelabtropfmin = 155;
loeffelabtropfmax = 90;
lcd.setCursor ( 0, 2 );
lcd.print ("Mittel ");
}
if (results.value == 16743045)
{
pottgroesse = 2;
achse1 = 0;
achse2 = 155;
loeffelmin = 70;
loeffelmax = 110;
achse1abtropf = 20;
achse2abtropf = 135;
loeffelabtropfmin = 146;
loeffelabtropfmax = 90;
lcd.setCursor ( 0, 2 );
lcd.print ("Gross ");
}
if (results.value == 16761405)
{
start = true;
}
irrecv.resume();
}
}
lcd.setCursor ( 0, 1 );
lcd.print ("Achtung: ");
lcd.setCursor ( 0, 2 );
lcd.print ("Umruehren gestartet!");
lcd.setCursor ( 0, 3 );
lcd.print ("Finger weg! ");
digitalWrite(sound, HIGH);
delay(500);
digitalWrite(sound, LOW);
delay(1000);
digitalWrite(sound, HIGH);
delay(500);
digitalWrite(sound, LOW);
delay(1000);
digitalWrite(sound, HIGH);
delay(500);
digitalWrite(sound, LOW);
// Servosteuerung
servoachse1.write(achse1);
delay(1000);
servoachse2.write(achse2);
delay(1000);
for(ruehren=0; ruehren<6; ruehren++)
{
servoloeffel.write(loeffelmax);
delay(500);
servoloeffel.write(loeffelmin);
delay(500);
}
servoloeffel.write(90);
delay(1000);
servoachse2.write(achse2abtropf);
delay(500);
servoachse1.write(achse1abtropf);
delay(1000);
for(ruehren=0; ruehren<2; ruehren++)
{
servoloeffel.write(loeffelabtropfmax);
delay(500);
servoloeffel.write(loeffelabtropfmin);
delay(500);
}
servoloeffel.write(90);
delay(1000);
servoachse2.write(90);
delay(500);
servoachse1.write(90);
start = false;
}
Die Servos steuern die Bewegungen des Roboterarms je nach gewählter Tassengröße an. Um den Löffel halbwegs elegant in die Tasse zu manövrieren, muss man ein wenig probieren. Die Servos lassen sich gradweise in einem maximalen Bewegungswinkel von 180 Grad ansteuern. 90 Grad ist die mittlere Position, sodass das Ruderhorn maximal 90 Grad in jede Richtung bewegt werden kann. Eine Ansteuerung darüber hinaus ist lediglich möglich, wenn man das Servo kontinuierlich drehen lassen würde. Das eignet sich aber nicht zur Ansteuerung eines Roboterarms.
Zusätzlich besitzt die NUP-M01 eine akustische Warnfunktion, um zu vermeiden, dass der Benutzer in die Maschine greift. Der Piezo-Lautsprecher wird einfach nur ein- und ausgeschaltet.
Fazit
Eine Maschine aus Pappe lässt sich in wenigen Stunden zusammenbauen. Die Ansteuerung gelingt über einen Arduino Uno Mikrocontroller. Die Programmierung in C ist über die kostenfreie Arduino Software auch für Einsteiger einfach zu bewältigen, denn die notwendigen Befehle zur Ansteuerung von Servos sowie das Auslesen von Infrarot-Befehlen sind übersichtlich. Also ran an Schere und Bastelmesser, denn selbstgemacht ist doch am schönsten.