seeseekey.net - Invictus Deus Ex Machina

Wer auf der Suche nach einer gra­fi­schen Ent­wick­lungs­um­ge­bung für den Arduino ist, der solle sich ein­mal Mini­bloq anschauen. Das ganze ist dabei für Ein­stei­ger geeig­net da die „Pro­gram­mie­rung“ sehr gra­fisch abläuft. Das kann man sich auch an den Bei­spie­len anschauen. Die Soft­ware selbst ist im Moment für Win­dows und Linux ver­füg­bar und steht unter der RobotGroup-Multiplo Paci­fist License (RMPL), wel­che unter http://multiplo.com.ar/soft/Mbq/Minibloq.Lic.v1.0.en.pdf ein­ge­se­hen wer­den kann. Mini­bloq selbst fin­det man auf der offi­zi­el­len Seite unter http://blog.minibloq.org/.

Ein Elek­to­mo­tor kann sich vor­wärts und rück­wärts dre­hen. Erreicht wird dies indem man ihn ein­fach umpolt. Pro­ble­ma­tisch wird das ganze wenn man einen Motor ansteu­ern möchte z.B. über einen Arduino. Da kann man das ganze natür­lich nicht ein­fach per Hand umpo­len. Also muss eine Schal­tung her. Diese Schal­tung hört auf den Namen Vier­qua­dran­ten­stel­ler und sieht so aus:

Mit die­ser Schal­tung ist es mög­lich den Motor zu beschleu­ni­gen und ihn wie­der zu brem­sen. Das ganze funk­tio­niert dabei sowohl vor­wärts als auch rück­wärts. Wer das ganze nicht von Hand nach­bauen möchte, der kann sich auch ICs besor­gen wel­che diese Schal­tung bereits enthalten.

Wei­tere Infor­ma­tio­nen gibt es unter:
http://de.wikipedia.org/wiki/Vierquadrantensteller
http://www.elektronik-kompendium.de/sites/slt/0208031.htm
http://www.rn-wissen.de/index.php/Getriebemotoren_Ansteuerung

Wecker gibt es viele, teils auch mit aus­ge­fal­len­dem Design, aber die Defu­se­able Clock ist mal was neues:

Der Wecker scheint dabei auf einem Arduino auf­zu­bauen. Natür­lich kann man ihn mor­gens stil­echt ent­schär­fen muss dann aller­dings die Kabel aus­tau­schen. Der Nach­teil an die­sem Wecker ist aller­dings die Tat­sa­che das er sich für Flug­rei­sen nicht eig­net ;)

Wei­tere Infor­ma­tio­nen gibt es unter:
http://nootropicdesign.com/projectlab/2011/09/05/defusable-clock/

Für ein klei­nes Arduino Pro­jekt ver­su­che ich gerade ein paar Räder an einem Motor zu befes­ti­gen. Dies ist aller­dings schwie­ri­ger als zunächst ange­nom­men. Das Pro­blem ist das die Boh­run­gen im Rad sich meist von dem Durch­mes­ser der Motor­welle unter­schei­den. Nach­dem ich nicht nur einen Baumarkt/Elektronikmarkt auf den Kopf gestellt habe, war ich der Lösung nicht wirk­lich näher.

Bis ich auf die Web­seite http://www.rn-wissen.de/index.php/R%C3%A4der_an_der_Motorwelle_befestigen_%28Welle/Nabe-Verbindung%29 gestos­sen bin. Auf die­ser Seite wel­che Teil eines grös­se­ren Wikis ist geht geht es um die Lösung ebend die­ses Befes­ti­gungs­pro­ble­mes. Die Wiki bie­tet neben die­ser Seite noch viele andere inter­es­sante Dinge, wel­che sich der geneigte Bast­ler ruhig anschauen sollte.

Auf der Suche nach ein paar bestimm­ten Infor­ma­tio­nen über den Arduino bin ich über die Web­seite http://www.ladyada.net gestol­pert. Dort gibt es eine Menge Infor­ma­tio­nen über den Arduino, bestimmte Shields und eine ganze Menge andere Hard­ware. Die Shields wel­che auf der Seite vor­ge­stellt wer­den kön­nen dabei auf http://www.adafruit.com auch käuf­lich erwor­ben wer­den. Sehr inter­es­sant das ganze :)

Bei MIDI han­delt es sich um ein gut über 20 Jahre altes Pro­to­koll zur Kom­mu­ni­ka­tion, mit wel­chem sich Musik­in­stru­mente, Syn­the­si­zer et cetera unter­ein­an­der ver­stän­di­gen kön­nen. MIDI Signale kann man dabei auch mit dem Arduino erzeu­gen. Damit man das Rad nicht neu erfin­den muss, gibt es eine Biblio­thek wel­che auf den Namen Midi­Duino hört und unter http://ruinwesen.com/mididuino zu fin­den ist. Mit die­ser kann man MIDI Signale erzeu­gen als auch inter­pre­tie­ren. Sie abstra­hiert dabei die seri­elle Kom­mu­ni­ka­tion und imple­men­tiert einen MIDI Stack.

Wei­tere Infor­ma­tio­nen gibt es unter:
http://de.wikipedia.org/wiki/MIDI

Bei einem Servo han­delt es sich um einen Motor wel­cher sich genau steu­ern lässt z.B. auf eine exakte Posi­tion. Die Ansteue­rungs­elek­tro­nik ist bei einem Servo gleich ein­ge­baut. Ser­vos sind im übri­gen im Nor­mal­fall nicht zum Durch­lauf gedacht, da eine mecha­ni­sche Sperre dies ver­hin­dert. Neben dem Servo soll es auch noch zwei LEDs (eine rote und eine grüne) zur Anzeige des Zustan­des sowie einen Tas­ter zum an– und aus­schal­ten geben.

Zuerst wird der Servo mit dem Board ver­bun­den. Der Servo hat dabei drei Anschlüsse, GND (schwarz bzw. braun), VDD (rot) sowie SIGNAL (Orange). GND wird dabei mit Ground ver­bun­den, VDD mit der 5 Volt Buchse des Arduino und Signal mit PIN 9 des Boards. Der Tas­ter wird mit PIN 4 ver­bun­den, die bei­den LEDs mit PIN 2 und 3. Damit wäre die Ver­ka­be­lung erledigt.

Nun geht es an den Quell­code. Die­ser soll den Servo ansteu­ern, die Lich­ter leuch­ten las­sen, sowie den Tas­ter abfra­gen. Inter­es­sant ist die Zeile:

digitalWrite(pushButton, HIGH); //Pull up Widerstand aktivieren

In die­ser Zeile wird der interne Pull Up Wider­stand des Arduino für PIN 4 akti­viert. Andern­falls müsste ein hoch­oh­mi­ger (1000 — 100000 Ohm) Wider­stand auf dem Board im Tas­ter­schalt­kreis ver­baut wer­den, da es sonst vor­kom­men kann das der Tas­ter nicht reagiert.

#include <Servo.h> 

Servo servo;

int pushButton=4;

int ledRed=3;
int ledGreen=2;

void setup()
{
 pinMode(pushButton, INPUT);

 pinMode(ledRed, OUTPUT);
 pinMode(ledGreen, OUTPUT);

 servo.attach(9);

 digitalWrite(pushButton, HIGH); //Pull up Widerstand aktivieren
} 

void loop()
{
 int pressed=digitalRead(pushButton);

 digitalWrite(ledGreen, LOW);
 digitalWrite(ledRed, HIGH);

 if(pressed==LOW)
 {
 digitalWrite(ledGreen, HIGH);
 digitalWrite(ledRed, LOW);

 servo.write(360);
 delay(2000);
 servo.write(0);
 }

 delay(15);
}

In Action sieht das ganze dann so aus:

Der Source­code sowie der Schalt­plan kön­nen sich natür­lich auch her­un­ter­ge­la­den werden.

Wei­tere Infor­ma­tio­nen gibt es unter:
http://de.wikipedia.org/wiki/Servo
http://www.freeduino.de/books/servos-f%C3%BCr-durchlauf-umbauen
http://de.wikipedia.org/wiki/Pull_up

Die erste Schal­tung wel­che man im Nor­mal­fall mit dem Arduino baut, ist ja meist recht ein­fach. Eine LED wird ein­fach an einen PIN sowie Ground ange­schlos­sen und zum leuch­ten gebracht. Ich habe mir da aller­dings gleich ein wenig mehr zusam­men gebaut. Bei mir wur­den es ein paar LEDs sowie zwei Laut­spre­cher. Zuerst wur­den die LEDS auf das Bre­ad­board gesteckt und anschlie­ßend mit Ground sowie je einem PIN auf dem Arduino Board ver­bun­den. Das glei­che wurde mit den zwei Laut­spre­chern getan.

Die Schal­tung im Aufbau.

Nun fehlte nur noch der Source­code. In die­sem wer­den die LEDs sowie die Laut­spre­cher angesteuert:

int ledPinRed1=13;
int ledPinYellow1=12;
int ledPinRed2=11;
int ledPinGreen=10;
int ledPinRed3=9;
int ledPinYellow2=8;
int ledPinRed4=7;

int soundKlack=6;
int soundSin=5;

void setup()
{
 pinMode(ledPinRed1, OUTPUT);
 pinMode(ledPinYellow1, OUTPUT);
 pinMode(ledPinRed2, OUTPUT);
 pinMode(ledPinGreen, OUTPUT);
 pinMode(ledPinRed3, OUTPUT);
 pinMode(ledPinYellow2, OUTPUT);
 pinMode(ledPinRed4, OUTPUT);

 pinMode(soundKlack, OUTPUT);
 pinMode(soundSin, OUTPUT);
}

void loop()
{
 blinkRed();

 sound();

 blinkGreen();

 sound();

 blinkYellow();

 sound();

 analogWrite(soundSin, 200);
 delay(100);
 analogWrite(soundSin, 0);

 analogWrite(soundSin, 500);
 delay(200);
 analogWrite(soundSin, 0);

 analogWrite(soundSin, 1000);
 delay(400);
 analogWrite(soundSin, 0);
}

void sound()
{
 digitalWrite(soundKlack, LOW);
 delay(100);
 digitalWrite(soundKlack, HIGH);
}

void blinkRed()
{
 digitalWrite(ledPinRed1, HIGH);
 digitalWrite(ledPinRed2, HIGH);
 digitalWrite(ledPinRed3, HIGH);
 digitalWrite(ledPinRed4, HIGH);
 delay(500);
 digitalWrite(ledPinRed1, LOW);
 digitalWrite(ledPinRed2, LOW);
 digitalWrite(ledPinRed3, LOW);
 digitalWrite(ledPinRed4, LOW);
}

void blinkYellow()
{
 digitalWrite(ledPinYellow1, HIGH);
 digitalWrite(ledPinYellow2, HIGH);
 delay(500);
 digitalWrite(ledPinYellow1, LOW);
 digitalWrite(ledPinYellow2, LOW);
}

void blinkGreen()
{
 digitalWrite(ledPinGreen, HIGH);
 delay(500);
 digitalWrite(ledPinGreen, LOW);
}

Wer das ganze nach­bauen möchte (warum auch immer ;) ) fin­det hier den Source­code sowie die Frit­zing Datei (der Schaltplan).

Und so sieht das ganze dann in Action aus:

Das Steck­brett (Bre­ad­board) wel­ches bei den meis­ten Arduino Star­ter Kits dabei ist sieht meist so aus:

Die Frage wel­che sich natür­lich stellt ist wie ist das Steck­brett ver­ka­belt ist. Ich habe das bei mei­nem Exem­plar ein­fach mal durch­ge­mes­sen. Die unte­ren Rei­hen sind dabei hori­zon­tal bis zur Hälfte durch­kon­tak­tiert. Die Steck­plätze hin­ge­gen sind immer ver­ti­kal kontaktiert.

Beim Arduino han­delt es sich um ein Ent­wick­ler­board mit wel­chem man schnell mal irgend­wel­che Schal­tun­gen zusam­men­bauen und aus­pro­bie­ren kann. Das schöne an die­sem Sys­tem ist das es sehr ein­stei­ger­freund­lich ist. Zu dem Thema gibt es auch eine ganze Reihe von inter­es­san­ten Seiten:

Und so sieht er aus der Arduino:

Gekauft wer­den kann er in Deutsch­land unter ande­rem bei bau­s­teln (http://bausteln.de) und Thin­ker­Soup (http://www.tinkersoup.de/). Ein Arduino UNO kos­tet dort in etwa 26 €.

Wei­tere Infor­ma­tio­nen gibt es unter:
http://de.wikipedia.org/wiki/Arduino-Plattform