ard-set01 - Nicht kategorisiert Joy-It - Kostenlose Bedienungsanleitung

Produkttyp	Arduino-kompatibles Mikrocontroller-Set (ard-set01)
Mikrocontroller	ATmega2560
Abmessungen	101,52 mm x 53,3 mm
Betriebsspannung	7–12 V (max. 6–20 V)
Digitale I/O-Pins	54 (14 mit PWM)
Analoge I/O-Pins	16
Speicher	256 kB Flash (8 kB Bootloader), 8 kB SRAM, 4 kB EEPROM
Taktfrequenz	16 MHz
DC-Strom pro I/O-Pin	40 mA
DC-Strom 3,3 V	50 mA
Lieferumfang	Board, USB-Kabel, Breadboard, LEDs, Widerstände, Summer, Potentiometer, Sensoren (Flammen-, Temperatur-, Fotowiderstand), Infrarot-Fernbedienung, Matrix-Module, Taster, Kabel u.v.m.
Software	Arduino IDE (kostenlos, kompatibel)
Besonderheiten	Kompatibel mit Arduino Mega 2560, 20 Projektbeispiele in der Anleitung, EU-Konformitätserklärung
Pflege und Reinigung	Vor Feuchtigkeit und Staub schützen. Zur Reinigung trockenes Tuch verwenden.
Sicherheitshinweise	Nur im angegebenen Spannungsbereich betreiben. Keine Kurzschlüsse verursachen. Nicht in der Nähe von Wasser verwenden.
Reparierbarkeit / Ersatzteile	Standard-Arduino-Komponenten, Ersatzteile im Handel erhältlich. Reparatur durch Fachpersonal empfohlen.

Häufig gestellte Fragen - ard-set01 Joy-It

Ist das Joy-It ard-set01 kompatibel mit der offiziellen Arduino-IDE?

Ja, das Set ist voll kompatibel mit der Arduino IDE. Wählen Sie unter Werkzeuge -> Board den Punkt 'Arduino/Genuino Mega or Mega 2560' aus.

Welche Spannungsversorgung wird für das Board benötigt?

Das Board benötigt eine Eingangsspannung von 7–12 V (maximal 6–20 V). Es kann über den USB-Anschluss (5 V) oder eine externe Stromversorgung (z.B. 9V-Netzteil) betrieben werden.

Sind Treiber für Windows/Mac/Linux erforderlich?

Die Arduino IDE installiert automatisch die benötigten Treiber. Bei Problemen können die Treiber manuell von der Arduino-Website heruntergeladen werden.

Welche Komponenten sind im Lieferumfang enthalten?

Das Set enthält das Mikrocontroller-Board, USB-Kabel, Breadboard, diverse LEDs, Widerstände, Summer, Potentiometer, Sensoren (Flammen-, Temperatur-, Lichtsensor), Infrarot-Fernbedienung, 8x8 LED-Matrix, 7-Segment-Anzeigen, Taster und viele Jumper-Kabel.

Kann ich mit diesem Set auch eigene Projekte umsetzen?

Ja, das Set ist für Anfänger und Fortgeschrittene geeignet. Die Anleitung enthält 20 Projekte als Einstieg, aber das Board kann frei programmiert werden.

Wie schließe ich einen passiven Summer an?

Ein passiver Summer benötigt ein PWM-Signal zur Tonerzeugung. Verbinden Sie ihn mit einem digitalen PWM-Pin (z.B. Pin 8) und GND. Im Code verwenden Sie digitalWrite() mit Verzögerungen oder tone().

Was ist der Unterschied zwischen aktiven und passiven Summern?

Ein aktiver Summer erzeugt selbstständig einen Ton bei Anlegen von Spannung. Ein passiver Summer benötigt ein pulsierendes Signal (PWM) zur Tonerzeugung und kann verschiedene Frequenzen abspielen.

Wie kann ich die Helligkeit einer LED über einen Potentiometer steuern?

Verbinden Sie das Potentiometer mit einem analogen Eingang (z.B. A0) und eine LED mit einem PWM-Pin (z.B. 11). Lesen Sie den Analogwert mit analogRead() und geben Sie ihn skaliert mit analogWrite() an den LED-Pin aus.

Funktioniert der IR-Empfänger mit jeder Fernbedienung?

Der IR-Empfänger ist für das NEC-Protokoll ausgelegt, wie es viele Fernbedienungen verwenden. Für andere Protokolle muss der Code angepasst werden. Die Bibliothek IRremote unterstützt mehrere Formate.

Wo finde ich die neueste Bedienungsanleitung und Software?

Die Bedienungsanleitung liegt als PDF bei oder kann auf der Webseite notice-facile.com heruntergeladen werden. Die Arduino IDE erhalten Sie kostenlos auf arduino.cc.

BEDIENUNGSANLEITUNG ard-set01 Joy-It

1 Allgemeine Informationen & Technische Daten

2 Anschlussbelegung

3 Software Installation

3.1 Software Einrichtung

4 EU-Konformitätserklärung

5 Projektbeispiele

5.1 Projekt 1: Hallo Welt

5.2 Projekt 2: Blinkende LED

5.3 Projekt 3: PWM Lichtkontrolle

5.4 Projekt 4: Ampellichter

5.5 Projekt 5: LED Jagt-Effekt

5.6 Projekt 6: Tastengesteuerte LED

5.7 Projekt 7: Responder Experiment

5.8 Projekt 8: Aktiver Summer

5.9 Projekt 9: Passiver Summer

5.10 Projekt 10: Analogwert Auslesen

5.11 Projekt 11: Fotowiderstand

5.12 Projekt 12: Flammensensor

5.13 Projekt 13: Lageschalter

5.14 Projekt 14: 1-Ziffer LED Segment Anzeige

5.15 Projekt 15: 4 Ziffer LED Segment Anzeige

5.16 Projekt 16: LM35 Temperatursensor

5.17 Projekt 17: 74HC595

5.18 Projekt 18: RGB LED

5.19 Projekt 19: Infrarot Fernbedienung

5.20 Projekt 20: 8x8 LED Matrix

Sehr geehrter Kunde,

vielen Dank, dass Sie sich für unser Produkt entschieden haben.

Im Folgenden haben wir aufgelistet, was bei der Inbetriebnahme zu beachten ist:

1. Allgemeine Informationen & Technische Daten

Unser Board ist ein hochwertiger Nachbau und kompatibel mit dem Arduino Mega 2560, es handelt sich aber ausdrücklich nicht um einen Original Arduino.

Das Mega Board ist das richtige Mikrocontroller -board für die, die schnell und unkompliziert in die Programmierwelt einsteigen wollen.

Dieses Set führt Sie durch eine Vielzahl von Projekten.

Sein ATMega2560-Mikrocontroller bietet Ihnen genügend Leistung für Ihre Ideen und Projekte. Er ist 101.52 mm x 53.3 mm groß und hat mit 54 digitalen Ein- und Ausgängen und 16 analogen Eingängen viele Verbindungsmöglichkeiten.

Model ARD_Mega2560R3
Mikrocontroller ATmega2560
Eingangs-Spannung	7-12V
Eingangs-Spannung (max.)	6-20V
Digital IO 54 (14 mit PWM)
Analog IO 16
DC Strom IO 40mA
DC Strom 3.3V 50mA
Speicher	256kB (8kB für Bootloader)
SRAM 8kB
EEPROM	4kB
Clock Speed	16 MHz
Abmessungen	101.52mm x 53.3mm

2. Anschlussbelegung

3. Software Installation

Damit mit man mit der Programmierung des JOY-iT ARD_Mega2560R3 beginnen kann, muss vorab auf dem Computer, der für das Programmieren verwendet wird, eine Entwicklungsumgebung, sowie die Treiber für das zugehörige Betriebssystem, installiert werden.

Als Entwicklungsumgebung bietet sich die Arduino IDE an, die von dem Arduino Hersteller als OpenSource Software unter der GPLv2 veröffentlicht wurde, die sich vom Konzept und Aufbau an Einsteiger richtet.

Diese ist vollständig kompatibel zum JOY-iT ARD_Mega2560R3 und beinhaltet neben der Programmierumgebung auch die benötigten Treiber, um direkt loslegen zu können.

Den Download der Software finden Sie hier.

3.1 Software Einrichtung

Nach der Installation der Software, muss das entsprechende Microcontroller-Board in der Programmierumgebung eingerichtet werden. Hierzu befolgen Sie die folgenden zwei Schritte:

1. Unter [Werkzeuge->Board] muss „Arduino/Genuino Mega or Mega 2560“ ausgewählt werden

1. Unter [Werkzeuge -> Port] wählen Sie dann den Port aus, der mit „(Arduino/Genuino Mega or Mega 2560)“ gekennzeichnet ist.

4 EU-Konformitätserklärung

Hersteller: JOY-iT Europe GmbH

Pascalstr. 8

47506 Neukirchen-Vluyn

Artikelbezeichnung: ard_mega2560R3 /ARD-Set01

Beschreibung: Microcontroller-Board / Set

Verwendungszweck: Versuchsaufbauten / Prototypen

Hiermit erklärt der Hersteller, die JOY-IT Europe GmbH, Pascalstr. 8, D-47506 Neukirchen-Vluyn, dass das Produkt „ard_Mega2560IP“ bei bestimmungsgemäßer Verwendung die Grundlegenden Anforderungen der folgenden Richtlinien erfüllt:

2014/ 30/EU (EMV) & 2011/65/EU (Rohs)

Die nachfolgend aufgeführten Normen wurden zur Beurteilung des Gerätes angewandt:

EN 61326-1: 2013

elektrische Ausrüstung für Mess-, Regel und Laborgeräte - EMV Anforderungen Teil 1 allgemeine Anforderungen

Datum

03.03.2017

Name

Yue Yang

Unterschrift

Stellung im Betrieb

Geschäftsführerin

5 Projektbeispiele

5.1 Projekt 1: „Hallo Welt“

Wir beginnen mit etwas simplen.

Für dieses Projekt benötigt man nur die Platine und ein USB Kabel, um das „Hallo Welt!“ Experiment zu starten.

Dies ist ein Kommunikationstest für deinen Mega2560 und deinen PC, sowie ein grundlegendes Projekt für

deinen ersten Versuch in der Arduino Welt!

Hardware Menge
Mega2560 Platine 1
USB Kabel 1
LED 1

Nachdem die Installation der Treiber abgeschlossen ist, lass uns die Arduino Software öffnen und einen Code verfassen, welcher es dem Mega2560 ermöglicht „Hallo Welt!“ unter deiner Anweisung anzuzeigen. Natürlich kannst du auch einen Code verfassen, welcher den Mega2560 ohne Anweisung wiederholt „Hallo Welt!“ wiedergeben lässt. Ein simpler if () Befehl wird dies übernehmen.

Wir können die LED an Pin 13 anweisen, erst zu blinken und anschließend „Hallo Welt!“ anzuzeigen, nachdem der Arduino den Befehl dazu bekommt.

int val;    // Definiert die variable "Val"
int ledpin=13;    // Definiert digitales Interface 13
void setup()
{
    Serial.begin(9600);    // Setzt die Baudrate auf 9600 um
    //der Konfiguration der Software zu
    //entsprechen. Wenn es mit einem
    //bestimmten Gerät verbunden ist,
    //muss die Baudrate übereinstimmen.

    pinMode(ledpin,OUTPUT);    // Bestimmt den Digital Pin 13 als
    //Ausgang. Wenn I/O Ports an
    // einem Arduino verwendet werden,
    //wird diese Konfiguration immer
    //benötigt.
}

void loop()
{
    val=Serial.read();    // Liest die Anleitung oder Char-Symbole
    //vom PC zum Arduino und ordne sie "Val"
    //zu.
    if(val=='R')    // Bestimmt ob die Anweisung oder
    //der erhaltene Buchstabe „R" ist.
    {    // Falls es „R" ist,
    digitalWrite(ledpin,HIGH);    // Schaltet die LED am Digital Pin 13
    //ein.
    delay(500);
    digitalWrite(ledpin,LOW);    // Schaltet die LED am Digital Pin 13
    // aus.
    delay(500);
    Serial.println("Hello World!"); // Zeigt „Hallo Welt!" an. 

Klick auf den seriellen Port Monitor, füge „R“ ein, LED wird einmal aufleuchten, PC wird die Information „Hallo Welt“ vom Arduino erhalten.

5.2 Projekt 2: Blinkende LED

Das blinkende LED Experiment ist ziemlich einfach.

In dem „Hallo Welt!“ Programm sind wir der LED bereits begegnet. Diesmal werden wir eine LED mit einem der digitalen Pins verbinden. Zusätzlich zum Arduino und einem USB Kabel werden die folgenden Teile benötigt:

Hardware Menge
Mega2560 Platine 1
USB Kabel 1
Rote M5 LED 1
220Ω Widerstand	1
Breadboard 1
Breadboard Überbrückungskabel 2

Wir folgen dem unten angezeigten Diagramm des verlinkten Experimentschaltplans. Hier benutzen wir Digital Pin 10. Wir verbinden die LED an einen 220 Ohm Widerstand um Beschädigungen durch zu hohe Ströme zu vermeiden.

int ledPin = 10;    // Definiert Digital Pin 10.

void setup()
{
    pinMode(ledPin, OUTPUT);    // Definiert Pin mit verbundener LED
    als Ausgang.
}

void loop()
{
    digitalWrite(ledPin, HIGH);    // Schaltet die LED ein.
    delay(1000);    // Wartet eine Sekunde.
    digitalWrite(ledPin, LOW);    // Schaltet die LED aus.
    delay(1000);    // Wartet eine Sekunde
} 

Nach dem Runterladen dieses Programms, wirst du im Experiment die an Pin 10 verbundene LED sich, mit einem Intervall von ca. einer Sekunde, Ein- und Ausschalten sehen.

5.3 Projekt 3: PWM Lichtkontrolle

PWM, kurz für Pulse Width Modulation, ist eine Technik, welche benutzt wird um analoge Signalpegel in digitale zu kodieren.

Ein Computer kann keine Analogspannung ausgeben.

Er kann nur Digitalspannung ausgeben mit Werten wie 0V oder 5V.

Also wird ein hochauflösenden Zähler benutzt, um einen

spezifischen analogen Signalpegel zu kodieren, indem man den Auslastungsgrad von PWM moduliert.

Das PWM Signal ist auch digitalisiert, weil zu jedem Zeitpunkt, vollständig auf Gleichstrom die Energieversorgung entweder 5V (AN) oder 0V (AUS) ist.

Die Spannung oder der Strom wird der Analogen Last (das Gerät, dass die Energie verbraucht) durch wiederholte Impulsfolgen zugeführt bei denen immer ein und ausgeschaltet wird.

Solange eingeschaltet wird der Strom der last zugeführt wenn es ausgeschaltet ist nicht.

Mit einer angemessenen Bandbreite kann jeder analoge Wert per PWM entschlüsselt werden.

Der Wert der Ausgangsspannung wird anhand der AN und AUS zustände kalkuliert.

Spannung= (AN-Zeit/Impulszeit)*maximaler Spannungswert.

PWM hat viele Anwendungen: Regulierung der Lampenhelligkeit, Regulierung der Motorgeschwindigkeit etc.

Nachfolgend sind die drei Grundparameter von PWM:

1. Die Amplitude der Impulsbreite (Minimum/Maximum)
2. Die Pulsperiode (Die gegenseitige Pulsfrequenz in einer Sekunde)
3. Der Spannungspegel (wie: 0V-5V)

Es gibt 6 PWM Schnittstellen auf dem Mega2560: digitaler Pin 3, 5, 6, 9, 10 und 11.

In vorherigen Experimenten haben wir die „tastenkontrollierte LED“ gemacht, wo wir ein digitales Signal verwendet haben und einen digitalen Pin zu kontrollieren.

Diesmal werden wir ein Potentiometer benutzen um die Helligkeit der LED zu kontrollieren.

Hardware Menge
Mega2560 Platine 1
USB Kabel 1
Rote M5 LED 1
Variabler Widerstand 1
220Ω Widerstand	1
Breadboard 1
Breadboard Überbrückungskabel 6

Der Eingang des Potentiometers ist analog, also verbinden wir ihn mit dem analogen Port. Die LED verbinden wir mit dem PWM Port.

Ein anderes PWM Signal kann die Helligkeit der LED regulieren.

In dem Erstellungsprozess für das Programm werden wir die analoge Schreibfunktion nutzen (PWM Schnittstelle, Analogwert). In diesem Experiment werden wir den Analogwert des Potentiometers lesen und den Wert dem PWM Port zuordnen, sodass eine entsprechende Änderung der Helligkeit der LED beobachtet werden kann. Ein letztes Teil wird den Analogwert auf dem Bildschirm anzeigen. Du kannst dies als das „Analogwert auslesen“ Projekt ansehen welchem einen Analogen PWM wert zugeordnet wird. Nachfolgend findest du ein Beispielprogramm.

int potpin=0;    // Initialisiert analogen Pin 0
int ledpin=11;    // Initialisiert den digitalen Pin 11 (PWM Ausgang)
int val=0;    // Speichert den Wert der Variable vom Sensor
    // temporär
void setup()
{
    pinMode(ledpin,OUTPUT);    // Definiert digitalen Pin 11 als „Ausgang“
    Serial.begin(9600);    // Setzt Baudrate auf 9600

    // Achtung: Für analoge Ports sind sie automatisch als
    // „Eingang“ eingestellt
}

void loop()
{
    val=analogRead(potpin);    // Liest den Analogwert vom Sensor und weist diesen
    // „Val“ zu
    Serial.println(val);    // Zeigt den Wert von „Val“
    analogWrite(ledpin,val/4);    // Schaltet die LED ein und stellt die Helligkeit ein
    // (Maximaler Ausgang von PWM ist 255)
    delay(10);    // Wartet 0,01 Sekunden
} 

Nach der Übertragung des Programms und bei Bewegung des Potentiometers, können wir Veränderungen bei den angezeigten Werten beobachten.

Außerdem können wir eine offensichtliche Änderung der LED Helligkeit auf dem Breadboard erkennen.

5.4. Projekt 4: Ampellichter

Im vorherigen Programm haben wir das blinkende LED Experiment mit einer LED durchgeführt.

Jetzt wird es Zeit ein etwas komplizierteres Experiment durchzuführen: Ampellichter.

Eigentlich sind diese zwei Experimente ähnlich.

Während dieses Experiments werden wir 3 LEDs mit verschiedenen Farben nutzen, während im letzten nur eine LED zum Einsatz kam.

Hardware Menge
Mega2560 Platine 1
USB Kabel 1
Rote M5 LED 1
Gelbe M5 LED 1
Grüne M5 LED 1
220Ω Widerstand	3
Breadboard 1
Breadboard Überbrückungskabel 4

Da dies eine Simulation von Ampellichtern ist, sollte auch die Leuchtzeit jeder einzelnen LED genau so lange, wie bei echten Ampellichtern sein.

In diesem Programm werden wir die Arduino Verzögerungsfunktion nutzen, um die Verzögerungszeit zu kontrollieren.

int redled =10;    // Initialisiert digitalen Pin 8
int yellowled =7;    // Initialisiert digitalen Pin 7
int greenled =4;    // Initialisiert digitalen Pin 4

void setup()
{
    pinMode(redled, OUTPUT);    // Setzt den Pin mit der roten LED als „Ausgang“
    pinMode(yellowled, OUTPUT);    // Setzt den Pin mit der gelben LED als „Ausgang“
    pinMode(greenled, OUTPUT);    // Setzt den Pin mit der grünen LED als „Ausgang“
}

void loop()
{
    digitalWrite(greenled, HIGH);    // Schaltet die grüne LED ein delay(5000);    // Wartet 5 Sekunden
    digitalWrite(greenled, LOW);    // Schaltet die grüne LED aus for(int i=0;i<3;i++)    // Blinkt 3x
    {
    delay(500);    // Wartet 5 Sekunden
    digitalWrite(yellowled, HIGH);    // Schaltet die gelbe LED ein delay(500);    // Wartet 5 Sekunden
    digitalWrite(yellowled, LOW);    // Schaltet die gelbe LED aus
    }
    delay(500);    // Wartet 5 Sekunden
    digitalWrite(redled, HIGH);    // Schaltet die rote LED ein delay(5000);    // Wartet 5 Sekunden
    digitalWrite(redled, LOW);    // Schaltet die rote LED aus
} 

Wenn der Hochladeprozess fertig ist, sind die Ampellichter sichtbar.

Das grüne Licht wird für 5 Sekunden leuchten und sich dann abschalten. Danach wird das gelbe Licht 3 Mal blinken und anschließend das rote Licht für 5 Sekunden leuchten, sodass ein Kreislauf gebildet wird.

5.5 Projekt 5: LED Jagd-Effekt

Wir sehen oft Reklametafeln, welche versehen sind mit bunten LEDs.

Diese ändern sich ständig um verschiedene Effekte zu formen. In diesem Experiment wird ein Programm verfasst, welches den LED Jagd-effekt simuliert.

Hardware Menge
Mega2560 Platine 1
USB Kabel 1
LED 6
220Ω Widerstand	6
Breadboard 1
Breadboard Überbrückungskabel 12

int BASE = 2; // Der I/O Pin für die erste LED
int NUM = 6; // Anzahl der LEDs
void setup()
{
    for (int i = BASE; i < (BASE + NUM); i++)
    {
    pinMode(i, OUTPUT); // Setzt I/O Pinne als Ausgang
    }
}
void loop()
{
    for (int i = BASE; i < (BASE + NUM); i++)
    {
    digitalWrite(i, LOW); // Setzt I/O Pinne auf „niedrig“, schaltet die LEDs
    // nacheinander ein
    delay(200); // Verzögerung
    }
    for (int i = BASE; i < (BASE + NUM); i++)
    {
    digitalWrite(i, HIGH); // Setzt I/O Pinne auf „hoch“, schaltet die LEDs nacheinander ab
    delay(200); // Verzögerung
    }
} 

5.6 Projekt 6: Tastengesteuerte LED

I/O Port ist die Schnittstelle für EINGANG und AUSGANG.

Bis jetzt haben wir nur den Ausgang benutzt.

In diesem Experiment werden wir versuchen den Eingang zu benutzen, um den Ausgangswert des angeschlossenen Gerätes auslesen zu können.

Wir werden eine Taste und eine LED mit dem Eingang und dem Ausgang benutzen, um ein besseres Verständnis über die I/O Funktion zu vermitteln.

Tastenschalter, den meisten von uns bekannt, haben einen Schaltwert (digitaler Wert). Wenn der Schalter gedrückt wird schließt sich der Schaltkreis und befindet sich in einem leitenden Status.

Hardware Menge
Mega2560 Platine 1
USB Kabel 1
LED 1
220Ω Widerstand	1
10kΩ Widerstand	1
Tastenschalter 1
Breadboard 1
Breadboard Überbrückungskabel 5

Sobald man die Taste drückt, wird sich die LED einschalten. In diesem Programm wird eine Entscheidungsabfrage benutzt.

int ledpin=11;    // Initialisiert Pin 11
int inpin=7;    // Initialisiert Pin 7
int val;    // Definiert „Val"
void setup()
{
    pinMode(ledpin,OUTPUT);    // Setzt LED Pin als „Ausgang“
    pinMode(inpin,INPUT);    // Setzt Tastenpin als „Eingang“
}
void loop()
{
    val=digitalRead(inpin);    // Liest den Pegelwert von Pin 7
    // und ordnet diesen „Val“ zu
    if(val==LOW)    // Prüft ob die Taste gedrückt wird,
    falls ja,
    // wird die LED eingeschaltet
    { digitalWrite(ledpin,LOW);} 
    else 
    { digitalWrite(ledpin,HIGH);} 
} 

Wenn die Taste gedrückt wird, leuchtet die LED, ansonsten bleibt sie aus. Das simple Prinzip dieses Experimentes wird oft in einer Vielfalt von Schaltkreisen und Elektrogeräten verwendet.

5.7 Projekt 7: Responder Experiment

In diesem Programm gibt es 3 Tasten und eine Reset-Taste, welche mit Hilfe von 7 digitalen I/O PINs die 3 entsprechenden LEDs steuern.

Hardware Menge
Mega2560 Platine 1
USB Kabel 1
Rote M5 LED 1
Gelbe M5 LED 1
Grüne M5 LED 1
220Ω Widerstand	7
Tastenschalter 4
Breadboard 1
Breadboard Überbrückungskabel 13

int redled=8;    // Setzt die rote LED als „Ausgang“
int yellowled=7;    // Setzt die gelbe LED als „Ausgang“
int greenled=6;    // Setzt die grüne LED als „Ausgang“
int redpin=5;    // Initialisiert Pin für rote Taste
int yellowpin=4;    // Initialisiert Pin für gelbe Taste
int greenpin=3;    // Initialisiert Pin für grüne Taste
int restpin=2;    // Initialisiert Pin für Reset-Taste
int red;
int yellow;
int green;
void setup()
{
    pinMode(redled,OUTPUT);
    pinMode(yellowled,OUTPUT);
    pinMode(greenled,OUTPUT);
    pinMode(redpin,INPUT);
    pinMode(yellowpin,INPUT);
    pinMode(greenpin,INPUT);
}
void loop()    //Liest wiederholt die Pinne der Tasten
{
    red=digitalRead(redpin);
    yellow=digitalRead(yellowpin);
    green=digitalRead(greenpin);
    if(red==LOW)RED_YES();
    if(yellow==LOW)YELLOW_YES();
    if(green==LOW)GREEN_YES();
}

void RED_YES()    // Führt den Code aus bis rote LED an //
    //ist; endet den Kreislauf wenn die
    //Reset-Taste betätigt wird
{
    while(digitalRead(restpin)==1)
    {
    digitalWrite(redled,HIGH);
    digitalWrite(greenled,LOW);
    digitalWrite(yellowled,LOW);
    }
    clear_led();
} 

void YELLOW_YES() // Führt den Code aus bis gelbe LED an
    //ist; endet den Kreislauf
    //wenn die Reset-Taste betätigt wird
{
    while(digitalRead(restpin)==1)
    {
    digitalWrite(redled,LOW);
    digitalWrite(greenled,LOW);
    digitalWrite(yellowled,HIGH);
    }
    clear_led();
}
void GREEN_YES() // Führt den Code aus bis grüne LED an
    //ist; endet den
    //Kreislauf wenn die Reset-Taste betätigt
    //wird
{
    while(digitalRead(restpin)==1)
    {
    digitalWrite(redled,LOW);
    digitalWrite(greenled,HIGH);
    digitalWrite(yellowled,LOW);
    }
    clear_led();
}
void clear_led() // Alle LEDs aus
{
    digitalWrite(redled,LOW);
    digitalWrite(greenled,LOW);
    digitalWrite(yellowled,LOW);
} 

Achten Sie bitte darauf, dass Sie beide Code-Teile in ihrem Sketch des Arduino-Programms zusammenfügen.

Wenn eine Taste betätigt wird, schaltet sich die entsprechende LED ein.

Wird die Reset-Taste betätigt, schaltet sich die entsprechende LED wieder aus.

5.8 Projekt 8: Aktiver Summer

Aktive Summer werden in Computern, Druckern, Weckern, Elektrospielzeug etc. als ein Geräusch emittierendes Element eingesetzt. Es hat eine innere Vibrationsquelle. Mit einer 5V-Energieversorgung verbunden, kann es wiederholt summen.

Hardware Menge
Mega2560 Platine 1
USB Kabel 1
Summer 1
Breadboard 1
Breadboard Überbrückungskabel 2

int buzzer=8;    // Initialisiere digitalen I/O
Pin, welcher den Summer
    //kontrolliert

void setup()
{
    pinMode(buzzer,OUTPUT);    // Stellt den Pin Modus auf
    // „Ausgang"
}

void loop()
{
    digitalWrite(buzzer, HIGH);    // Macht Geräusche
} 

Das Projekt ist nach dem Übertragen des Programms abgeschlossen.

Der Summer summt.

5.9 Projekt 9: Passiver Summer

Mit dem Mega2560 sind viele interaktive Projekte möglich.

Die bisherigen Projekte haben sich hauptsächlich mit LEDs beschäftigt, doch ein häufig verwendetes Projekt ist das akustisch-optische Display.

Hierfür wird ein passiver Summer verwendet, der sich, im Gegensatz zum aktiven Summer, nicht selbst aktivieren kann.

Die Aktivierung erfolgt über eine Pulsfrequenz.

Unterschiedliche Frequenzen resultieren beim Summer in unterschiedlichen Tönen.

Dies kann dafür genutzt werden, um beispielsweise die Melodie eines Liedes wiederzugeben.

Hardware Menge
Mega2560 Platine 1
USB Kabel 1
Passiver Summer 1
Breadboard 1
Breadboard Überbrückungskabel 2

int buzzer=8;    // Wählt digitalen I/O Pin für den Summer
    // aus
void setup()
{
    pinMode(buzzer,OUTPUT);    // Setzt die digitale IO Pinreihen
    //Ausgänge als Ausgang.
}
void loop()
{
    unsigned char i,j;    // Bestimmt Variable
    while(1)
    {
    for(i=0;i<80;i++)    // Gibt einen Frequenzton aus
    {
    digitalWrite(buzzer,HIGH);    // Ton
    delay(1);    // 1ms Verzögerung
    digitalWrite(buzzer,LOW);    // Kein Ton
    delay(1);    // 1ms Verzögerung
    }
    for(i=0;i<100;i++)    // Gibt Frequenzton aus
    {
    digitalWrite(buzzer,HIGH);    // Ton
    digitalWrite(buzzer,LOW);    // Kein Ton
    delay(2);    // 2ms Verzögerung
    }
    }
} 

5.10 Projekt 10: Analogwert auslesen

In diesem Projekt geht es um die analogen Schnittstellen des Mega2560.

Ein analogRead () Befehl kann den Wert der Schnittstelle lesen.

Durch die Analog-Digital-Umwandlung des Mega2560 liegen die ausgelesenen Werte zwischen 0 und 1023.

Um die Werte auslesen zu können, ist es wichtig, auf die richtige Baudrate zu achten.

Die Baudrate des Computers sollte der Baudrate des Gerätes entsprechen.

Öffnet man den seriellen Monitor des Arduino-Programms, so kann man die Baudrate in der unteren rechten Ecke konfigurieren.

In diesem Projekt wird der eingestellte Widerstandswert eines Potentiometers zu einem analogen Signal umgewandelt und anschließend auf dem Bildschirm ausgegeben.

Hardware Menge
Mega2560 Platine 1
USB Kabel 1
Potentiometer 1
Breadboard 1
Breadboard Überbrückungskabel 3

int potpin=0;    // Initialisiert analogen Pin 0
int ledpin=13;    // Initialisiert digitalen Pin 13
int val=0;    // Definiert „Val“, ordnet Ur-
sprungswert zu
void setup()
{
    pinMode(ledpin,OUTPUT);    // Setzt digitalen Pin als „Ausgang“
    Serial.begin(9600);    // Setzt Baudrate auf 9600
}
void loop()
{
    digitalWrite(ledpin,HIGH);    // Schaltet LED auf Pin 13 ein
    delay(50);    // Wartet 0,05 Sekunden
    digitalWrite(ledpin,LOW);    // Schaltet LED auf Pin 13 aus
    delay(50);    // Wartet 0,05 Sekunden
    val=analogRead(potpin);    // Liest Analogwert vom Pin 0
    //und ordnet ihn „Val“ zu
    Serial.println(val);    // Zeigt Wert von „Val“
} 

Die ausgelesenen Werte werden im seriellen Monitor ausgegeben.

5.11 Projekt 11: Fotowiderstand

Ein Fotowiderstand (Photovaristor) ist ein Widerstand, dessen Widerstandskraft je nach einfallender Lichtstärke variiert.

Er basiert auf dem fotoelektrischen Effekt von Halbleitern.

Wenn das einfallende Licht intensiv ist, reduziert sich die Widerstandskraft.

Wenn das einfallende Licht schwach ist, erhöht sich die Widerstandskraft.

Photovaristoren werden normalerweise zur Lichtmessung, Lichtkontrolle und zur Photovoltaik-Umwandlung (konvertiert die Änderung von Licht in eine Änderung der Elektrizität) benutzt.

Fotowiderstände werden in diversen Licht-Steuerungs-Schaltkreisen eingesetzt, z.B. als optische Schalter. In diesem Projekt wird dieser Effekt genutzt um eine LED der aktuellen Lichtstärke anzupassen.

Hardware Menge
Mega2560 Platine 1
USB Kabel 1
Rote M5 LED 1
Fotowiderstand 1
220Ω Widerstand	1
10kΩ Widerstand	1
Breadboard 1
Breadboard Überbrückungskabel 5

int potpin=0;    // Initialisiert analogen Pin 0 an
    //dem Photovaristor angeschlossen ist
int ledpin=11;    // Initialisiert digitalen Pin 11. Ausgang
    //welcher die Helligkeit der LED reguliert
int val=0;    // Initialisiert Variable „Val“
void setup()
{
    pinMode(ledpin,OUTPUT);    // Stellt Pin 11 als Ausgang ein
    Serial.begin(9600);    // Setzt Baudrate auf „9600“
}
void loop()
{
    val=analogRead(potpin);    // Liest den Analogwert des Sensors
    //und dieser wird „Val“ zugewiesen
    Serial.println(val);    // Zeigt den Wert von „Val“ an
    analogWrite(ledpin,val);    // Schaltet die LED ein und stellt die
    //Helligkeit ein
    delay(10);    // Wartet 0,01 Sekunden
} 

5.12 Projekt 12: Flammensensor

Der Flammensensor (infrarotempfangende Triode) wird speziell auf Robotern verwendet um Flammenquellen zu finden.

Dieser Sensor hat eine hohe Sensitivität zu Flammen.

Der Flammensensor ist nach dem Prinzip, dass Infrarotstrahlung sehr empfindlich auf Feuer reagiert, gebaut.

Er hat ein speziell entworfenes Infrarot-Aufnahmerohr um Feuer zu entdecken, um dann die Helligkeit der Flamme zu einem Signal umzuwandeln.

Diese Signale werden dann zum zentralen Prozessor weitergegeben und entsprechend verarbeitet.

Wenn der Sensor sich einem Feuer nähert, ändert sich der analoge Spannungswert.

Mit einem Multimeter lässt sich überprüfen, dass die Spannung bei 0.3V liegt, wenn sich kein Feuer nähert.

Nähert sich ein Feuer, so liegt die Spannung bei 1.0V.

Je höher die Spannung, desto näher das Feuer.

Hardware Menge
Mega2560 Platine 1
USB Kabel 1
Flammensensor 1
Summer 1
10kΩ Widerstand	1
Breadboard 1
Breadboard Überbrückungskabel 6

int flame=0;    // Wählt analogen Pin 0 für Sensor aus
int Beep=9;    // Wählt digitalen Pin 9 für Summer aus
int val=0;    // Initialisiert Variable

void setup()
{
    pinMode(Beep,OUTPUT);    // Stellt Summer Pin als „Ausgang“ ein
    pinMode(flame,INPUT);    // Stellt Sensor Pin als „Eingang“ ein
    Serial.begin(9600);    // Setzt Baudrate auf „9600“
}

void loop()
{
    val=analogRead(flame);    // Liest den Analogwert des Sensors
    Serial.println(val);    // Gibt den Analogwert aus
    if(val>=600)    // Summer summt, wenn Analogwert über 600
    {
    digitalWrite(Beep,HIGH);
    }else
    {
    digitalWrite(Beep,LOW);
    }
    delay(500);
} 

5.13 Projekt 13: Lageschalter

Der Lageschalter kontrolliert den EIN- und AUSSCHALTER einer LED.

Der Schalter ist an, wenn ein Ende vom Schalter unterhalb horizontaler Position ist.

Anhand des Spannungswertes des Analog-Ports, an dem der Lageschalter angeschlossen wird, kann geprüft werden, in welcher Lage sich der Schalter befindet.

Hardware Menge
Mega2560 Platine 1
USB Kabel 1
Lageschalter 1
Rote M5 LED 1
220Ω Widerstand	1
Breadboard 1
Breadboard Überbrückungskabel 5

void setup()
{
    pinMode(8, OUTPUT); // Stellt digitalen Pin 8 als „Ausgang“ ein
}
void loop()
{
    int i; // Definiert Variable i
    while(1)
    {
    i=analogRead(5); // Liest den Spannungswert vom analogen Pin 5
    if(i>512) // Wenn größer als 512 (2.5V)
    {
    digitalWrite(8,LOW); // Schalte LED ein
    }
    else // sonst
    {
    digitalWrite(8,HIGH); // Schalte LED aus
    }
    }
} 

Wird das Breadboard bis zu einem bestimmten Grad geneigt, so schaltet sich die LED ein. Falls es keine Neigung gibt, bleibt die LED aus.

5.14 Projekt 14: 1-Ziffer LED Segment Anzeige

LED Segment Anzeigen sind verbreitet für die Anzeige von numerischen Informationen.

Sie werden oft bei Anzeigen von elektromagnetischen Öfen, vollautomatischen Waschmaschinen, Wassertemperaturdisplays, elektronischen Uhren etc. verwendet.

Die LED Segment Anzeige ist ein Halbleiter und ein Licht ausgebendes Gerät.

Seine Basiseinheit ist eine LED.

Die LED Segment Anzeige kann in die 7-Segment und die 8-Segment Anzeige unterteilt werden. Die 8-Segment Anzeige hat eine LED-Einheit mehr (für die Dezimalpunkt Anzeige) als die 7-Segment Anzeige.

Je nach Verdrahtung der LED-Einheiten, kann die LED Segment Anzeige in Anzeigen mit gemeinsamer Anode und Anzeigen mit gemeinsamer Kathode unterteilt werden.

Die Anzeige mit gemeinsamer Anode kombiniert alle Anoden der LED-Einheiten in eine gemeinsame Anode (COM).

Für die gemeinsame Anode Anzeige muss die gemeinsame Anode (COM) mit +5V verbunden werden.

Wenn der Kathodenpegel eines Segments niedrig ist, ist das Segment an.

Wenn der Kathodenpegel eines Segments hoch ist, ist das Segment aus.

Für die gemeinsame Kathodenanzeige muss die gemeinsame Kathode (COM) mit GND verbunden werden.

Wenn der Anodenpegel eines Segments hoch ist, ist das Segment an.

Wenn der Anodenpegel eines Segments niedrig ist, ist das Segment aus.

Hardware Menge
Mega2560 Platine 1
USB Kabel 1
8-Segment Anzeige 1
220Ω Widerstand	8
Breadboard 1
Breadboard Überbrückungskabel 12

// Stelle den IO Pin für jedes Segment ein
int a=7;    // Stellt digitalen Pin 7 für Segment a ein
int b=6;    // Stellt digitalen Pin 6 für Segment b ein
int c=5;    // Stellt digitalen Pin 5 für Segment c ein
int d=10;    // Stellt digitalen Pin 10 für Segment d ein
int e=11;    // Stellt digitalen Pin 11 für Segment e ein
int f=8;    // Stellt digitalen Pin 8 für Segment f ein
int g=9;    // Stellt digitalen Pin 9 für Segment g ein
int dp=4;    // Stellt digitalen Pin 4 für Segment dp ein

void digital_0(void)    // Zeigt Nummer 5 an
{
    unsigned char j;
    digitalWrite(a,HIGH);
    digitalWrite(b,HIGH);
    digitalWrite(c,HIGH);
    digitalWrite(d,HIGH);
    digitalWrite(e,HIGH);
    digitalWrite(f,HIGH);
    digitalWrite(g,LOW);
    digitalWrite(dp,LOW);
}

void digital_1(void)    // Zeigt Nummer 1 an
{
    unsigned char j;
    digitalWrite(c,HIGH);    // Setzt Pegel für Pin 5 auf „hoch“
    digitalWrite(b,HIGH);    // Schaltet Segment b aus
    for(j=7;j<=11;j++)    // Schaltet andere Segmente aus
    digitalWrite(j,LOW);
    digitalWrite(dp,LOW);    // Schaltet Segment dp aus
}

void digital_2(void)    // Zeigt Nummer 2 an
{
    unsigned char j;
    digitalWrite(b,HIGH);
    digitalWrite(a,HIGH);
    for(j=9;j<=11;j++)
    digitalWrite(j,HIGH);
    digitalWrite(dp,LOW);
    digitalWrite(c,LOW);
    digitalWrite(f,LOW);
} 

void digital_3(void)    // Zeigt Nummer 3 an
{
    digitalWrite(g,HIGH);
    digitalWrite(a,HIGH);
    digitalWrite(b,HIGH);
    digitalWrite(c,HIGH);
    digitalWrite(d,HIGH);
    digitalWrite(dp,LOW);
    digitalWrite(f,LOW);
    digitalWrite(e,LOW);
}

void digital_4(void)    // Zeigt Nummer 4 an
{
    digitalWrite(c,HIGH);
    digitalWrite(b,HIGH);
    digitalWrite(f,HIGH);
    digitalWrite(g,HIGH);
    digitalWrite(dp,LOW);
    digitalWrite(a,LOW);
    digitalWrite(e,LOW);
    digitalWrite(d,LOW);
}

void digital_5(void)    // Zeigt Nummer 5 an
{
    unsigned char j;
    digitalWrite(a,HIGH);
    digitalWrite(b, LOW);
    digitalWrite(c,HIGH);
    digitalWrite(d,HIGH);
    digitalWrite(e, LOW);
    digitalWrite(f,HIGH);
    digitalWrite(g,HIGH);
    digitalWrite(dp,LOW);
}

void digital_6(void)    // Zeigt Nummer 6 an
{
    unsigned char j;
    for(j=7;j<=11;j++)
    digitalWrite(j,HIGH);
    digitalWrite(c,HIGH);
    digitalWrite(dp,LOW);
    digitalWrite(b,LOW);
}

void digital_7(void)    // Zeigt Nummer 7 an
{
    unsigned char j;
    for(j=5;j<=7;j++)
    digitalWrite(j,HIGH);
    digitalWrite(dp,LOW);
    for(j=8;j<=11;j++)
    digitalWrite(j,LOW);
} 

void digital_8(void)    // Zeigt Nummer 8 an
{
    unsigned char j;
    for(j=5;j<=11;j++)
    digitalWrite(j,HIGH);
    digitalWrite(dp,LOW);
}
void digital_9(void)    // Zeigt Nummer 5 an
{
    unsigned char j;
    digitalWrite(a,HIGH);
    digitalWrite(b,HIGH);
    digitalWrite(c,HIGH);
    digitalWrite(d,HIGH);
    digitalWrite(e, LOW);
    digitalWrite(f,HIGH);
    digitalWrite(g,HIGH);
    digitalWrite(dp,LOW);
}
void setup()
{
    int i;    // deklariert eine Variable
    for(i=4;i<=11;i++)
    pinMode(i,OUTPUT);    // Stellt Pin 4-11 als „Ausgang“
}
void loop()
{
    while(1)
    {
    digital_0();    // Zeigt Nummer 0 an
    delay(1000);    // Wartet 1 Sekunde
    digital_1();    // Zeigt Nummer 1 an
    delay(1000);    // Wartet 1 Sekunde
    digital_2();    // Zeigt Nummer 2 an
    delay(1000);    // Wartet 1 Sekunde
    digital_3();    // Zeigt Nummer 3 an
    delay(1000);    // Wartet 1 Sekunde
    digital_4();    // Zeigt Nummer 4 an
    delay(1000);    // Wartet 1 Sekunde
    digital_5();    // Zeigt Nummer 5 an
    delay(1000);    // Wartet 1 Sekunde
    digital_6();    // Zeigt Nummer 6 an
    delay(1000);    // Wartet 1 Sekunde
    digital_7();    // Zeigt Nummer 7 an
    delay(1000);    // Wartet 1 Sekunde
    digital_8();    // Zeigt Nummer 8 an
    delay(1000);    // Wartet 1 Sekunde
    digital_9();    // Zeigt Nummer 9 an
    delay(1000);    // Wartet 1 Sekunde
} 

5.15 Projekt 15: 4-Ziffern LED Segment Anzeige

In diesem Projekt wird eine 4-Ziffern 7-Segmente Anzeige betrieben.

Für LED Anzeigen sind strombegrenzende Widerstände unverzichtbar.

Es gibt zwei Verdrahtungsmethoden für strombegrenzende Widerstände.

Bei der ersten verbindet man einen Widerstand mit jeder Anode, das heißt 4 insgesamt für d1-d4 Anode.

Ein Vorteil dieser Methode ist, dass sie weniger Widerstände benötigt, und zwar nur 4 Stück.

Aber diese Methode kann keine konstante Helligkeit erhalten.

Die zweite Methode ist an jeden PIN einen Widerstand zu verbinden.

Hardware Menge
Mega2560 Platine 1
USB Kabel 1
4 Ziffern 7-Segment Anzeige 1
220Ω Widerstand	8
Breadboard 1
Breadboard Überbrückungskabel 12

Wird der obrige Code vollständig auf den Mega2560 übertragen, so gibt die Anzeige „1234“ aus.

5.16 Projekt 16: LM35 Temperatursensor

Der LM35 ist ein verbreiteter und einfach zu benutzender Temperatursensor.

Man braucht keine sonstige Hardware.

Die einzige Schwierigkeit besteht darin, den Code zu schreiben, welcher dafür sorgt, dass die Analogwerte, die er liest, in Celsius Temperatur umgewandelt werden.

Hardware Menge
Mega2560 Platine 1
USB Kabel 1
LM35 1
Breadboard 1
Breadboard Überbrückungskabel 5

int potPin = 0;    // Initialisiert Port A0 für Sensor
void setup()
{
    Serial.begin(9600);    // Stellt die Baudrate auf „9600“
}
void loop()
{
    int val;    // Definiert Variable
    int dat;    // Definiert Variable
    val=analogRead(0);    // Liest den Analogwert vom Sensor
    dat=(125*val)>>8;    // Temperaturkalkulationsformel
    Serial.print("Temp:");    // Ausgabe beginnt mit Temp
    Serial.print(dat);    // Ausgang und Anzeigewert von dat
    Serial.println("C");    // Zeigt „C“ Buchstaben an
    delay(500);    // Wartet 0,5 Sekunden
} 

Auf dem seriellen Monitor kann nun die Temperaturausgabe überwacht werden.

5.17 Projekt 17: 74HC595

Das 74HC595 ist eine Kombination aus einem 8-Ziffern Schieberegister, Merker und ausgestattet mit einem Tri-State Ausgang.

In diesem Projekt wird der 74HC595 verwendet, um 8 LEDs Ressourcensparend zu verwenden.

Die benötigten I/O Ports reduzieren sich von 8 auf 3 Ports.

Hardware Menge
Mega2560 Platine 1
USB Kabel 1
74HC595 Chip 1
Rote M5 LED 4
Grüne M5 LED 4
220Ω Widerstand	8
Breadboard 1
Breadboard Überbrückungskabel 37

int data = 2;    // Stellt Pin 14 des 74HC595 als Dateneingang
int clock = 5;    // Stellt Pin 11 des 74HC595 als Tackt Pin
int latch = 4;    // Stellt Pin 12 des 74HC595 als Ausgang
int ledState = 0;
const int ON = HIGH;
const int OFF = LOW;
void setup()
{
    pinMode(data, OUTPUT);
    pinMode(clock, OUTPUT);
    pinMode(latch, OUTPUT);
}
void loop()
{
    for(int i = 0; i < 256; i++)
    {
    updateLEDs(i);
    delay(500);
    }
}
void updateLEDs(int value)
{
    digitalWrite(latch, LOW);
    shiftOut(data, clock, MSBFIRST, ~value);
    digitalWrite(latch, HIGH);    // Verriegeln
} 

5.18 Projekt 18: RGB LED

Diese Diode wird durch PWM Signale gesteuert und besitzt ein dreifarbiges System um Farben darzustellen.

Das Bauteil kann direkt an den Mega2560 Schnittstellen ausgeführt werden.

5.19 Projekt 19: Infrarot Fernbedienung

Der IR-Empfänger wandelt das ankommende Lichtsignal in ein schwaches, elektrisches, Signal um. Um den Code einer Fernbedienung zu dekodieren, ist es nötig die Kodierungsmethode zu kennen. In diesem Projekt wird dafür das NEC-Protokoll verwendet.

Hardware Menge
Mega2560 Platine 1
USB Kabel 1
Infrarotempfänger 1
Infrarot Fernbedienung 1
Rote M5 LED 6
220Ω Widerstand	6
Breadboard 1
Breadboard Überbrückungskabel 11

Bitte achten Sie darauf, dass Sie, bevor Sie den unten stehenden Code auf Ihren Mega2560 übertragen, die IRremote Bibliothek in Ihrem Arduino Bibliotheksverwalter herunterladen und installieren. Nur dann wird das Projekt wie gewünscht funktionieren.

#include <IRremote.h>
int RECV_PIN = 11;
int LED1 = 2;
int LED2 = 3;
int LED3 = 4;
int LED4 = 5;
int LED5 = 6;
int LED6 = 7;
long on1 = 0x00FFA25D;
long off1 = 0x00FFE01F;
long on2 = 0x00FF629D;
long off2 = 0x00FFA857;
long on3 = 0x00FFE21D;
long off3 = 0x00FF906F;
long on4 = 0x00FF22DD;
long off4 = 0x00FF6897;
long on5 = 0x00FF02FD;
long off5 = 0x00FF9867;
long on6 = 0x00FFC23D;
long off6 = 0x00FFB047;
IRrecv irrecv(RECV_PIN);
decode_results results;

void dump(decode_results *results) {
    int count = results->rawlen;
    if (results->decode_type == UNKNOWN)
    {
    Serial.println("Could not decode message");
    }
    else 
    {
    if (results->decode_type == NEC)
    {
    Serial.print("Decoded NEC: ");
    } else if (results->decode_type == SONY)
    {
    Serial.print("Decoded SONY: ");
    }
    else if (results->decode_type == RC5)
    {
    Serial.print("Decoded RC5: ");
    }
    else if (results->decode_type == RC6)
    {
    Serial.print("Decoded RC6: ");
    }
} 

Serial.print(results->value, HEX);
    Serial.print(" ");
    Serial.print(results->bits, DEC);
    Serial.println(" bits)");
}
    Serial.print("Raw ");
    Serial.print(count, DEC);
    Serial.print(": );

for (int i = 0; i < count; i++)
{
    if ((i % 2) == 1) {
    Serial.print(results->rawbuf[i]*USECPERTICK, DEC);
    }
    else 
    {
    Serial.print(-(int)results->rawbuf[i]*USECPERTICK, DEC);
    }
    Serial.print(" ");
    }
    Serial.println("");
}

void setup()
{
    pinMode(RECV_PIN, INPUT);
    pinMode(LED1, OUTPUT);
    pinMode(LED2, OUTPUT);
    pinMode(LED3, OUTPUT);
    pinMode(LED4, OUTPUT);
    pinMode(LED5, OUTPUT);
    pinMode(LED6, OUTPUT);
    pinMode(13, OUTPUT);
    Serial.begin(9600);

    irrecv.enableIRIn(); // Start the receiver
}

int on = 0;
unsigned long last = millis(); 

void loop()
{
    if (irrecv.decode(&results))
    {
    if (millis() - last > 250)
    {
    on = !on;
    // digitalWrite(8, on ? HIGH : LOW);
    digitalWrite(13, on ? HIGH : LOW);
    dump(&results);
    }
    if (results.value == on1)
    digitalWrite(LED1, HIGH);
    if (results.value == off1)
    digitalWrite(LED1, LOW);
    if (results.value == on2)
    digitalWrite(LED2, HIGH);
    if (results.value == off2)
    digitalWrite(LED2, LOW);
    if (results.value == on3)
    digitalWrite(LED3, HIGH);
    if (results.value == off3)
    digitalWrite(LED3, LOW);
    if (results.value == on4)
    digitalWrite(LED4, HIGH);
    if (results.value == off4)
    digitalWrite(LED4, LOW);
    if (results.value == on5)
    digitalWrite(LED5, HIGH);
    if (results.value == off5)
    digitalWrite(LED5, LOW);
    if (results.value == on6)
    digitalWrite(LED6, HIGH);
    if (results.value == off6)
    digitalWrite(LED6, LOW);
    last = millis();
    irrecv.resume();
} 

5.20 Projekt 20: 8x8 LED Matrix

Die interne Struktur und äußere Erscheinung einer LED Matrix sind wie folgt:

Die 8x8 LED Matrix besteht aus 64 LEDs.

Jede LED ist im Bereich des Schnittpunktes von Reihe und Spalte platziert.

Wenn der Pegel für eine Reihe 1 ist und der Pegel der entsprechenden Spalte 0 ist, wird die LED in deren Schnittpunkt angehen.

Beispiel: Wenn du die erste LED einschalten willst, stelle Pin 9 auf „HIGHPEGEL“ und Pin 13 auf „LOWPEGEL“ ein.

Falls du die erste Reihe einschalten willst, stelle Pin 9 auf

„HIGHPEGEL“ und die Pinne 13, 3, 4, 10, 6, 11, 15, 16 auf „LOWPEGEL“ ein.

Um die erste Spalte einzuschalten stelle Pin 13 auf „LOWPEGEL“ und die Pinne 9, 14, 8, 12, 1, 7, 2, 5 auf „HIGHPEGEL“.