Auf der Make Munich 2016 habe ich am Stand von fab4U.de schöne große (6 x 6cm) und auch lichtstarke 8×8 LED Matrix Displays mit Ansteuerung über eine einfache SPI-artige Schnittstelle gesehen. Jetzt habe ich einige dieser Blöcke bestellt und möchte damit mit einem Arduino eine eigene Variante der digitalen Sanduhr bauen, die auf der Website des Herstellers vorgestellt wird.

Hier ist das erste Video zu den Displays:

https://www.youtube.com/watch?v=6gNUzXAmsJg

Die Links zum Thema:

• Produktseite des Herstellers – für Bestellungen einfach an die auf der Website links angegebene Adresse mailen, der Hersteller meldet sich dann mit einer Bankverbindung. Ein PixBlock kostet derzeit 16€ (ab 3 Stk 15€) plus Versandkosten.
• PixBlock Arduino Library auf Github
• „Bits of Time“ – Sanduhr-Projekt von fab4U mit PixBlock Displays und On-Board ATtiny Controller

Fragen und Anregungen bitte einfach in die Kommentare schreiben.

Über 70.000 Mal wurde unsere kleine iOS Helfer-App zur Berechnung der Widerstandswerte von  Kohleschichtwiderständen (4 & 5 Ringe) anhand der Farbringe bereits aus dem App Store heruntergeladen.

Der Widerstandswert ist bei allen handelsüblichen Kohleschichtwiderständen über den Farbcode abzulesen. Dieser besteht meist aus 4 oder 5 Farbringen, bei denen der letzte (oft auch dicker gezeichnete) Ring leicht von den anderen Ringen abgesetzt ist.

Mit dem Widerstands-Rechner ist der Ohm-Wert von Widerständen nach dem aufgedruckten Farbcode schnell und einfach ermittelt.

Ab sofort ist die kostenlose App auch für Android verfügbar und kann aus dem Google Play Store installiert werden.

Durch die wenigen benötigten Bauteile ein perfektes Einsteigerprojekt.

Mit einem lichtempfindlichen Widerstand (LDR, Fotoresistor) und einem Lautsprecher oder Piezo Element wird eine Schaltung gebaut, die ab einer gewissen Helligkeit anfängt, die James Bond Titelmelodie zu spielen. Diese Schaltung kann man z.B. ein einer Schachtel verstauen, als Schubladenwächter benutzen oder einen James Bond-Fan beim Einschalten des Lichts überraschen.

Hier ein kurzes Video mit Informationen zur Funktionsweise und zum Anschluß einer Gabellichtschranke an den Arduino:

Und hier der Arduino Sketch:

#include "pitches.h"
#define NO_SOUND 0 // für die Pausen
 
int ldrPin = A0; // Lichtempfindlicher Widerstand
int speakerPin = 8; // Lautsprecher
 
// Thanks to
// http://garagelab.com/profiles/blogs/how-to-use-tone-function-arduino-playing-the-james-bond-theme
 
// Array mit Noten des Bond Theme
int16_t melody[] = {
  NOTE_E4,NOTE_F4,NOTE_F4,NOTE_F4,NOTE_F4,NOTE_E4,NOTE_E4,NOTE_E4,
  NOTE_E4,NOTE_G4,NOTE_G4,NOTE_G4,NOTE_G4,NOTE_E4,NOTE_E4,NOTE_E4,
  NOTE_E4,NOTE_F4,NOTE_F4,NOTE_F4,NOTE_F4,NOTE_E4,NOTE_E4,NOTE_E4,
  NOTE_E4,NOTE_G4,NOTE_G4,NOTE_G4,NOTE_G4,NOTE_E4,NOTE_E4,NOTE_E4,
  NOTE_DS5,NOTE_D5,NOTE_B4,NOTE_A4,NOTE_B4,
  NOTE_E4,NOTE_G4,NOTE_DS5,NOTE_D5,NOTE_G4,NOTE_B4,
  NOTE_B4,NOTE_FS5,NOTE_F5,NOTE_B4,NOTE_D5,NOTE_AS5,
  NOTE_A5,NOTE_F5,NOTE_A5,NOTE_DS6,NOTE_D6,NO_SOUND
};
 
// Dauer der einzelnen Noten
// Notenwert: 1 = ganze Note, 2 = halbe Note, 4 = Viertelnote usw.
int16_t noteDurations[] = {
  8,16,16,8,4,8,8,8,
  8,16,16,8,4,8,8,8,
  8,16,16,8,4,8,8,8,
  8,16,16,8,4,8,8,8,
  8,2,8,8,1,
  8,4,8,4,8,8,
  8,8,4,8,4,8,
  4,8,4,8,3,1
};
 
int songPace = 1450; // Dauer einer ganzen Note in Millisekunden
int melodyLength = 0;
 
int playState = 0; // 0 = ruhig warten bis es hell wird, 1 = Song spielt gerade, -1 = ruhig, warten bis es dunkel wird
int noteCount = 0; // Laufender Zaehler fuer aktuelle Position
 
 
void setup() {
 
  Serial.begin(9600);
  pinMode(speakerPin, OUTPUT);
 
  melodyLength = sizeof(melody) / sizeof(melody[0]);
 
  Serial.print ("Melody length: ");
  Serial.println (melodyLength);
  Serial.println ("------------");
}
 
void loop() {
 
  if (analogRead(ldrPin) > 100) { // es ist grade hell!
    if (playState == 0) { // warte ich gerade aufs loslegen?
      playState = 1;  // ja, also loslegen!
    }
  } else // es ist grade dunkel
  {
    // Spiele ich gerade oder warte ich darauf, dass es dunkel wird?
    if ((playState == 1) || (playState == -1)) { 
       playState = 0; // Setze Status auf 0 = Warten, bis es hell wird
       noteCount = 0;
    }
  }
 
  if (playState == 1) {
    int duration = songPace/noteDurations[noteCount]; // Aus Notenwert die Länge in Millisec berechnen
    tone(speakerPin, melody[noteCount], duration); // Note mit tone() spielen
    delay(duration*1.2); // Kurz warten vor naechster Note
    noteCount ++; // Notenzaehler erhoehen
    if (noteCount >= melodyLength) {  // Wenn letzte Note gespielt, Zaehler auf Anfang und Status auf Pause
      noteCount = 0;
      playState = -1;
    }
  }
 
  // Debug-Ausgaben auf dem Seriellen Monitor
  Serial.print(playState);
  Serial.print("   ");
  Serial.print(noteCount);
  Serial.print("   ");
  Serial.print(melody[noteCount]);
  Serial.print("   ");
  Serial.print(noteDurations[noteCount]);
  Serial.print("   ");  
  Serial.println(analogRead(A0));
 
}

Die Datei „pitches.h“. Am besten im Arduino Editor mit dem kleinen blauen Pfeil rechts ein „Neues Tab“ erstellen, dieses „pitches.h“ benennen und diesen Inhalt hineinkopieren.

/*************************************************
 * Public Constants
 *************************************************/
 
#define NOTE_B0  31
#define NOTE_C1  33
#define NOTE_CS1 35
#define NOTE_D1  37
#define NOTE_DS1 39
#define NOTE_E1  41
#define NOTE_F1  44
#define NOTE_FS1 46
#define NOTE_G1  49
#define NOTE_GS1 52
#define NOTE_A1  55
#define NOTE_AS1 58
#define NOTE_B1  62
#define NOTE_C2  65
#define NOTE_CS2 69
#define NOTE_D2  73
#define NOTE_DS2 78
#define NOTE_E2  82
#define NOTE_F2  87
#define NOTE_FS2 93
#define NOTE_G2  98
#define NOTE_GS2 104
#define NOTE_A2  110
#define NOTE_AS2 117
#define NOTE_B2  123
#define NOTE_C3  131
#define NOTE_CS3 139
#define NOTE_D3  147
#define NOTE_DS3 156
#define NOTE_E3  165
#define NOTE_F3  175
#define NOTE_FS3 185
#define NOTE_G3  196
#define NOTE_GS3 208
#define NOTE_A3  220
#define NOTE_AS3 233
#define NOTE_B3  247
#define NOTE_C4  262
#define NOTE_CS4 277
#define NOTE_D4  294
#define NOTE_DS4 311
#define NOTE_E4  330
#define NOTE_F4  349
#define NOTE_FS4 370
#define NOTE_G4  392
#define NOTE_GS4 415
#define NOTE_A4  440
#define NOTE_AS4 466
#define NOTE_B4  494
#define NOTE_C5  523
#define NOTE_CS5 554
#define NOTE_D5  587
#define NOTE_DS5 622
#define NOTE_E5  659
#define NOTE_F5  698
#define NOTE_FS5 740
#define NOTE_G5  784
#define NOTE_GS5 831
#define NOTE_A5  880
#define NOTE_AS5 932
#define NOTE_B5  988
#define NOTE_C6  1047
#define NOTE_CS6 1109
#define NOTE_D6  1175
#define NOTE_DS6 1245
#define NOTE_E6  1319
#define NOTE_F6  1397
#define NOTE_FS6 1480
#define NOTE_G6  1568
#define NOTE_GS6 1661
#define NOTE_A6  1760
#define NOTE_AS6 1865
#define NOTE_B6  1976
#define NOTE_C7  2093
#define NOTE_CS7 2217
#define NOTE_D7  2349
#define NOTE_DS7 2489
#define NOTE_E7  2637
#define NOTE_F7  2794
#define NOTE_FS7 2960
#define NOTE_G7  3136
#define NOTE_GS7 3322
#define NOTE_A7  3520
#define NOTE_AS7 3729
#define NOTE_B7  3951
#define NOTE_C8  4186
#define NOTE_CS8 4435
#define NOTE_D8  4699
#define NOTE_DS8 4978

Arduino Starter Kits gibts z.B. bei Amazon. Die für dieses Projekt benötigten Bauteile sind in praktisch jedem Set enthalten:

Die Arduino Boards können vieles, verfügen aber nicht über eine Echtzeituhr. Das bedeutet, dass eine eventuell benötigte Zeitangabe im Arduino Sketch nach jedem Stromausfall oder Neustart neu gesetzt werden muss.

Für Projekte, bei denen man datum- oder zeitabhängig Ereignisse auslösen oder protokollieren will, benötigt man eine Echtzeituhr (Real Time Clock = RTC) als zusätzliches Bauelement. Eine nicht sonderlich genaue, aber dafür sehr preisgünstige Lösung ist die Real Time Clock DS1307, kompakt in einem IC verbaut. Mit einer 3V-Knopfzelle ist diese Echtzeituhr in der Lage, die Zeit bis zu 5 Jahre mitzuführen, allerdings mit einer relativ großen Ungenauigkeit von 1-2 Sekunden pro Tag. Adafruit bietet zum DS1307 ein Breakout Kit an, das mit ein wenig Lötarbeit selbst zusammengebaut werden kann.

Die benötigte Library gibts hier auf Github: https://github.com/adafruit/RTClib/archive/master.zip

Einfach das ZIP runterladen und dekomprimieren. Den erzeugten Ordner in „RTClib“ umbenennen (ohne das „-master“ hintendran) und über die Arduino IDE im Menü „Sketch -> Include Library -> Add .ZIP Library“ importieren.

Im Video-Tutorial erkläre ich den Aufbau und die Verwendung der Echtzeituhr DS1307.

Hier der erste Sketch, mit dem die aktuelle Systemzeit (fast richtig) vom PC in die Real Time Clock übertragen werden kann.

// Date and time functions using a DS1307 RTC connected via I2C and Wire lib
#include 
#include "RTClib.h"
 
RTC_DS1307 rtc;
 
void setup () {
 
  while (!Serial); // for Leonardo/Micro/Zero
 
  Serial.begin(57600);
  if (! rtc.begin()) {
    Serial.println("Couldn't find RTC");
    while (1);
  }
 
  if (! rtc.isrunning()) {
    Serial.println("RTC is NOT running!");
    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
    Serial.println("RTC adjusted!");
  }
}
 
void loop () {
    DateTime now = rtc.now();
 
    Serial.print(now.year(), DEC);
    Serial.print('/');
    Serial.print(now.month(), DEC);
    Serial.print('/');
    Serial.print(now.day(), DEC);
    Serial.print(" ");
    Serial.print(now.hour(), DEC);
    Serial.print(':');
    Serial.print(now.minute(), DEC);
    Serial.print(':');
    Serial.print(now.second(), DEC);
    Serial.println();
 
    delay(3000);
}

Und der 2. Sketch, welcher die gesetzte Zeit zusätzlich auf einem seriellen 7-Segment-Display von Sparkfun anzeigt.

// Date and time functions using a DS1307 RTC connected via I2C and Wire lib
#include 
#include "RTClib.h"
#include "SoftwareSerial.h"
 
const int softwareTx = 8;
const int softwareRx = 7;
 
RTC_DS1307 rtc;
SoftwareSerial s7s(softwareRx, softwareTx);
 
char tempString[10];  // String für 7-Segment Display
 
void setup () {
 
  while (!Serial); // for Leonardo/Micro/Zero
 
  Serial.begin(57600);
  if (! rtc.begin()) {
    Serial.println("Couldn't find RTC");
    while (1);
  }
 
//  if (! rtc.isrunning()) {
//    Serial.println("RTC is NOT running!");
//    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
//    Serial.println("RTC adjusted!");
//  }
 
  s7s.begin(9600);
  clearDisplay();
  setDecimals(0b010000);
  setBrightness(255);
 
}
 
void loop () {
    DateTime now = rtc.now();
    sprintf(tempString, "%02d%02d", now.hour(), now.minute());     
    s7s.print(tempString);
    Serial.println(tempString);
    delay(1000);
}
 
 
// Hilfsfunktionen für 7-Segment-Display
 
void clearDisplay()
{
  s7s.write(0x76);
}
 
void setBrightness(byte value)
{
  s7s.write(0x7A);
  s7s.write(value);
}
 
void setDecimals(byte decimals)
{
  s7s.write(0x77);
  s7s.write(decimals);
}

Die Breakout-Boards mit dem DS1307 kommunizieren alle per I²C mit dem Arduino. Die RTClib Library funktioniert also nicht nur mit dem Kit von Adafruit (z.B. hier erhältlich bei exp-tech.de), sondern auch mit jedem anderen Breakout Board, das diese Echtzeituhr verwendet.

Auch bei Amazon gibts zahlreiche Versionen.

Fragen, Wünsche und Anregungen bitte in die Kommentare. Danke.

Ich weiß noch sehr gut, wie ich vor mittlerweile zu vielen Jahrzehnten meinen besten Schulfreund um dessen Chemie-Experimentierkasten von Kosmos beneidet habe. Viel später kamen dann die ersten Kästen mit dem markanten weiß-blauen Schriftzug für meine eigenen Kinder ins Haus, unter anderem zu den Themen Mikroskopie und Elektronik. Deswegen habe ich mich gefreut, als auf der Spielwarenmesse 2016 in Nürnberg ein neuer Experimentierkasten vorgestellt wurde, der mit einem spielerischen Zugang die Arduino-Programmierung vermitteln will. Der Kosmos-Verlag hat mir freundlicherweise einen KosmoBits Kasten zur Verfügung gestellt, den ich in den nächsten Wochen ausprobieren und auf seine Brauchbarkeit für (jugendliche) Maker-Projekte hin abtesten werde.

Beim Thema „Programmieren lernen“ bin ich ja kein Freund von Produkten, welche die Programmierung hinter visuellen Oberflächen wie Scratch oder Ardublocks verstecken und damit gar zu verspielt aufbereiten. Kosmos geht da mit KosmoBits erfreulicherweise einen anderen Weg und lässt den Anwender nach einer kurzen Einführungs- und Spielphase mitten hinein in die Arduino IDE. Dank der gut aufbereiteten Anleitung und des zugehörigen Spiels, das für iOS und Android (Smartphone und Tablet) verfügbar ist, geht das recht flott und ist dabei auch unterhaltsam.

Der Kasten besteht aus einer Platine und dem Gehäuse eines Gamepad-Controllers. Dieser verfügt über zwei Knöpfe, Steuerungsrad und Neopixel (RGB-LED) sowie einen Port zum Anschluss von Sensoren und wird mit dem beigelegten Kosmoduino Mikrocontroller bestückt. Der Kosmoduino ist ein Arduino-kompatibler Mikrocontroller und verfügt über ein integriertes Bluetooth LE Modul. Der Zusammenbau des Gamepads und der Sensoren geht problemlos (kein Löten notwendig!) und das Gamepad kann unmittelbar nach dem Zusammenbau verwendet werden, um via Bluetooth am Smartphone/Tablet das KosmoBits-Spiel zu steuern.

Im ersten Video stelle ich den KosmoBits Kasten im Detail vor und bespreche die einzelnen Bestandteile:

Sobald das Gamepad zusammengebaut ist, werden im Spiel – ein einfacher Plattformer – die Grundlagen eines Arduino Sketches vermittelt. In einigen Spielsituationen ist außerdem der Einsatz eines Sensors notwendig. Diese Sensoren (Bewegungssensor, Lichtsensor, Schallsensor, Temperatursensor) können auf das Gamepad gesteckt werden und übermitteln ihre Messwerte an das Spiel. Wie das funktioniert, das zeige ich in einem der nächsten Videos.

Wenn das Spiel durchgespielt ist und damit die einfachsten Arduino-Grundlagen vermittelt wurden, geht es mit Hilfe der Anleitung zu ersten eigenen Maker-Projekten. Die Abfrage der Steuerung und der Sensoren wird teilweise durch eigene Libraries vereinfacht, mit dem mitgelieferten Breadboard und einigen Widerständen und Farb-LEDs können schnell erste kleine Projekte aufgebaut werden.

Durch den Arduino-kompatiblen Mikrocontroller kann man das Gamepad auch als Basis für umfangreichere Projekte verwenden und zusätzliche eigene Sensoren oder Breakout-Boards anschließen. Gerade das Bluetooth-Modul würde da interessante Möglichkeiten bieten. Ich bin überzeugt, dass da in den nächsten Monaten in der Maker-Community einige Hacks veröffentlicht werden, die deutlich über die Startprojekte in der Anleitung hinausgehen :)

Weitere Videos gibt es in den kommenden Wochen. Hier geht es zur Website des KosmoBits Experimentierkastens.

Im 3. Teil des KosmoBits Videos habe ich ab Minute 8:30 den angepassten Arduino Sketch der kürzlich hier vorgestellten Bond Theme Box erwähnt.

Damit der Sketch funktioniert, müsst ihr lediglich den Lichtsensor auf das Interaction Board stecken und folgenden Sketch (Achtung, besteht aus zwei Dateien!) auf den Kosmoduino übertragen.

Hier Teil 1 des Sketches:

#include "pitches.h"
#include "KosmoBits_Pins.h"
#define NO_SOUND 0 // für die Pausen
 
int ldrPin = KOSMOBITS_SENSOR_PIN; // Lichtempfindlicher Widerstand
int speakerPin = KOSMOBITS_BUZZER_PIN; // Lautsprecher
 
// Thanks to
// http://garagelab.com/profiles/blogs/how-to-use-tone-function-arduino-playing-the-james-bond-theme
 
// Array mit Noten des Bond Theme
int16_t melody[] = {
  NOTE_E4,NOTE_F4,NOTE_F4,NOTE_F4,NOTE_F4,NOTE_E4,NOTE_E4,NOTE_E4,
  NOTE_E4,NOTE_G4,NOTE_G4,NOTE_G4,NOTE_G4,NOTE_E4,NOTE_E4,NOTE_E4,
  NOTE_E4,NOTE_F4,NOTE_F4,NOTE_F4,NOTE_F4,NOTE_E4,NOTE_E4,NOTE_E4,
  NOTE_E4,NOTE_G4,NOTE_G4,NOTE_G4,NOTE_G4,NOTE_E4,NOTE_E4,NOTE_E4,
  NOTE_DS5,NOTE_D5,NOTE_B4,NOTE_A4,NOTE_B4,
  NOTE_E4,NOTE_G4,NOTE_DS5,NOTE_D5,NOTE_G4,NOTE_B4,
  NOTE_B4,NOTE_FS5,NOTE_F5,NOTE_B4,NOTE_D5,NOTE_AS5,
  NOTE_A5,NOTE_F5,NOTE_A5,NOTE_DS6,NOTE_D6,NO_SOUND
};
 
// Dauer der einzelnen Noten
// Notenwert: 1 = ganze Note, 2 = halbe Note, 4 = Viertelnote usw.
int16_t noteDurations[] = {
  8,16,16,8,4,8,8,8,
  8,16,16,8,4,8,8,8,
  8,16,16,8,4,8,8,8,
  8,16,16,8,4,8,8,8,
  8,2,8,8,1,
  8,4,8,4,8,8,
  8,8,4,8,4,8,
  4,8,4,8,3,1
};
 
int songPace = 1450; // Dauer einer ganzen Note in Millisekunden
int melodyLength = 0;
 
int playState = 0; // 0 = ruhig warten bis es hell wird, 1 = Song spielt gerade, -1 = ruhig, warten bis es dunkel wird
int noteCount = 0; // Laufender Zaehler fuer aktuelle Position
 
 
void setup() {
 
  Serial.begin(9600);
  pinMode(speakerPin, OUTPUT);
 
  melodyLength = sizeof(melody) / sizeof(melody[0]);
 
  Serial.print ("Melody length: ");
  Serial.println (melodyLength);
  Serial.println ("------------");
}
 
void loop() {
 
  if (analogRead(ldrPin) > 100) { // es ist grade hell!
    if (playState == 0) { // warte ich gerade aufs loslegen?
      playState = 1;  // ja, also loslegen!
    }
  } else // es ist grade dunkel
  {
    // Spiele ich gerade oder warte ich darauf, dass es dunkel wird?
    if ((playState == 1) || (playState == -1)) { 
       playState = 0; // Setze Status auf 0 = Warten, bis es hell wird
       noteCount = 0;
    }
  }
 
  if (playState == 1) {
    int duration = songPace/noteDurations[noteCount]; // Aus Notenwert die Länge in Millisec berechnen
    tone(speakerPin, melody[noteCount], duration); // Note mit tone() spielen
    delay(duration*1.2); // Kurz warten vor naechster Note
    noteCount ++; // Notenzaehler erhoehen
    if (noteCount >= melodyLength) {  // Wenn letzte Note gespielt, Zaehler auf Anfang und Status auf Pause
      noteCount = 0;
      playState = -1;
    }
  }
 
  // Debug-Ausgaben auf dem Seriellen Monitor
  Serial.print(playState);
  Serial.print("   ");
  Serial.print(noteCount);
  Serial.print("   ");
  Serial.print(melody[noteCount]);
  Serial.print("   ");
  Serial.print(noteDurations[noteCount]);
  Serial.print("   ");  
  Serial.println(analogRead(A0));
 
}

Und die Datei „pitches.h“. Am besten im Arduino Editor mit dem kleinen blauen Pfeil rechts ein „Neues Tab“ erstellen, dieses „pitches.h“ benennen und diesen Inhalt hineinkopieren.

/*************************************************
 * Public Constants
 *************************************************/
 
#define NOTE_B0  31
#define NOTE_C1  33
#define NOTE_CS1 35
#define NOTE_D1  37
#define NOTE_DS1 39
#define NOTE_E1  41
#define NOTE_F1  44
#define NOTE_FS1 46
#define NOTE_G1  49
#define NOTE_GS1 52
#define NOTE_A1  55
#define NOTE_AS1 58
#define NOTE_B1  62
#define NOTE_C2  65
#define NOTE_CS2 69
#define NOTE_D2  73
#define NOTE_DS2 78
#define NOTE_E2  82
#define NOTE_F2  87
#define NOTE_FS2 93
#define NOTE_G2  98
#define NOTE_GS2 104
#define NOTE_A2  110
#define NOTE_AS2 117
#define NOTE_B2  123
#define NOTE_C3  131
#define NOTE_CS3 139
#define NOTE_D3  147
#define NOTE_DS3 156
#define NOTE_E3  165
#define NOTE_F3  175
#define NOTE_FS3 185
#define NOTE_G3  196
#define NOTE_GS3 208
#define NOTE_A3  220
#define NOTE_AS3 233
#define NOTE_B3  247
#define NOTE_C4  262
#define NOTE_CS4 277
#define NOTE_D4  294
#define NOTE_DS4 311
#define NOTE_E4  330
#define NOTE_F4  349
#define NOTE_FS4 370
#define NOTE_G4  392
#define NOTE_GS4 415
#define NOTE_A4  440
#define NOTE_AS4 466
#define NOTE_B4  494
#define NOTE_C5  523
#define NOTE_CS5 554
#define NOTE_D5  587
#define NOTE_DS5 622
#define NOTE_E5  659
#define NOTE_F5  698
#define NOTE_FS5 740
#define NOTE_G5  784
#define NOTE_GS5 831
#define NOTE_A5  880
#define NOTE_AS5 932
#define NOTE_B5  988
#define NOTE_C6  1047
#define NOTE_CS6 1109
#define NOTE_D6  1175
#define NOTE_DS6 1245
#define NOTE_E6  1319
#define NOTE_F6  1397
#define NOTE_FS6 1480
#define NOTE_G6  1568
#define NOTE_GS6 1661
#define NOTE_A6  1760
#define NOTE_AS6 1865
#define NOTE_B6  1976
#define NOTE_C7  2093
#define NOTE_CS7 2217
#define NOTE_D7  2349
#define NOTE_DS7 2489
#define NOTE_E7  2637
#define NOTE_F7  2794
#define NOTE_FS7 2960
#define NOTE_G7  3136
#define NOTE_GS7 3322
#define NOTE_A7  3520
#define NOTE_AS7 3729
#define NOTE_B7  3951
#define NOTE_C8  4186
#define NOTE_CS8 4435
#define NOTE_D8  4699
#define NOTE_DS8 4978

Das war’s schon. Die Melodie sollte immer abgespielt werden, wenn der Lichtsensor einen Wert über der angegebenen Schwelle misst, also z.B. wenn man das Interaction Board in einer Schachtel oder einer Schublade versteckt und diese dann öffnet.

Die erste Maker Faire Vienna im April 2016 war ein großer Erfolg. Mehr als 6.000 Besucher kamen und bestaunten die Projekte von über 200 Makern aus vielen verschiedenen Themenbereichen. Auch mir hat die bunte Mischung aus Kreativität, Handwerk und Technologie sehr gut gefallen und einen recht interessanten Tag in Wien beschert.

Die nächste Maker Faire Vienna findet am 20. und 21. Mai 2017 statt und seit einigen Tagen läuft der Call for Makers! Wenn ihr also eure Projekte dort ausstellen oder einen Workshop abhalten wollt, dann meldet euch rechtzeitig an!

Alle Details dazu gibts auf http://makerfairevienna.com/

Vor einigen Wochen habe ich kommentarlos dieses Video auf Youtube gepostet und viele Leser haben die Lösung natürlich gleich erraten.

Wie so oft ist das am wichtigsten, was man im Video nicht sieht. In diesem Fall ein Infrarot-Entfernungssensor von Sharp, der außerhalb des Bildes positioniert ist.

Der Projektaufbau ist eigentlich recht simpel. Der Sharp-IR-Sensor liefert einen Analogwert ans Arduino-Pin A0, der mit Hilfe der SharpIR Library in einen ungefähren Zentimeter-Wert umgerechnet wird. Damit die doch recht sprunghaften Messwerte des Sensors etwas geglättet werden, lege ich diese in einem Array mit den letzten 20 Messwerten ab und bilde daraus einen gleitenden Durchschnitt. Das führt auch zu einer schön fließenden Bewegung des beleuchteten LED-Bereichs.

Aus dem so ermittelten Abstand werden dann die LEDs auf dem WS2812B LED Streifen ermittelt, die eingeschaltet werden müssen. Fertig ist der Zauber.

Für das Projekt werden die folgenden Teile benötigt:

– Arduino Uno R3 (oder ähnlich)
– Sharp IR Sensor, z.B. GP2Y0A02YK
– WS2812B LED Streifen (60 LEDs)
– Netzteil mit 6V/4A
– Kleinteile wie ein Breadboard, 100 nF Kondensator, 200 Ohm Widerstand und einige Jumper-Kabel.

Hier das Tutorial-Video. Den benötigten Arduino-Sketch findet ihr weiter unten.

Die beiden im Sketch verwendeten Libraries können beide in der aktuellen Version über den Library Manager der Arduino IDE installiert werden.

/* WS2812B LED Stripe Magic - Demo
 * 
 * Sharp IR Sensor: Analog Pin A0
 * WS 2812B NeoPixel Pin: Digital 6
 * 
 * More information http://www.makerblog.at/2016/12/der-magische-ws2812b-led-streifen/
 * 
 */

#include <Adafruit_NeoPixel.h>
#define PIN 6
#define NUMPIXELS 60

#include <SharpIR.h>
#define ir A0
// Running average variables
const int numReadings = 20;
int readings[numReadings];      // the readings from the analog input
int readIndex = 0;              // the index of the current reading
int total = 0;                  // the running total
int average = 0;                // the average
int newValue = 0;
int lastpixel = 0;

SharpIR sharp(GP2Y0A02YK0F, A0);
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);

void setup() {
 Serial.begin(115200);
 pixels.begin(); // This initializes the NeoPixel library.

 // Reset running average array
 for (int thisReading = 0; thisReading < numReadings; thisReading++) {
 readings[thisReading] = 0;
 }
}

void loop() {

 int dis=sharp.getDistance(); // this returns the distance to the object

 // map distance to LED strip
 // map 20-110cm distance to LEDs #0 to #59
 // play with this value to match your LED strip
 int dispix = map(dis,18,95,0,60);

 // Ignore results out of bound, send -10 to average array instead
 // This leads to LED marker gliding to end of strip when no object is within distance
 if ((dispix >= 0) && (dispix < 60)) {
 newValue = dispix;
 } else {
 newValue = -10;
 }

 // Running average code from
 // https://www.arduino.cc/en/Tutorial/Smoothing
 // subtract the last reading:
 total = total - readings[readIndex];
 // read from the sensor:
 readings[readIndex] = newValue;
 // add the reading to the total:
 total = total + readings[readIndex];
 // advance to the next position in the array:
 readIndex = readIndex + 1;
 // if we're at the end of the array...
 if (readIndex >= numReadings) {
 // ...wrap around to the beginning:
 readIndex = 0;
 }
 // calculate the average:
 int avePos = total / numReadings;

 // set LEDs with following function and show them
 draw(avePos);
 pixels.show();

}

// Simple function resetting all pixels and lighten some around desired distance
void draw(int pix) {

 for (int i=0; i<60; i++) {
 pixels.setPixelColor(i, pixels.Color(2,0,0)); 
 } 
 pixels.setPixelColor(pix-2, pixels.Color(0,0,30)); 
 pixels.setPixelColor(pix-1, pixels.Color(0,0,100)); 
 pixels.setPixelColor(pix, pixels.Color(0,0,250)); 
 pixels.setPixelColor(pix+1, pixels.Color(50,0,50)); 
 pixels.setPixelColor(pix+2, pixels.Color(20,0,20)); 
}

Viel Spaß beim Nachbauen! Fragen und Anregungen bitte einfach in die Kommentare schreiben.

Ein PIR Sensor ist ein passiver Sensor (PIR = Passive InfraRed), der häufig in Bewegungsmeldern zum Einsatz kommt. Die gängigen PIR Module sind am Arduino sehr einfach aufgebaut und verfügen über 2 Pins für die Stromversorgung (+5V, GND) und ein Statuspin, das bei erkannter Bewegung auf HIGH gesetzt wird.

Einige PIR Module sind zusätzlich noch mit 2 Trim-Potentiometern ausgestattet, mit denen sich die Reichweite (meist max. 6-7m) und die Dauer des HIGH-Signals regeln lässt.

Ein einfaches Projekt, bei dem Funktionsweise und Einsatz eines PIR Sensors mit wenigen Zeilen Arduino-Code gezeigt werden, gibt es im folgenden Video:

Und hier der Arduino Sketch aus dem Video für den PIR Sensor:

int pirPin = 8;
int ledPin = 13;

void setup() {
 // put your setup code here, to run once:
 Serial.begin(9600);
 pinMode(pirPin, INPUT);
 pinMode(ledPin, OUTPUT);
}

void loop() {
 // put your main code here, to run repeatedly:
 int s = digitalRead(pirPin);
 digitalWrite(ledPin, s);
}

Der HC-SR04 ist ein sehr beliebter Low-Cost Entfernungssensor, der sich einfach mit dem Arduino abfragen lässt. Der HC-SR04 arbeitet mit Ultraschall, sendet also hochfrequente Schallwellen aus und setzt ein Pin auf HIGH, sobald das zurückgeworfene Echo vom Sensor registriert wird. Aus der zwischen Signal und Echo vergangenen Zeit lässt sich dann die Entfernung des nächsten Hindernisses berechnen.

HC-SR04 bei Amazon (5er Pack)

Der Distanzsensor wird über die 5V vom Arduino mit Strom versorgt und benötigt zwei weitere I/O-Pins zur Messung. Über das Trigger-Pin wird die Messung gestartet, d.h. eine Schallwelle ausgesendet. Das Echo-Pin des Sensor ändert seinen Zustand, sobald der vom Hindernis reflektierte Schall den Sensor erreicht.

Im folgenden Video wird die Funktionsweise und der Betrieb am Arduino erklärt:

Die NewPing-Library zur einfachen Ansteuerung des HC-SR04 Entfernungssensors wird hier erklärt http://playground.arduino.cc/Code/NewPing und die jeweils aktuelle Version steht bei Bitbucket zum Download bereit.

Der im Video verwendete Arduino Sketch:

// http://playground.arduino.cc/Code/NewPing
#include <NewPing.h>
 
#define TRIG_PIN 5
#define ECHO_PIN 11
#define MAX_DIST 400
 
NewPing sonar(TRIG_PIN, ECHO_PIN, MAX_DIST); // NewPing initialisieren
 
void setup() {
 Serial.begin(9600);
}
 
void loop() {
 delay(50);
 unsigned int distanceCM = sonar.ping_cm();
 Serial.print(distanceCM);
 Serial.println("cm");
}

Ich verwende die Sensoren von Elegoo, derzeit gibt es die Familienpackung mit 5 Stück HC-SR04 für unter 10 Euro bei Amazon. Ideal z.B. für Roboterprojekte, wo Hindernisse in mehreren Richtungen erkannt werden müssen.

Nachdem mein vor über 5 Jahren selbstgebauter 3D Drucker – ein aus Gewindestangen zusammengeschraubter Prusa i2 – schon deutliche Spuren des fortschreitenden Verfalls zeigt, hat conrad.at einen sehr guten Zeitpunkt erwischt, um mir einen Bausatz des neuen Renkforce RF500 3D Druckers zu Testzwecken zur Verfügung zu stellen.

Der RF500 füllt sowohl vom Leistungsumfang als auch preislich die Lücke zwischen dem großen Renkforce RF2000 und dem kleinen Einsteigergerät RF100.

Der Bausatz wird ohne beheizbares Druckbett geliefert und eignet sich damit vorerst mal nur zum Druck von PLA-Filament (1,75mm). Bei einem Düsendurchmesser von 0,4mm unterstützt das Gerät eine Druckschichtdicke von 0,05 – 0,3mm und einen Bauraum von 210 x 135 x 170mm.

Aus dem Bausatz habe ich in ca. 6 Arbeitsstunden anhand der Anleitung ohne größere Probleme den einsatzbereiten Drucker zusammengebaut. Die Anleitung steht als PDF auf der Produktseite zum Download bereit (Abschnitt: Dokumente und Downloads) und es empfiehlt sich, vor Baubeginn zu überprüfen, ob man das für den Bau  benötigte Werkzeug auch wirklich zur Verfügung hat, da es sonst während des Zusammenbaus immer wieder zu ungewollten Verzögerungen kommt. Zusätzlich lohnt es sich, alle Bauteile vor dem Baubeginn durchzuschauen und vor allem die Schrauben und Distanzhülsen der Größe nach zu sortieren.

Der Rahmen des Renkforce RF500 ist vollständig aus hochwertigen 20mm Aluprofilen aufgebaut, die mit 5mm Zylinderkopfschrauben verbunden werden. Beim Aufbau ist wichtig, dass der Rahmen auf einer ebenen Fläche zusammengebaut und beim Anziehen der Schrauben möglichst exakt rechtwinklig ausgerichtet wird. Der Rahmen ist wie der ganze Drucker vollständig aus Metall aufgebaut, lediglich die Standfüße sind aus Kunststoff, damit sie mit etwas Druck – notfalls in einem Schraubstock – in die Kugelkopfschrauben gepresst werden können. Für die Achsen werden THK Linearführungen verwendet, die hohe Präzision auch bei dauerhaften Einsatz sicherstellen sollen.

Auch der im Renkforce RF500 verwendete Filament-Extruder und das Hotend werden selbst zusammengebaut, was mein Verständnis für diese doch kritischen Bauteilgruppen deutlich verbessert hat und auch die Hemmschwelle vor der erneuten Zerlegung zu Wartungszwecken senkt. Das war in den ersten Wochen aber noch nicht notwendig.

Die Elektronik des RF500 basiert auf einem Arduino Mega, auf den ein RAMPS-Shield mit 4 Schrittmotortreibern aufgesteckt wird. Beim Zusammenbau sind dabei keine Lötarbeiten notwendig, alle Kabel zu den Schrittmotoren und Endschaltern sowie zur Heizpatrone samt Temperaturfühler werden über Stecker verbunden – genauso wie das Display, über das der Drucker mithilfe eines Drehknopfs gesteuert werden kann.

Auf dem Arduino Mega läuft eine von Conrad angepasste Marlin Firmware. Als Slicer wird RepetierHost empfohlen. Eine direkt einsetzbare Version der Software samt Konfiguration für den RF500 wird zur Verfügung gestellt, allerdings nur für Windows. Für Linux und Mac ist es nicht ganz so einfach, vor allem für den Mac gibt es aktuell nur eine ältere Version von RepetierHost, was die manuelle Konfiguration nicht gerade erleichtert.

Die vom Slicer erzeugte GCODE-Datei kann entweder direkt vom PC aus an den Drucker gesendet werden oder – meine bevorzugte Variante – auf eine SD-Karte gespeichert und von dieser gedruckt werden. Das hat auch den Vorteil, dass während des Drucks kein PC laufen muss und damit eine mögliche Fehlerquelle (automatische Windows-Updates etc.) ausgeschaltet wird.

Der Bausatz wird ohne ein beheizbares Druckbett geliefert, kann also in der Form nur PLA und keine ABS Kunststoffe drucken, da ABS ohne beheiztes Druckbett während des Druckvorganges zu stark schrumpft und sich von der Druckplatte lösen würde. Gedruckt wird auf eine 3M Haftfolie, die auf die Glasplatte geklebt wird und die bei PLA Drucken wirklich gut funktioniert und auch nach einigen Wochen noch keine Ermüdungserscheinungen zeigt.

Als Bewährungsprobe für den Drucker habe ich das bekannte Zahnradkugellager des Thingiverse-Users Emmet gedruckt. Das ist ein Planetengetriebe, bestehend aus  7 Zahnrädern, die sich innerhalb eines umschließendes Zahnradrings bewegen und so gestaltet sind, dass sie sich auch nicht entfernen lassen. Das gesamte Getriebe wird in einem Stück gedruckt und war direkt nach dem Abnehmen vom Druckbett funktionsfähig.

Mein Video zum Renkforce RF500 Maker Bausatz:

Mein Fazit:

Der Renkforce RF500 Maker Bausatz bietet im Vergleich zu meinem alten 3D Drucker eine enorme Verbesserung bei Komfort, Geschwindigkeit und Druckqualität und ist derzeit mein Standarddrucker und fast täglich im Einsatz. Fehldrucke oder Druckabbrüche gab es bisher nur bei fehlerhafter Filament-Zufuhr, die ich aber durch den Ausdruck zusätzlicher Filamenthalterungen für die von mir verwendeten Rollen in den Griff bekommen habe.

Mit der Windows-Version von RepetierHost habe ich mich zwangsweise angefreundet, möchte aber möglichst bald mit Cura slicen – sobald ich die Konfiguration für den RF500 richtig hinbekommen (oder ein fertiges Profil dafür gefunden) habe.

Der großteils gut durchdachte Aufbau des Rahmens gefällt mir sehr gut und lässt viel Raum für die Montage eigener Erweiterungen (GoPro-Halterung usw). Erstaunt hat mich die trotz fehlenden Gehäuses sehr geringe Geräuschentwicklung beim Druck, vor allem im Vergleich zu meinem alten Prusa i2.

Die Kritikpunkte beschränken sich aus meiner Sicht neben der an manchen Stellen nicht ganz eindeutigen Anleitung (manche Punkte wurden in der Zwischenzeit bereits korrigiert) auf den vergleichsweise kleinen Bauraum, der bei meinen üblichen Anwendungen (Kleinteile für meine Bastelprojekte) aber keine Rolle spielt.

Alles in allem ist der Renkforce RF500 Maker Bausatz ein sehr empfehlenswerter 3D Drucker. Der aktuelle Preis (Stand 06/2017) von €699,00 liegt natürlich über dem ähnlicher Bausätze aus China, man bekommt aber auch eine entsprechende hohe Qualität bei der Anleitung und in der Ausführung.

Der Online-Versender Gearbest hat mir freundlicherweise einen 3D Drucker vom Typ Creality CR-10 zu Testzwecken zur Verfügung gestellt. Der Drucker kommt als Bausatz, ist aber praktisch fertig zusammengebaut und in weniger als einer Stunde einsatzbereit.

Die Druckqualität ist sehr gut, über die Qualität des Rahmens und der mechanischen Komponenten kann ich derzeit noch keine Aussage machen, dazu hat der Drucker noch zu wenig Betriebsstunden.

Hier das Video:

Und die im Video erwähnten Dateien und Links:

• CR10_20mm_xyzCalibration_cube.gcode – 20mm Kalibrierungswürfel – direkt druckbare GCODE-Datei für den Creality CR-10 (20% Infill)
• CR10_cat.gcode – Winkekatze (Lucky Cat) – korrigierte Version der von Creality teilweise fehlerhaft ausgelieferten Datei – ebenfalls direkt druckbar mit dem Creality CR-10 (0% Infill)
• Facebook-Gruppe zum Drucker – im Bereich „Dateien/Files“ gibt es die Profile für Cura samt Installationshinweisen in den Kommentaren
• www.crforums.com – alle denkbaren Fragen rund um den CR-10 werden in diesem Forum behandelt
• Creality CR-10 im Online-Shop von Gearbest.com (aktueller Gutscheincode: SPCR10)

Das Elegoo Robot Car Kit gibt es mittlerweile in der 3. Version. Grund genug, dass ich es mir mal genauer angeschaut habe. Das erste Video umfasst das Unboxing und eine kurze Vorstellung der enthaltenen Bauteile und der Anleitung.

Das Robot Car Kit enthält einige ganz interessante Bauteile, die sich auch in vielen anderen Projekten einsetzen und weiterverwenden lassen. Neben einem Clone des Arduino Uno R3 gibt es ein eigenes Expansion Shield, an dem man den Ultraschall Entfernungssensor HC-SR04 samt zugehörigem Servo, das Line Tracking Modul mit 3 digitalen Liniensensoren und das Bluetooth Low Energy Modul HC-08 direkt anschliessen kann. Die Pins der einzelnen Module werden dabei direkt auf Arduino Pins weitergeleitet, alles ist gut beschriftet. Der Infrarot Sensor als Empfänger für die IR-Fernsteuerung ist direkt auf dem Expansion Shield montiert.

Die 4 Getriebemotoren samt Bereifung werden über ein kleines Motortreiber-Shield angesprochen, das mit einer H-Bridge vom Typ L298N samt großem Kühlkörper ausgestattet ist.

Zur Stromversorgung sind 2 Akkus (2200mAh, 3.7V) samt Ladegerät enthalten. Wie viel Betriebszeit man mit einer Akkuladung kriegt, habe ich noch nicht ausprobieren können.

In den nächsten Wochen zeige ich dann den Zusammenbau des Basismodells in einem eigenen Video.

Das Elegoo Robot Car Kit 3.0 gibts zu einem guten Preis bei Amazon: http://amzn.to/2iyxYvt

Der Einstieg in die Welt der Arduino Mikrocontroller gelingt am besten und preiswertesten mit einem Arduino Starter Kit. Mittlerweile sind Einsteiger-Pakete zwischen 15 und knapp 100 Euro am Markt und dank Amazon & Co. auch leicht erhältlich. Hätte ich vor einigen Jahren noch blind das originale Arduino/Genuino Starter Kit empfohlen, so bietet mittlerweile die Firma Elegoo die preislich attraktivsten Starter Kits für fast jedes Projekt an.

Jedes Starterkit enthält ein Arduino UNO kompatibles Mikrocontroller Board, das einsteigerfreundlich über USB an den PC/Mac angeschlossen und programmiert werden kann.

Drei der bekannteren Arduino Starter Kits möchte ich hier kurz vorstellen.

Elegoo Uno Ultimate Starter Kit

Etwas großspurig bezeichnet der Hersteller das umfangreichste Starter Kit aus der eigenen Produktpalette gleich als das „Most Complete Starter Kit„. Und ja, in gewisser Weise hat er da nicht Unrecht.

Eine vergleichbare Menge an Bauteilen findet man tatsächlich in keinem anderen Kit und durch die stetig steigende Qualität der Anleitung können auch deutschsprachige Kunden beim Elegoo Uno Ultimate Starter Kit mittlerweile bedenkenlos zugreifen. Viele der enthaltenen Bauteile gehen dann auch weit über das Einstiegslevel hinaus und bieten auch ambitionierten Elektronik-Bastlern Stoff für interessante Arduino Projekte.

Einige Highlights aus dem Starter Kit:

• Elegoo Uno R3 (baugleich und voll kompatibel zum Arduino Uno R3)
• Großes Breadboard (Steckplatine) und viele Verbindungskabel
• Modellbau-Servo
• Ultraschall-Abstandssensor
• 4-stellige 7-Segment Anzeige
• MAX 7219 LED Display mit 8×8=64 LEDs
• Infrarot-Fernbedienung samt Empfängermodul
• Joystick & Drehencoder
• DHT11 Temperatur- und Feuchtigkeitssensor
• 74HC595 Schieberegister & L293D H-Brücke
• Batteriegepufferte Echtzeituhr
• LCD Display Modul 1602 (16 Zeichen, 2-zeilig)
• Schrittmotor mit Motortreiber
• Wasserstandssensor
• Piezo Tongenerator
• Lärmsensor
• Lichtempfindliche Widerstände (Helligkeitssensor)
• Infrarot Bewegungsmelder
• ADXL335 3-Achsen Beschleunigungssensor
• RFID Modul samt Chip
• Unmengen an Widerständen, LEDs, Dioden, Transistoren usw.

Alle enthaltenen Bauelemente sind direkt einsetzbar, es muss nichts gelötet werden. Die deutsche Anleitung findet man als PDF auf der beiliegendem CD-ROM oder als Download auf der Website des Herstellers. Enthalten sind etwa 30 Projekte von ganz einfach bis hin zu anspruchsvoll.

Meine Kaufempfehlung für ambitionierte Kinder und interessierte Erwachsene!
Das Elegoo Ultimate Starter Kit gibt es um EUR 46,99 bei Amazon

Elegoo UNO Super Starter Kit

Einen Mittelweg zwischen den Basic und dem Ultimate Kit von Elegoo findet dieses Starter Kit. Es verfügt im Vergleich zur günstigeren Basisversion über einige interessante Bauelemente, mit denen sich auch schon anspruchsvollere Projekte realisieren lassen, verzichtet aber auf die ganz schweren Kaliber, zu deren Verwendung ohnehin schon mehr Erfahrung im Bereich Elektronik notwendig ist.

Im Super Starter Kit sind unter anderem enthalten

• Elegoo Uno R3 (baugleich und voll kompatibel zum Arduino Uno R3)
• Großes Breadboard (Steckplatine) und viele Verbindungskabel
• Infrarot-Fernbedienung samt Empfängermodul
• Modellbau-Servo
• Ultraschall-Abstandssensor
• 4-stellige 7-Segment Anzeige
• Schrittmotor mit Motortreiber
• 74HC595 Schieberegister & L293D H-Brücke
• Piezo Tongenerator
• DHT11 Temperatur- und Feuchtigkeitssensor
• Gleichstrommotor
• Lichtempfindliche Widerstände (Helligkeitssensor)
• Unmengen an Widerständen, LEDs, Dioden, Transistoren usw.

Meine Kaufempfehlung für Kinder bis 12 Jahren!
Die Anleitung von CD-ROM oder zum Download von der Hersteller-Website führt verständlich und gut illustriert durch die einzelnen Projekte. Mit den enthaltenen Bauteilen können auch ohne Vorwissen sehr schöne Experimente durchgeführt werden. Etwas Erfahrung in der Bedienung eines PCs wird natürlich vorausgesetzt.

Das Elegoo Super Starter Kit gibt es um EUR 33,81 bei Amazon.

Elegoo UNO Basic Starter Kit

Das Basic Starter Kit  ist die günstigste Möglichkeit, um sich für wenig Geld mit dem Thema Arduino Mikrocontroller beschäftigen zu können. Das Set eignet sich sehr gut für Anfänger, man kann sofort loslegen und einfache Projekte mit Drucktastern, Widerständen und LEDs realisieren. Enthalten sind unter anderem:

• Elegoo Uno R3 (baugleich und voll kompatibel zum Arduino Uno R3)
• Kleines Breadboard (Steckplatine) und Verbindungskabel
• 74HC595 Schieberegister
• Piezo Tongenerator
• Tilt Sensor
• Lichtsensor (lichtempfindliche Wicderstände)
• RGB LED
• viele einfarbige LED (gelb, blau, grün, rot)
• Drucktaster
• Widerstände

Die Anleitung ist als PDF auf der CD-ROM enthalten oder kann von der Website des Herstellers geladen werden. Die Tutorials durch die einzelnen Projekte sind gut verständlich aufgebaut und auch für den Einsteiger leicht nachzuvollziehen. Für meinen Geschmack ist die Box, in der das Set geliefert wird, etwas zu klein. Erstmal ausgepackt kann man sich kaum erklären, wie die Teile jemals in diese kleine Schachtel gepasst haben.

Ansonsten aber top für Arduino Einsteiger, zum unschlagbaren Preis von EUR 17,61 bei Amazon erhältlich.

In diesem längeren Youtube-Video zeige ich, wie man einen RFID Transponder (auch RFID Tag oder RFID Token genannt) mit einem MFRC-522 Modul als Lesegerät am Arduino auslesen und damit eine einfache Schaltung steuern kann.

Die meisten MFRC-522 Card Reader Module für den Arduino enthalten einen blauen Token und zusätzliche eine weiße RFID Karte mit unterschiedlichen UIDs. Diese lassen sich auslesen und damit kann man, wie im Video gezeigt, mit dem Arduino verschiedene Aktionen auslösen, z.B. LEDs ein- und ausschalten oder einen Servo für ein Schloss steuern.

Die beiden im Video verwendeten Arduino Sketches gibts am Ende der Seite:

Hier der Sketch zum Auslesen der UID.

Die eingebunden MFRC522-Library kann man über den Library Manager der Arduino IDE installieren („Sketch“->“Include library“->“Manage libraries“). Dort einfach „mfrc522“ ins Suchfeld eingeben und die angezeigte Library installieren.

Sketch 1 – RFID Transponder UID auslesen:

/*
 * Typical pin layout used:
 * -----------------------------------------------------------------------------------------
 *             MFRC522      Arduino       Arduino   Arduino    Arduino          Arduino
 *             Reader/PCD   Uno/101       Mega      Nano v3    Leonardo/Micro   Pro Micro
 * Signal      Pin          Pin           Pin       Pin        Pin              Pin
 * -----------------------------------------------------------------------------------------
 * RST/Reset   RST          9             5         D9         RESET/ICSP-5     RST
 * SPI SS      SDA(SS)      10            53        D10        10               10
 * SPI MOSI    MOSI         11 / ICSP-4   51        D11        ICSP-4           16
 * SPI MISO    MISO         12 / ICSP-1   50        D12        ICSP-1           14
 * SPI SCK     SCK          13 / ICSP-3   52        D13        ICSP-3           15
 */

#include <SPI.h>
#include <MFRC522.h>

#define RST_PIN   9     // SPI Reset Pin
#define SS_PIN    10    // SPI Slave Select Pin

MFRC522 mfrc522(SS_PIN, RST_PIN);   // Instanz des MFRC522 erzeugen

void setup() {
  // Diese Funktion wird einmalig beim Start ausgeführt
  Serial.begin(9600);  // Serielle Kommunikation mit dem PC initialisieren
  SPI.begin();         // Initialisiere SPI Kommunikation
  mfrc522.PCD_Init();  // Initialisiere MFRC522 Lesemodul
}

void loop() {
  // Diese Funktion wird in Endlosschleife ausgeführt

  // Nur wenn eine Karte gefunden wird und gelesen werden konnte, wird der Inhalt von IF ausgeführt
  // PICC = proximity integrated circuit card = kontaktlose Chipkarte
  if (mfrc522.PICC_IsNewCardPresent() && mfrc522.PICC_ReadCardSerial() ) {
    Serial.print("Gelesene UID:");
    for (byte i = 0; i < mfrc522.uid.size; i++) {
      // Abstand zwischen HEX-Zahlen und führende Null bei Byte < 16
      Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " ");
      Serial.print(mfrc522.uid.uidByte[i], HEX);
    }
    Serial.println();

    // Versetzt die gelesene Karte in einen Ruhemodus, um nach anderen Karten suchen zu können.
    mfrc522.PICC_HaltA();
    delay(1000);
  }
}

und der etwas längere 2. Sketch, mit dem 2 LEDs an Pin 3 & 5 gesteuert werden:

/*
 * Typical pin layout used:
 * -----------------------------------------------------------------------------------------
 *             MFRC522      Arduino       Arduino   Arduino    Arduino          Arduino
 *             Reader/PCD   Uno/101       Mega      Nano v3    Leonardo/Micro   Pro Micro
 * Signal      Pin          Pin           Pin       Pin        Pin              Pin
 * -----------------------------------------------------------------------------------------
 * RST/Reset   RST          9             5         D9         RESET/ICSP-5     RST
 * SPI SS      SDA(SS)      10            53        D10        10               10
 * SPI MOSI    MOSI         11 / ICSP-4   51        D11        ICSP-4           16
 * SPI MISO    MISO         12 / ICSP-1   50        D12        ICSP-1           14
 * SPI SCK     SCK          13 / ICSP-3   52        D13        ICSP-3           15
 */

#include <SPI.h>
#include <MFRC522.h>

#define RST_PIN   9     // SPI Reset Pin
#define SS_PIN    10    // SPI Slave Select Pin

MFRC522 mfrc522(SS_PIN, RST_PIN);   // Instanz des MFRC522 erzeugen

byte blue_uid[] = {0x20, 0x89, 0x87, 0x15};
byte red_uid[] = {0xD2, 0xFB, 0x2C, 0x5B};

int blue_led = 5; // Pin der blauen LED
int red_led = 3; // Pin der roten LED

int blue_check = false;
int red_check = false;


void setup() {
  // Diese Funktion wird einmalig beim Start ausgeführt
  Serial.begin(9600);  // Serielle Kommunikation mit dem PC initialisieren
  SPI.begin();         // Initialisiere SPI Kommunikation
  mfrc522.PCD_Init();  // Initialisiere MFRC522 Lesemodul
  pinMode(blue_led, OUTPUT);
  pinMode(red_led, OUTPUT);
}

void loop() {
  // Diese Funktion wird in Endlosschleife ausgeführt

  // Nur wenn eine Karte gefunden wird und gelesen werden konnte, wird der Inhalt von IF ausgeführt
  // PICC = proximity integrated circuit card = kontaktlose Chipkarte
  if (mfrc522.PICC_IsNewCardPresent() && mfrc522.PICC_ReadCardSerial() ) {
    Serial.print("Gelesene UID:");
    for (byte i = 0; i < mfrc522.uid.size; i++) {
      // Abstand zwischen HEX-Zahlen und führende Null bei Byte < 16
      Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " ");
      Serial.print(mfrc522.uid.uidByte[i], HEX);
    }
    Serial.println();

    // UID Vergleichen mit blue_uid
    blue_check = true;
    for (int j=0; j<4; j++) {
      if (mfrc522.uid.uidByte[j] != blue_uid[j]) {
        blue_check = false;
      }
    }

    // UID Vergleichen mit red_uid
    red_check = true;
    for (int j=0; j<4; j++) {
      if (mfrc522.uid.uidByte[j] != red_uid[j]) {
        red_check = false;
      }
    }

    if (blue_check) {
      digitalWrite(blue_led, HIGH);
    }

    if (red_check) {
      digitalWrite(red_led, HIGH);
    }

    // Versetzt die gelesene Karte in einen Ruhemodus, um nach anderen Karten suchen zu können.
    mfrc522.PICC_HaltA();
    delay(1000);
    digitalWrite(blue_led, LOW);
    digitalWrite(red_led, LOW);
  }

}

Das vorgestellte MFRC-522 RFID Card Reader Modul kann man einzeln oder als Teil eines Arduino Starter Kits kaufen, z.B.:

Nach einigen Bausätzen mit mehr oder weniger Fertigstellungsaufwand wollte ich mal einen 3D Drucker testen, der sich gezielt an Einsteiger wendet, als sofort einsetzbares Gerät geliefert wird und trotzdem noch im unteren Preisbereich angesiedelt ist. Ausgesucht habe ich mir dazu den da Vinci Mini w von XYZprinting.com, in Österreich und Deutschland zum Beispiel vertrieben durch Reichelt Elektronik, die mir freundlicherweise auch ein Testgerät zur Verfügung gestellt haben. Der Straßenpreis des 3D Druckers beträgt aktuell etwa € 280,00.

Nach dem Auspacken müssen die Transportsicherungen (Klemmen und Klebeband) entfernt und der Druckkopf in den Schlitten gesetzt werden. Für das Druckbett werden 3 Blätter einer Haftfolie mitgeliefert, die bei mir aber nicht besonders gut gehaftet hat. Dann noch das mitgelieferte Filament einsetzen und einfädeln und der Drucker ist bereit für den Einsatz.

Als Software dient XYZware vom Hersteller. Download, Installation und Verbindung mit dem Drucker funktioniert problemlos. Etwas nervig ist lediglich die erzwungene Registrierung samt Anlage eines Benutzerkontos vor dem ersten Druck. Der Drucker kann über USB oder per WLAN gesteuert werden.

Der Drucker verarbeitet nur die originalen Filamentspulen des Herstellers. Dafür sorgt einerseits ein RFID-Tag, mit dem jede Spule gechipt ist und zusätzlich noch die speziell geformte Spulenhalterung. Das PLA Filament von XYZprinting.com ist merklich teurer, dafür laut Herstellerangaben aus Maisstärke hergestellt, biologisch abbaubar, ungiftig und frei von Schwermetallen. Das ist z.B. beim Einsatz mit kleineren Kindern oder in der Schule nicht ganz unwichtig.

Die ersten Drucke des 20mm Kalibrierungswürfels waren leider nicht erfolgreich, durch die relativ geringe Auflagefläche wollte das Druckobjekts nicht am Druckbett (bzw. der mitglieferten Klebefolie) haften. Erst mit etwas Uhu-Stick auf der Haftfolie ging es dann.

Im Video zeige ich die wesentlichen Funktionen des Druckers und der Software und einige Testdrucke.

Der Drucker ist z.B. bei diesem Anbieter erhältlich:
https://www.reichelt.de/3D-Drucker/DA-VINCI-MINI-W/3/index.html?ACTION=3&GROUPID=7354&ARTICLE=182710

[Update 15.01.2018 am Ende des Artikels]:

3D-Drucken sollte eigentlich ja Spaß machen, manchmal kann es einen aber auch zur Verzweiflung treiben. Da funktioniert die Mechanik des 3D-Druckers einwandfrei, der Extruder befördert das Filament in Richtung Druckkopf und presst es durch die Düse auf das Druckbett – und das vielleicht schon seit Stunden.

Und dann das: Das Druckobjekt löst sich während des Drucks an einer Ecke vom Druckbett – das sogenannten Warping – oder überhaupt auf der gesamten Auflagefläche.

Alarm! Im besten Fall sitzt man grade daneben und schaut zu, wie sich viele Stunden Druckzeit in einen Fall für den Müll verwandeln. Im schlimmeren Fall druckt der 3D Printer unbeaufsichtigt noch eine Nacht lang vor sich hin und produziert einen großen Knäuel Filament.  Spätestes dann beschäftigt sich jeder damit, wie die Haftung der ersten Schicht am Druckbett weiter verbessert werden kann.

In den letzten 5 Jahren seit dem Bau meines erstem 3D-Druckers hat sich da einiges getan. Anfangs noch mit Kapton-Band, das mir aber bald zu mühselig war und bald durch eine selbst angerührte Aceton-ABS-Pampe ersetzt wurde, die ich vor dem Druck auf die  Glasplatte pinselte. Später gab es dann immer mehr spezielle Haftfolien und Druckbetten, die für eine sichere Haftung sorgen sollten. Meistens reicht das auch.

Bei besonders heiklen Fällen mit sehr wenig Auflagefläche wie dem Astronauten rechts im Bild benötigt man aber zusätzliche Unterstützung, um die Verbindung zwischen Druckbett und erster Schicht des Druckobjekts noch weiter zu verstärken.

Seit einigen Wochen verwende ich jetzt den printafix Haftspray von der Firma Aprintapro bei beinahe allen meinen Drucken, egal ob ABS, PLA, beheiztes Druckbett oder nicht. Vor dem Druck einige Sprüher des Haftsprays auf das Druckbett (vorher kurz schütteln) und die Drucke halten bombenfest.

Direkt nach dem Druck auf einem beheizten Druckbett sogar zu fest, erst mit sinkender Temperatur kommt dann wieder der Punkt, wo sich Objekt mit einem sorgfältig gesetzten Schlag von der Druckfläche lösen lässt. Ich verwende dazu meistens einen scharfen Spachtel, den ich an einer Ecke des Objekts ansetze und dann mit einem kleinen Hammer (oder dem Griff eines schwereren Schraubenziehers) leicht anschlage.

[Update 15.01.2018]:
Nach einigen Wochen mit printafix bin ich restlos überzeugt von diesem Haftspray und kann ihn nur weiterempfehlen. Leider ist der Spray bei Amazon derzeit nur bei einem Händlerzu erhalten – und das ziemlich überteuert. Mittlerweile habe ich einen weiteren ähnlichen Spray namens 3DLac Sprühkleber gefunden, konnte den aber wegen der horrenden Versandkosten nach Österreich bisher nicht testen.

Der von Edwin Hall 1879 in seiner Dissertation erstmals beschriebene Effekt (Wikipedia) beschreibt das Verhalten von geladenen Teilchen, die sich durch ein Magnetfeld bewegen, das quer zu ihrer Bewegungsrichtung liegt. In einem stromdurchflossenen Leiter, auf den senkrecht dazu ein Magnetfeld wirkt, driften die Elektronen abhängig von der Richtung des einwirkenden Magnetfelds an einen Rand des Leiters. Dadurch entsteht zwischen den äußeren Rändern des Leiters aufgrund der Ladungsverschiebung eine Spannung.

Während in einem normalen Leiter mit kreisförmigem Querschnitt der Effekt minimal ist, kann man in einem rechteckigen Leiter mit größerer Fläche (z.B. einem flachen Plättchen) den Spannungsunterschied zwischen den Rändern des Leiters messen. Nach diesem Prinzip arbeitet ein Hall-Effekt Sensor.

Der Hall-Effekt ist zwar ein analoger Effekt, d.h. die messbare Spannung verändert sich mit der Stärke des einwirkenden Magnetfelds, die meisten handelsüblich verfügbaren Hall-Effekt Sensoren sind jedoch mit einem digitalen Ausgangspin ausgestattet und können damit zwar als berührungsloser Schalter (Switch) genutzt werden, nicht aber zur linearen Messung der Magnetfeldstärke.

Bei den Hall-Effekt Sensoren unterscheidet man verschiedene Funktionsweisen:

• Latching Hall-Effekt Sensoren merken sich den zuletzt erkannten Zustand, behalten diesen auch bei Entfernung des Magneten bei und benötigen ein Magnetfeld in der entgegengesetzten Richtung, um den Zustand zu wechseln
• Non-Latching Hall-Effekt Sensoren wechseln und während der Anwesenheit eines Magnetfelds den Zustand und fallen bei Entfernung des Magneten wieder in den Ausgangszustand. Diese Sensoren gibt es unipolar (erkennen nur eine magnetische Polarität) und bipolar (erkennen beiden Polaritäten)

Zum Einsatz am Arduino weit verbreitet sind Sensoren vom Typ US1881 (latching) und US5881 (non-latching), die in Online-Shops wie Adafruit und Sparkfun, aber auch bei Amazon erhältlich sind.

Die Sensoren verfügen über 3 Anschlüsse, die meistens (von der schmalen Seite aus gesehen) in der Reihenfolge [ +5V – GND – Signalpin ] angeordnet sind.

Sensoren wie der US1881 verfügen über einen Open-Collector Signalausgang und benötigen zusätzlich einen 10kOhm Widerstand zwischen +5V und dem Signalpin, um korrekt zu funktionieren (oder den internen Pull-Up Widerstand des Arduino-Pins).

Anschluss und Verwendung eines Hall-Effekt Sensors am Arduino seht ihr im folgenden Tutorial:

Hier der im Video verwendete Sketch:

const int ledPin = 7;
const int hallPin = 4;

void setup() {
  pinMode(4, INPUT);
  pinMode(7, OUTPUT);
}

void loop() {
  digitalWrite(ledPin, digitalRead(hallPin));
}

Bezugsquellen für einen US1881 oder kompatiblen Hall-Effekt Sensor:

Lineare Hall Effekt Sensoren sind etwas schwieriger zu finden, bei Amazon sind sie z.B. in diesen umfangreichen Sensor Kits enthalten:

In diesem Arduino Projekt seht ihr, wie man mit einem 4×4 Keypad zur Eingabe von Pincodes und einem Servo ein einfaches Schloss bauen kann, das sich nur nach Eingabe des richtigen Codes öffnet.

In vielen Arduino Starter Kits sind mittlerweile 3×4 oder 4×4 Keypads enthalten, mit denen sich sehr einfach Benutzereingaben erfassen und verarbeiten lassen. Mein 4×4 Keypad ist aus einem Ultimate Starter Kit von Elegoo. Dieses Set enthält auch alle anderen für dieses Projekt benötigten Teile.

Wie funktionieren diese Keypads nun? Für das Auslesen eines Tastendrucks auf diesen 16 Tastenschaltern soll man ja wenn möglich nicht gleich 16 Pins am Arduino benötigen. So viele hat man auf vielen Boards ja auch gar nicht zur Verfügung. Bei einem 4×4 Membran-Keypad werden durch Multiplexing nur 8 Pins benötigt, es gibt auch Lösungen mit noch weniger. Die 8 Anschlüsse aus dem Keypad kommen an 8 Digitalpins des Arduino. 4 Pins dienen dem Arduino dabei als Ausgang und sind zum Beispiel mit den 4 Zeilen des Keypads verbunden. Die anderen 4 Pins werden als Eingänge verwendet und sind mit den Spalten verbunden. Jeweils an diesen Kreuzungen liegt ein Membranschalter, der im gedrückten Zustand die Verbindung zwischen Zeile und Spalte herstellt.

Zur Abfrage eines Tastendrucks wird nicht das gesamte Tastenfeld gleichzeitig überwacht, sondern es werden die einzelnen Zeilen in jeweils kurzen Abständen mit Strom versorgt, d.h. das zugehörige Ausgangspin am Arduino geht auf HIGH. Wird in dieser Zeit eine Taste in dieser Zeile gedrückt, so schliesst sich der Membranschalter und am zugehörigen Eingangspin, das an dieser Spalte angeschlossen ist, wird am Arduino ein HIGH messbar. Da man jetzt weiß, welche Zeile gerade mit Strom versorgt wird und welche Spalte sich als HIGH zurückmeldet, muss der Schalter am Schnittpunkt von Zeile und Spalte gerade gedrückt sein. Das alles passiert in Zyklen von Millisekunden, sodass auch garantiert jeder Tastendruck erkannt wird.

Um die technischen Feinheiten müssen wir uns glücklicherweise nicht kümmern, wie beim Arduino zu erwarten gibt es dafür eine fertige Library. Über den Library Manager der Arduino Entwicklungsumgebung könnt ihr euch die Keypad-Library installieren. In Ordner Examples findet ihr dann das Code-Beispiel HelloKeypad, das die Initialisierung des Keypad-Objekts zeigt.

Hier das Tutorial-Video für dieses Projekt.

Und hier der im Video verwendeten Source-Code für das Servoschloss:

#include <Keypad.h>
#include <Servo.h> 

// Pinlänge und Pincode festlegen
const byte PINLENGTH = 4;
char pinCode[PINLENGTH+1] = {'0','8','1','5'};

// Zwischenspeicher für Eingaben
char keyBuffer[PINLENGTH+1] = {'-','-','-','-'};

// Kompakter kann man das auch so schreiben:
// char pin[] = "0815";
// char keyBuffer[] = "----";

// Definition für das Keypad von Elegoo
const byte ROWS = 4; // vier Zeilen
const byte COLS = 4; // vier Spalten
// Symbole auf den Tasten
char hexaKeys[ROWS][COLS] = {
  {'1','2','3','A'},
  {'4','5','6','B'},
  {'7','8','9','C'},
  {'*','0','#','D'}
};
byte rowPins[ROWS] = {9, 8, 7, 6}; //connect to the row pinouts of the keypad
byte colPins[COLS] = {5, 4, 3, 2}; //connect to the column pinouts of the keypad

// Einstellung für Servo und LEDs
const int greenPin = 12;
const int redPin = 13;
const int servoPin = 11;
const int angleClosed = 30;
const int angleOpen = 120;
const int openDelay = 3000;

// Servo-Objekt erzeugen
Servo myservo;

// Instanz von Keypad erzeugen, Keymap und Pins übergeben
Keypad customKeypad = Keypad( makeKeymap(hexaKeys), rowPins, colPins, ROWS, COLS); 

void setup(){
  Serial.begin(9600);
  // LED Pins setzen
  pinMode(greenPin, OUTPUT);
  pinMode(redPin, OUTPUT);
  digitalWrite(greenPin, LOW);
  digitalWrite(redPin, LOW);
  // Servo auf Ausgangsposition
  myservo.attach(servoPin);
  myservo.write(angleClosed);
}
  
void loop(){
  // Gedrückte Taste abfragen
  char customKey = customKeypad.getKey();

  if (customKey) {
    // Check, ob ASCII Wert des Char einer Ziffer zwischen 0 und 9 entspricht
    if ((int(customKey) >= 48) && (int(customKey) <= 57)){ 
      addToKeyBuffer(customKey); 
    }
  // oder Code überprüfen, falls Raute gedrückt wurde 
    else if (customKey == '#') { 
      checkKey(); 
    } 
  } 
} 

void addToKeyBuffer(char inkey) { 
  Serial.print(inkey); 
  Serial.print(" > ");
  // Von links nach rechts Zeichen um eins weiterkopieren = ältestes Zeichen vergessen
  for (int i=1; i<PINLENGTH; i++) {
    keyBuffer[i-1] = keyBuffer[i];
  }
  // in ganz rechter Stelle die letzte Ziffer speichern
  keyBuffer[PINLENGTH-1] = inkey;
  Serial.println(keyBuffer);
}

void checkKey() {
  // Eingabe mit festgelegtem Pincode vergleichen
  if (strcmp(keyBuffer, pinCode) == 0) {
    Serial.println("CORRECT");
    // Aktion für richtigen Pin ausführen
    pinCorrect();
  }
  else {
    Serial.println("WRONG!");
    // Aktion für falschen Pin ausführen
    pinWrong();
  }

  // Nach Überprüfung Eingabe leeren
  for (int i=0; i < PINLENGTH; i++) {
    keyBuffer[i] = '-'; 
  }
}

// Aktion für korrekten Pincode
void pinCorrect() {
  myservo.write(angleOpen);
  digitalWrite(greenPin, HIGH);
  delay(openDelay);
  myservo.write(angleClosed);
  digitalWrite(greenPin, LOW);
}

// Aktion für falschen Pincode
void pinWrong() {
  for (int i=0; i<3; i++) {
    digitalWrite(redPin, HIGH);
    delay(50);
    digitalWrite(redPin, LOW);  
    delay(20);
  }
}

Je nach Keypad können  die Arrays hexaKeys, colPins und rowPins unter Umständen andere Werte benötigen. Diese findet man aber üblicherweise im Beispielcode des Herstellers.

Diese einfache Eingabe von Werten über das Tastenfeld kann als Grundlage für viele weitere Projekte dienen, z.B. für Zahlenratespiele oder zur Erfassung von Projektkonfigurationen (Motorgeschwindigkeit steuern etc.).

Alle im Projekt verwendeten Bauteile (und viele mehr) findet ihr im Ultimate Starter Kit von Elegoo, aber natürlich sind die Keypads auch einzeln erhältlich.

Mit einem Sound Sensor Modul für den Arduino kann man ganz einfach laute Geräusche wie z.B. Händeklatschen oder Klopfen erkennen und darauf reagieren.

Die gängigen Schallsensoren aus den verschiedenen Arduino Starter Kits basieren meistens auf einem Operationsverstärker wie dem IC LM393. Damit wird die vom Mikrofon erzeugte Spannung mit dem Operationsverstärker verstärkt und mit der über ein Potentiometer eingestellten Referenzspannung verglichen. In Ausgang des Moduls wird dann dem Ergebnis entsprechend gesetzt und kann mit dem Arduino ausgelesen werden.

Im Video zeige ich, wie man mit dem Arduino und wenigen Zeilen Programmcode mit einem lauten Geräusch zwischen zwei LEDs umschalten kann. Mit ähnlichem Programmcode könnte man aber natürlich auch einen Servo oder ein Relais ansteuern.

Mehr dazu im folgenden Tutorial Video:

Und hier der Arduino Sketch, der im Video verwendet wird:

// Pins definieren
const int greenPin = 12;
const int redPin = 13;
const int soundPin = 7;

// Aktueller Status, boolean kann nur false/0 oder true/1 sein
// d.h. "not 0" = 1 und "not 1" = 0
// statt "not" kann man auch "!" schreiben
boolean greenLedStatus = false;

// Wie lange warten nach Ton?
const int pauseDelay = 200;

void setup() {
  // Pins konfigurieren und LEDs auf Start setzen
  Serial.begin(9600);
  pinMode(soundPin, INPUT);
  pinMode(greenPin, OUTPUT);
  pinMode(redPin, OUTPUT);
  digitalWrite(greenPin, greenLedStatus);
  digitalWrite(redPin, !greenLedStatus);
}

void loop() {
  // Digitalpin 7 auslesen und bei LOW umschalten
  int din = digitalRead(soundPin);
  if (!din) {
    greenLedStatus = !greenLedStatus;
    digitalWrite(greenPin, greenLedStatus);
    digitalWrite(redPin, !greenLedStatus);
    // Das HIGH ist nicht ganz logisch, da am Pin ja eigentlich ein LOW anliegt :)
    Serial.println("HIGH!");
    delay(pauseDelay);
  }
}

Das im Video verwendete Schallsensor-Modul stammt aus einem Elegoo Ultimate Starter Kit, das ich als umfangreiche Sammlung von Bauteilen für den Einstieg empfehlen kann.