Die große Arduino Laser Show

Inhaltsverzeichnis

Laser finden sich in vielen wichtigen medizinischen Produkten. Sie spielen eine wichtige Rolle in der (Unterhaltungs-)Elektronik, dienen als essenzielle Zutat von SciFi-Blockbustern, und haben noch viele weitere Anwendungen. Laser sind einfach spannend. Grund genug also, sie auch in eigenen Schaltungen zu verwenden.

Laserschwerter oder Laserwaffen in Science Fiction Filmen waren schon immer spannend. Und bekanntlich sind optische Laufwerke oder Beamer nur dank Laser möglich. Wozu aber sollte das Thema für die Arbeit mit Mikrocontrollern wie Arduino interessant sein?

Arduino meets Laser

Nach kurzer Überlegung finden sich einige Ideen für Laser-Projekte:

• In der obigen Abbildung sehen Sie die Laserharfe des Musikers und "Synthesizer"-Magiers Jean-Michel Jarre, die auf Basis eines Mikrocontrollers entstand.
• Natürlich lassen sich Laser auch für zahlreiche optische Effekte nutzen.
• Einen weiteren Anwendungsfall kennen Sie aus Actionfilmen bzw. -episoden wie beispielsweise James Bond oder Wallace & Gromit (The Wrong Trousers). Dort kommen typischerweise und regelmäßig Laser-basierte "Stolperdrähte" zum Einsatz, um für eine Alarmsicherung von Räumen zu sorgen.
• Infrarot-Laser mit ihren höheren Leistungen ermöglichen die Konstruktion von Graviermaschinen und leider auch von Waffen.
• Mit Linienlasern und einer Webcam sowie Schrittmotoren und einem Mikrocontroller ist die Konstruktion eines 3D-Scanners möglich.
• In Rollenspielen kommen Laser ebenfalls häufig zum Einsatz.

Darf es etwas Physik sein?

Wie ein Laser funktioniert, kennen wir aus dem Physikunterricht. Spannend an Lasern ist, dass sie monochromatisches Licht (d.h., Licht im selben Frequenzbereich) erzeugen, das eine scharfe Bündelung und eine große Kohärenzlänge aufweist. Kohärenz bedeutet, dass die erzeugten Wellen sich in die gleiche Richtung und in derselben Phase bewegen. Laserlicht hat eine Kohärenzlänge von mehreren Kilometern. Die Kohärenzlänge ist übrigens der Weglängen- beziehungsweise Laufzeitunterschied, den zwei Lichtstrahlen aufweisen dürfen, damit sie ein stabiles Interferenzmuster zeigen.

Laser steht für Light Amplification by Stimulated Emission of Radiation, also für Lichtverstärkung mittels stimulierter Strahlungsemission.

Grundvoraussetzung dafür ist die Anregung von Atomen. Wie wir uns eventuell noch erinnern, besitzen Atome Elektronen-Orbits mit unterschiedlichen Energieniveaus. Durch Anregung des Atoms - was letztendlich Zufuhr von Energie bedeutet - können sich Elektronen auf höhere Orbits begeben, also auf Umlaufbahnen mit höherem Energieniveau. Energiezufuhr kommt zum Beispiel zustande, wenn ein Photon auf ein Atom trifft.

Befindet sich eines der Elektronen im Orbit O₁ (Energieniveau E₁) und trifft ein Photon mit Energie E_p auf das betreffende Atom, das auch ein höheres Elektronen-Orbit mit Energieniveau E₂ = E₁ + E_p besitzt, kann das Photon das Atom anregen, wodurch das betreffende Elektron von Orbit O₁ auf Orbit O₂ (und damit von Energieniveau E₁ auf Energieniveau E₂) wechselt.

Ein Atom bleibt ohne äußeren Einfluss nicht im angeregten Zustand, sondern wechselt innerhalb von etwa 10^-8 sec wieder in den energieärmeren beziehungsweise in den Grundzustand zurück, wobei es ein Photon mit der entsprechenden Energiedifferenz E_p emittiert. Dieser zeitlich nicht vorhersehbare Vorgang heißt daher aus gutem Grund spontane Emission.

An dieser Stelle kommt das S(timulated) des Wortes Laser ins Spiel. Befindet sich ein Atom im angeregten Zustand, beispielsweise im Energieniveau E₂, und trifft ein weiteres Photon mit Energie E_p auf das Atom, bevor es zur spontanen Emission kommt, kann das Atom das neue Photon nicht absorbieren, sondern gibt stattdessen ein Photon gleicher Energie E_p ab. Es gibt nun also zwei sich bewegende Photonen, die wiederum auf andere Atome treffen. Das ist die stimulierte Emission. Durch Stimulation des Atoms lässt sich demzufolge eine Kettenreaktion auslösen. Alle freigegebenen Photonen haben dabei die gleiche Energie E_p, die gleiche Schwingungsphase, die gleiche Bewegungsrichtung und die gleiche Polarisation.

Damit die für einen Laser benötigte Verstärkung (Amplification) zustande kommt, benötigen wir die sogenannte Besetzungsinversion. Nur solange die in einer Zeiteinheit absorbierte Menge von Photonen kleiner ist als die Anzahl der stimulierten Emissionen, funktioniert der Laser. Spezielle Lasermedien wie etwa Rubinkristalle oder bestimmte Gasgemische besitzen entsprechende Eigenschaften, die das ermöglichen.

Eine wichtige Komponente des Lasers ist die sogenannte Pumpe, die pulsartig Energie in das Lasermedium pumpt und damit die benötigte Besetzungsinversion erzeugt. Die Pumpe kann zum Beispiel eine Lichtquelle sein, Elektronen emittieren, oder Energie per Wärme zuleiten.

Nachdem wir es jetzt schaffen, dass angeregte Atome Photonen emittieren, die sich durch das Lasermedium bewegen, fehlt nur noch ein wichtiger Baustein, der Resonator.

Der Resonator besteht aus zwei parallelen Spiegeln, von denen der eine alle Photonen reflektiert, während der andere teildurchlässig ist. Photonen bewegen sich aufgrund der Reflexion am Resonator mehrfach durch das Lasermedium, regen dabei viele weitere Atome an, bevor sie den Laser irgendwann durch den teildurchlässigen Spiegel verlassen und einen Laserstrahl bilden.

Spektrum der Laser

Es gibt eine große Vielzahl unterschiedlicher Laser mit unterschiedlichen Pumpen, Lasermedien, Energien und Wellenlängen. Die Wellenlängen reichen vom Röntgenbereich und Ultraviolett, über das sichtbare Licht bis zu Infrarot und Mikrowellen.

Tatsächlich basierte der erste Laser auf Mikrowellen und hieß deshalb Maser.

Für den Maker sind insbesondere die günstig beziehbaren Laserdioden interessant. Sie gibt es schon für nur wenige Euro pro Stück. In dem nachfolgend beschriebenen Projekt kamen beispielsweise Laserdioden für rund 3 Euro zum Einsatz. Ihre Funktionsweise ist wie folgt: Laut Wikipedia wird In Laserdioden "ein p-n-Übergang mit starker Dotierung bei hohen Stromdichten betrieben. Die Wahl des Halbleitermaterials bestimmt dabei die emittierte Wellenlänge, wobei heute ein Spektrum von Infrarot bis Ultraviolett abgedeckt wird".

Neben dem Farbspektrum, ist das Leistungsspektrum von Lasern ebenfalls sehr breit, wie die obige Abbildung zeigt.

• Die stärksten Laser kommen auf Leistungen von einigen Hundert Watt.
• Für Lasergravur im Heimbereich existieren zum Beispiel Infrarot-Laser mit Leistungen von 200 bis 500 mW und mehr.
• Einfache Laserpointer haben unter 3 bis 5 mW.

Das aber nur als Beispiele.

Beispiel Tripwire

Um eine praktische Anwendung eines Lasers kennenzulernen, dient ein Tripwire-Experiment (Laserschranken). In einem Raum treffen Laserstrahlen, die eventuell zuvor in ihrer Richtung durch Spiegel umgelenkt oder durch teildurchlässige Spiegel in mehrere Strahlen aufgespalten wurden, auf lichtempfindliche Widerstände. Unterbricht ein Gegenstand, ein Tier oder eine Person den Strahlengang, hat das einen veränderten Widerstand zur Folge, was einen Alarm auslöst.

Hierfür genügen relativ schwache Laser, sodass sich der Aufwand in engen Grenzen hält, auch was die Kosten betrifft.

Schaltung

In der vorliegenden Schaltung zur Demonstration eines Laser-Tripwire ist der Laser an einer separaten Spannungsquelle angeschlossen. Natürlich können Sie den Laser auch direkt mit dem Arduino verbinden. Egal, welches Vorgehen Sie wählen, sind Laser und Schaltung zumindest logisch voneinander unabhängig. Haben Sie momentan keinen Laser zur Hand, kann es gerne auch ein Laserpointer sein.

An dieser Stelle möchte ich noch einen Warnhinweis voranschicken. Laser sind grundsätzlich Geräte, die nicht in die Hände von Kindern gehören.

Aber auch Erwachsene unterschätzen Laser gerne. Sie selbst sollten folglich bei stärkeren Lasern mit entsprechenden Schutzbrillen arbeiten und unter keinen Umständen in den Strahl blicken oder hineingreifen. Doch Vorsicht! Es gibt für jeden Bereich von Wellenlängen eigene Schutzbrillen, keine Laser-Schutzbrille für alle Fälle bzw. für alle Wellenlängen.

Doch kommen wir nun zur eigentlichen Schaltung:

• Den Photowiderstand schließen wir an den analogen Port A0 an.
• Zugleich wird er mit der Stromversorgung des Arduino verbunden, also mit dessen 5-V- und GND-Ausgängen.
• Des Weiteren ist ein Widerstand mit 10 kΩ zwischen GND und Photowiderstand platziert.
• Den Buzzer bzw. Lautsprecher verbinden wir mit GND des Arduino und dem digitalen Ausgang 8 (PWM-Unterstützung beim Arduino Uno oder Mega). Wenn sie einen anderen Port verwenden wollen, müssen Sie nur darauf achten, dass dieser Port PWM unterstützt.

Um nicht nur einen geraden Strahl zu haben, könnten Sie ganz- oder teildurchlässige Laserspiegel verwenden. Da die nicht immer ganz günstig sind, verwende ich Zubehörteile für das Spiel Laser-Strategie-Khet 2.0. Dieses Spiel ist günstiger zu beschaffen als so mancher Laserspiegel.

Sketch

Im abgedruckten Listing überschreitet der an A0 ausgelesene Wert normalerweise einen Schwellwert. Zumindest gilt dies, solange der Laserstrahl direkt auf den Fotowiderstand treffen kann. Bei einer Unterbrechung des Strahls misst der Sketch allerdings am Fotowiderstand einen Wert unterhalb des Schwellwerts. In Reaktion darauf läuft die Polizeisirene los.

Dafür ist allerdings erst der besagte Schwellwert einzustellen. Zu diesem Zweck gibt das Programm laufend die gemessenen Helligkeitswerte am seriellen Monitor aus. Die Entwicklerin lässt den Sketch einfach laufen, ohne dass der Laserstrahl den Fotowiderstand trifft und beobachtet die gemeldeten Werte. Anschließend richtet sie den Laser direkt auf den Fotowiderstand und analysiert wieder die beobachteten Werte. Der Schwellwert sollte irgendwo in der Mitte zwischen der niedrigsten Helligkeit bei direktem Laserlicht und der höchsten Helligkeit ganz ohne Laserlicht liegen. Natürlich ließe sich zum Sketch eine automatische Kalibrierung ergänzen, die anfangs genau dieses Vorgehen gesteuert durchführt.

Eine weitere Möglichkeit zur automatischen Kalibrierung ist die Nutzung von zwei Fotowiderständen, von denen nur einer vom Laserstrahl getroffen wird, der andere aber nicht. Ein Sketch liest beide Werte und legt den Schwellwert auf die Mitte zwischen beiden. Dieser Vergleich kann bei einer anfänglichen Kalibrierung ablaufen, oder aber ständig im Betrieb. Letzteres hilft auch dabei, mit Helligkeitsschwankungen umzugehen.

Ratsam ist ebenfalls der Einbau eines Schalters, um die Alarmsicherung scharf zu schalten oder zu deaktivieren. Dann müssen Sie nicht immer gleich den Stecker ziehen.

/////////////////////////////////////////////////////
//
// Laser Tripwire
//
// Laserstrahl wird auf lichtempfindlichen 
// Photowiderstand positioniert.
// Sobald der Strahlengang unterbrochen wird,
// spielt der Sketch eine akustisches Signal ab
//
//////////////////////////////////////////////////////

const int BuzzerPin       =  8; // Buzzer an Digita 8 (PWM)
const int PhotoResistorPin= A0; // Fotowiderstand an A0

const int DeltaT = 1;           // Zeit zwischen Tönen
const int PlayLength = 10;      // Spiellänge jedes Tons

// Wird der Treshold-Wert unterschritten gibt es einen Alarm:
const int TresholdValue = 800;  

/////////////////////////////////////////////////////
//
// setup()
//    setzt  den Lautsprecher als Ausgang
//    startet die serielle Übertragung
//
//////////////////////////////////////////////////////
void setup() {
  pinMode(BuzzerPin, OUTPUT);
  Serial.begin(9600);
}

/////////////////////////////////////////////////////
//
// playDopplerSirene()
//    simuliert eine Sirene der US-Polizei
//    und wiederholt das <howOften> Mal
// Verwendung der Arduino tone-Funktionen
//
//////////////////////////////////////////////////////
void playDopplerSirene(unsigned int howOften) {
  int frequency = 0;
  int repetitions = 0;
  
  tone(BuzzerPin, 440);

  for (repetitions = 0; repetitions < howOften; repetitions++) {
    // Ton immer höher:
    for (frequency = 150; frequency < 1800; frequency += 1) {
      tone(BuzzerPin, frequency, PlayLength);     
      delay(DeltaT);
    }
    // Ton immer tiefer:
    for (frequency = 1800; frequency > 150; frequency -= 1) {
      tone(BuzzerPin, frequency, PlayLength); 
      delay(DeltaT);    
    }
  }
}

/////////////////////////////////////////////////////
//
// checkAlarm()
//    liest die Lichtintensität vom Fotowiderstand
//    und liefert zurück, ob der Schwellwert 
//    unterschritten wurde
//
//////////////////////////////////////////////////////
bool checkAlarm() {
  int val = analogRead(PhotoResistorPin);
  Serial.println(val);
  return (val < TresholdValue); 
}

/////////////////////////////////////////////////////
//
// loop()
//    prüft mit checklarm() ob es eine Alarmsituation 
//    gibt.
//    Wenn ja, spielt es einmal die Polizeisirene ab. 
//
//////////////////////////////////////////////////////
void loop() {
  if (checkAlarm()) {
    playDopplerSirene(1);  // einmal abspielen                
    delay(200);            // have a break
  }
}

Das Ganze auf den Kopf gestellt

Wenn wir im Sketch, genauer gesagt in der Methode checkAlarm(), die Bedingung

         (val < TresholdValue)

durch

         (val > TresholdValue)

ersetzen,

dann können wir den Alarm stattdessen dann aktivieren, sobald der Schwellwert überschritten wird.

Wozu das gut ist? Damit können Sie zum Beispiel mittels Wearables Rollenspiele umsetzen. In der Kleidung des Spielers sind an neuralgischen Stellen Fotowiderstände angebracht, die wiederum an das Wearable angeschlossen sind. Trifft nun beim Spiel eine Laserwaffe einen der Fotowiderstände, löst das Wearable einen Alarm aus. Der Spieler ist dann aus dem Spiel. Als Schaltung verwenden wir die weiter oben abgebildete Schaltung. Diesmal muss der Laser natürlich separiert von der restlichen Schaltung sein.

Laserharfe

Durch Modifikation der obigen Grundschaltung können wir ebenfalls eine gerahmte Laserharfe konstruieren. Gerahmt deshalb, weil hier mehrere Laser und Fotowiderstände in einen Rahmen eingebaut werden, wobei jeder Laser auf den ihm zugehörigen Fotowiderstand ausgerichtet ist. Sobald der Musiker in die Harfe greift, unterbricht er dadurch einen oder mehrere Strahlen. Die Schaltung erkennt dies und lässt je nach unterbrochenem Laserstrahl andere Töne erklingen.

Eine sehr einfach gestrickte Schaltung könnte folgendermaßen aufgebaut sein:

Aus Faulheit habe ich hier nur fünf Fotowiderstand-Laser-Paare eingezeichnet. Damit ist aber zumindest das Abspielen einer pentatonischen Tonleiter möglich, etwa die verbreitete A-Moll-Pentatonik mit a, C, D, E, G.

Wer auf eBay nach "Laser Harp" und "Arduino" sucht, stößt auf entsprechende Bausätze für um die 70 Euro. Das ist deutlich teurer als der Eigenbau, auch wenn dort meistens acht Laser und weitere Bauteile im Einsatz sind. Trotzdem ist es interessant, sich die bereitgestellten Bausätze zu Gemüte zu führen. Selbst bauen ist allerdings hier nicht nur billiger, sondern macht auch deutlich mehr Spaß.

Der gute Ton

Bleibt noch, das Thema Tonsynthese auf dem Arduino zu klären. Wie also erzeugen wir Noten auf einem Lautsprecher oder Buzzer?

Auf den arduino.cc-Webseiten gibt es eine Anleitung zum Abspielen von Melodien. Die Synthese von Tönen erfolgt mittels Pulsweitenmodulation (PWM), durch deren Hilfe sich die für bestimmte Noten erforderlichen Vibrationsfrequenzen erzeugen lassen. Der Lautsprecher wird immer für eine bestimmte Zahl von Millisekunden auf HIGH, dann wieder auf LOW gelegt. Dadurch erhalten wir ein Rechtecks-Signal mit der erforderlichen Frequenz.

Im Sketch werden zunächst für die Notenwerte folgende Konstanten definiert. Die Note a hat zum Beispiel eine Frequenz von 440 Hz.

Note Frequenz Periode Pulsweite(timeHigh)
c 261 Hz 3830 1915
d 294 Hz 3400 1700
e 329 Hz 3038 1519
f 349 Hz 2864 1432
g 392 Hz 2550 1275
a 440 Hz 2272 1136
b 493 Hz 2028 1014
C 523 Hz 1912 956

Der Sketch errechnet die Pulsweite (Länge des HIGH-Signals am Lautsprecher) aus

timeHigh = 1/(2 * toneFrequency) = period / 2

Nehmen wir Kammerton a mit 440 Hz, so ergibt sich (siehe Tabelle und Feld tones[]) als Pulsweite 1136. Daher wird der Lautsprecher jeweils für 1136 Mikrosekunden auf HIGH und für 1136 Millisekunden auf LOW geschaltet. Dadurch ergibt sich als Frequenz

    1000000 Mikrosekunden / 2272 Mikrosekunden = 440,140.... Hz

Wir kommen also auf die 440 Hz der Note a.

Quod erat demonstrandum!

Beispiel-Sketch zum Abspielen einer Melodie

Der Sketch auf der genannten Webseite (Copyleft D. Cuartielles, 2005) führt zusätzlich zu den Noten (Buchstaben 'c', 'd', 'e', 'f', 'g', 'a', 'b' ,'C') auch Pausen ein ('p'). Um den Rhythmus festzulegen, wird vor jeder Note der Melodie deren Dauer in Beats festgelegt. 2 Beats lang Note d, ein Beat Pause, und dann 1 Beat lang C wird im Feld melody[] zur Zeichenkette "2d1p1C".

int ledPin     = 13; // dient zur Anzeige des Status
int speakerOut =  9; // hier ist der Lautsprecher angeschlossen              
byte names[] = {'c', 'd', 'e', 'f', 'g', 'a', 'b', 'C'};  

// Pulsweiten für die Tonerzeugung:
 int tones[] = {1915, 1700, 1519, 1432, 1275, 1136, 1014, 956};

// Melodie mit Beats und Note beziehungsweise Pause:
byte melody[] = "2d2a1f2c2d2a2d2c2f2d2a2c2d2a1f2c2d2a2a2g2p8p8p8p";
// ...
int count    = 0;  // zählt bis zur Maximallänge der Melodie
int count2   = 0;  // iteriert zur richtigen Note
int count3   = 0;  // zählt die Beats per Note/Pause
int MAX_COUNT = 24;// Maximallänge der Melodie
int statePin = LOW;// Zustand zur Ausgabe am LED

void setup() {
 pinMode(ledPin, OUTPUT); 
}

void loop() {
  analogWrite(speakerOut, 0);   // erst einmal ausschalten  

  // durch alle Teile der Melodie iterieren:
  for (count = 0; count < MAX_COUNT; count++) { 
    statePin = !statePin;
    digitalWrite(ledPin, statePin);

    // durch alle Beats der Note/Pause zählen:
    for (count3 = 0; count3 <= (melody[count*2] - 48) * 30; count3++) {

      // Pulsweite für die Note in der Melodie suchen:
      for (count2=0;count2<8;count2++) {
        if (names[count2] == melody[count*2 + 1]) { // Note gefunden  
          analogWrite(speakerOut,500);      // Signal an 
                                            // Lautsprecher ausgeben

          delayMicroseconds(tones[count2]); // Warten
          analogWrite(speakerOut, 0);       // Kein Signal
          delayMicroseconds(tones[count2]); // Warten
        } 
        if (melody[count*2 + 1] == 'p') {   // im Falle einer Pause
          // make a pause of a certain size
          analogWrite(speakerOut, 0);       // Stille am Lautsprecher
          delayMicroseconds(500);
        }
      }
    }
  }
}

Aus diesem Sketch können Sie problemlos selbst extrahieren, wie sich beim Blockieren eines Laserstrahls in der gerahmten Laserharfe die entsprechenden Noten erzeugen lassen. Das Variieren der Oktaven lässt sich übrigens durch folgende Formeln bewerkstelligen. Wollen Sie von einer Note auf die eine Oktave höher liegende Note, verdoppelt sich die Frequenz. Hat beispielsweise das normale a eine Frequenz von 440 Hz, so besitzt das A auf der nächsthöheren Oktave eine Frequenz von 2 x 440 Hz = 880 Hz. Im Umkehrschluss besitzt das um eine Oktave tiefere a' die halbe Frequenz, also 440 / 2 = 220 Hz.

Frameless Laserharps

Zurück zu unserer Schaltung. Gerahmte Laserharfen haben diverse Nachteile. Sie benötigen einen Rahmen, was die Größe beschränkt, und mehrere Laser, was den Aufand erhöht.

Die Laserharfe von Jean-Michel Jarre (siehe Bild ganz oben) ist eindeutig nicht gerahmt.

Neben den gerahmten Laserharfen gibt es die rahmenlosen Laserharfen, die nur einen einzigen, dafür aber leistungsfähigen Laser und eine komplexere Konstruktion benötigen. Die wichtigsten Ingredienzen dabei sind:

• ein grüner Laser mit 50 mW Leistung,
• ein Schrittmotor,
• ein vollreflektierender Laserspiegel,
• ein Arduino,
• eine Schutzbrille,
• eine Soundschaltung mit MIDI-Ausgang,
• einen Annäherungssensor,
• ein Fotowiderstand.

Hier fällt der Laserstrahl auf einen Spiegel, der aber durch einen Schrittmotor ständig auf n vorgegebene Positionen gedreht wird. Für jede Position wird der Laserstrahl daher in eine andere Richtung umgelenkt. Da die Motorbewegung sehr schnell verläuft, hat der menschliche Beobachter den Eindruck, es handelt sich um eine Laserharfe mit n Strahlen bzw. Saiten. Dieses Phänomen ist auch unter der Bezeichnung POV (Persistence of Vision) bekannt und basiert auf dem begrenzten zeitlichen Auflösungsvermögen der visuellen Wahrnehmung. Ohne POV würden auch Filme nicht funktionieren.

Wenn der Musiker in den Laserstrahl greift, erfährt die Elektronik das dadurch, dass die Hand den Strahl reflektiert, was wiederum ein Fotowiderstand erfasst. Aufgrund der Position des Motors lässt sich abschließend feststellen, welche Saite der Musiker "angeschlagen" hat.

Rahmenlose Laserharfen merken übrigens nicht nur, welche Saiten der Musiker anschlägt, sondern auch auf welcher Höhe. Das geschieht zum Beispiel mit einem Infrarot-Näherungssensor, der orthogonal zum Spiegel angebracht ist.

Eine Frage blieb bisher unbeantwortet. Wie sorgen Maker eigentlich dafür, dass die Laserstrahlen überhaupt sichtbar sind? Dafür gibt es zum Beispiel schon für wenig Geld Nebelmaschinen.

Mit dem Thema rahmenloser Laserharfen beschäftigt sich der Blog in einer zukünftigen Folge, wenn er das Thema Audio-Schaltungen auf Basis des Arduino adressiert.

Lasers rock

Wie wir gesehen haben, lässt sich mit Lasern einiges anstellen. Vielleicht haben Sie Lust, die Beispiele dieser Folge zu ergänzen und zusätzliche Experimente durchzuführen.

Ein weiterer Tipp: Stöbern Sie ruhig mal auf Seiten wie www.instructables.com/howto/laser nach Ideen. Es ist faszinierend, mit welcher Kreativität die Community auch in Sachen Lasertechnik aufwartet. Wie wäre es zum Beispiel mit einem Arduino-basierten Laserschwert?

Oder haben Sie vielleicht eine völlig neue Anwendungsidee?

In jedem Fall wünsche ich Ihnen viel Spaß beim Experimentieren!

Mehr Infos

Was bisher geschah:

• Neues aus der Kreativitätsabteilung
  
• Remote Control
• Von Erleuchtungen und Lichterketten
• Logic Analyzer
• Make your own ESP8266 WiFi Shield
  
• Timer, Counter und Interrupts
• Arduino goes ESP8266
• Bright Side of Arduino
• Genuino bzw. Arduino unplugged
• Arduino-/IoT-Extra – Bibliotheken selbst implementieren
• Kleiner, tiefer, kürzer ... Entwicklung einer Wetterstation
• RESTful mit CoAP
  
• Kommunikation über MQTT
• Nach Hause telefonieren ... mit dem Arduino
  
• Schritt für Schritt
• Anwendungen mit Servo-Motoren
• Gut motorisiert mit Gleichstrommotoren
  
• Arduino für Fledermäuse
• Bewegungserkennung durch Infrarot-Strahlung
  
• Anschluss von LCD-Displays über den IIC-Bus
  
• Lauschen mit Sensoren
  
• JavaScript an Arduino: Es werde Licht
  
• Anschluss vieler LEDs an wenige Ausgänge
  
• Do-it-Yourself-Projekt: iXduino – Arduino on a Breadboard
• Crashkurs "Elektronik für IoT-Anwendungen" (Teil 3 von 3)
• Crashkurs "Elektronik für IoT-Anwendungen" (Teil 2 von 3)
• Crashkurs "Elektronik für IoT-Anwendungen" (Teil 1 von 3)

()