Abschlussprojekt und Präsentation
– Praktisch: Die
Schüler arbeiten an einem eigenen kleinen Projekt oder in Gruppen an einem
größeren Projekt, wie z.B. einem Mini-Roboter, einer Alarmanlage oder einem
einfachen Spiel.
– Präsentation:
Jede Gruppe oder jeder Schüler stellt sein Projekt vor und erklärt, wie es
funktioniert.
Extra Projekte
Prejekt 1: RGB-LED
Ein Projekt mit einer RGB-LED ist eine großartige Möglichkeit,
grundlegende Elektronik- und Programmierkenntnisse zu vermitteln. RGB-LEDs
können in verschiedenen Farben leuchten, indem sie unterschiedliche Mengen an
rotem, grünem und blauem Licht mischen.
Komponentenliste
– Arduino Uno
– RGB-LED (gemeinsame Anode oder Kathode)
– 3 Widerstände (220Ω bis 330Ω)
– Breadboard
– Jumper-Kabel
Verbindungen
1. RGB-LED:
– RGB-LEDs haben
vier Anschlüsse: einen für jede Farbe (Rot, Grün, Blau) und einen gemeinsamen
Anschluss (Anode oder Kathode).
– Wenn die LED eine
gemeinsame Anode (positiver Anschluss) hat, verbinde diesen mit 5V.
– Wenn die LED eine
gemeinsame Kathode (negativer Anschluss) hat, verbinde diesen mit GND.
2. Farben:
– Verbinde den
Rot-Pin der LED über einen 220Ω-Widerstand mit Pin 9 des Arduino.
– Verbinde den
Grün-Pin der LED über einen 220Ω-Widerstand mit Pin 10 des Arduino.
– Verbinde den
Blau-Pin der LED über einen 220Ω-Widerstand mit Pin 11 des Arduino.
Beispielcode
//Dieser Code steuert die RGB-LED und lässt sie verschiedene
Farben anzeigen:
//
Pin-Definitionen
const int
redPin = 9;
const int
greenPin = 10;
const int
bluePin = 11;
// Funktion
zur Einstellung der LED-Farbe
void
setColor(int redValue, int greenValue, int blueValue) {
analogWrite(redPin, 255 – redValue); // 255
minus Wert für gemeinsame Anode
analogWrite(greenPin, 255 – greenValue); //
255 minus Wert für gemeinsame Anode
analogWrite(bluePin, 255 – blueValue); // 255
minus Wert für gemeinsame Anode
}
void setup() {
// Setze die Pin-Modi
pinMode(redPin, OUTPUT);
pinMode(greenPin, OUTPUT);
pinMode(bluePin, OUTPUT);
// Starte mit der LED ausgeschaltet
setColor(0, 0, 0);
}
void loop() {
// Verschiedene Farben durchlaufen lassen
setColor(255, 0, 0); // Rot
delay(1000); // 1 Sekunde warten
setColor(0, 255, 0); // Grün
delay(1000); // 1 Sekunde warten
setColor(0, 0, 255); // Blau
delay(1000); // 1 Sekunde warten
setColor(255, 255, 0); // Gelb
delay(1000); // 1 Sekunde warten
setColor(0, 255, 255); // Cyan
delay(1000); // 1 Sekunde warten
setColor(255, 0, 255); // Magenta
delay(1000); // 1 Sekunde warten
setColor(255, 255, 255); // Weiß
delay(1000); // 1 Sekunde warten
setColor(0, 0, 0); // Aus
delay(1000); // 1 Sekunde warten
}
Erklärung des Codes
1. Pin-Definitionen:
– Die Pins, die mit
den roten, grünen und blauen Anoden/Kathoden der LED verbunden sind, werden
definiert.
2. Setup:
– Die Pins werden
als Ausgänge konfiguriert.
3. Loop:
– Die
`setColor`-Funktion wird aufgerufen, um die RGB-LED in verschiedenen Farben
leuchten zu lassen.
– Jede Farbe wird
für 1 Sekunde angezeigt (`delay(1000)`).
4. setColor-Funktion:
– Diese Funktion
verwendet `analogWrite`, um die Intensität der roten, grünen und blauen LEDs zu
steuern, wodurch verschiedene Farben erzeugt werden.
Erweiterungsideen
– Benutzerinteraktion: Füge Tasten hinzu, um die Farben
manuell zu ändern.
– Farbverlauf: Programmiere einen sanften Übergang zwischen
den Farben.
– Sensorintegration: Verwende einen Sensor (z.B.
Lichtsensor), um die Farben basierend auf Umgebungsbedingungen zu ändern.
Dieses Projekt bietet eine einfache Einführung in die
Verwendung von RGB-LEDs mit dem Arduino und kann leicht erweitert werden, um
komplexere Projekte zu erstellen.
Projekt 2: PWM
Einführung in PWM (Pulse Width Modulation)
Pulse Width Modulation (PWM) ist eine Technik zur Erzeugung
analoger Ergebnisse mit digitalen Mitteln. Durch schnelles Ein- und Ausschalten
eines digitalen Signals und Variieren der „Ein“-Zeit relativ zur
„Aus“-Zeit, kann die Durchschnittsleistung des Signals gesteuert
werden. PWM wird häufig zur Steuerung von Motoren, LEDs und anderen Geräten
verwendet, die eine variable Leistung benötigen.
Einfaches Beispiel: Helligkeit einer LED steuern
In diesem Beispiel verwenden wir PWM, um die Helligkeit
einer LED mit einem Arduino zu steuern.
Komponentenliste
– Arduino Uno
– LED
– 220Ω-Widerstand
– Breadboard
– Jumper-Kabel
Verbindungen
1. LED:
– Verbinde den
längeren Anschluss der LED (Anode) über einen 220Ω-Widerstand mit Pin 9 des
Arduino.
– Verbinde den
kürzeren Anschluss der LED (Kathode) mit GND.
Beispielcode
Der folgende Code verwendet PWM, um die Helligkeit der LED
allmählich zu erhöhen und zu verringern.
const int ledPin = 9; // Pin, an dem die LED
angeschlossen ist
void setup() {
// Setze
den LED-Pin als Ausgang
pinMode(ledPin, OUTPUT);
}
void loop() {
//
Helligkeit der LED schrittweise erhöhen
for (int brightness = 0; brightness <= 255; brightness++) {
analogWrite(ledPin, brightness);
delay(10);
}
// Helligkeit
der LED schrittweise verringern
for (int brightness = 255; brightness >= 0; brightness–) {
analogWrite(ledPin, brightness);
delay(10);
}
}
Erklärung des Codes
1. Pin-Definition:
– Der Pin, an dem
die LED angeschlossen ist, wird definiert (`ledPin`).
2. Setup:
– Der LED-Pin wird
als Ausgang konfiguriert (`pinMode(ledPin, OUTPUT)`).
3. Loop:
– Die
`loop`-Funktion enthält zwei `for`-Schleifen:
– Die erste
Schleife erhöht die Helligkeit der LED schrittweise von 0 (aus) bis 255 (voll
an), indem der `analogWrite`-Befehl verwendet wird. Nach jeder Änderung der
Helligkeit wartet der Code 10 Millisekunden (`delay(10)`), um eine sanfte
Änderung der Helligkeit zu ermöglichen.
– Die zweite
Schleife verringert die Helligkeit der LED schrittweise von 255 zurück auf 0,
ebenfalls mit einer kleinen Verzögerung nach jeder Änderung.
Wie PWM funktioniert
– Duty Cycle: Der Anteil der Zeit, in der das Signal
„ein“ ist, im Verhältnis zur Gesamtzeit eines PWM-Zyklus. Ein 100%
Duty Cycle bedeutet, dass das Signal die ganze Zeit an ist, ein 50% Duty Cycle
bedeutet, dass das Signal die Hälfte der Zeit an und die Hälfte der Zeit aus
ist.
– Frequenz: Wie oft das PWM-Signal pro Sekunde ein- und
ausgeschaltet wird. Bei Arduino beträgt die Standardfrequenz für PWM etwa 490
Hz für die meisten Pins.
Visuelle Darstellung
– 0% Duty Cycle: LED ist aus.
– 50% Duty Cycle: LED leuchtet halb so hell wie bei voller
Helligkeit.
– 100% Duty Cycle: LED ist voll an.
Durch das Variieren des Duty Cycles kann die
durchschnittliche Leistung, die der LED zugeführt wird, verändert werden, was
die wahrgenommene Helligkeit steuert. Dieses Prinzip kann auch auf andere
Geräte wie Motoren angewendet werden, um ihre Geschwindigkeit oder andere
Parameter zu steuern.
Projekt 3: Potentiometer
Ein Potentiometer ist ein variabler Widerstand, der oft als
Drehregler verwendet wird. Du kannst es nutzen, um den analogen Wert an einem
Arduino einzulesen und damit z.B. die Helligkeit einer LED zu steuern. Hier ist
eine Anleitung, wie du ein kleines 3-beiniges Potentiometer mit dem Arduino
verbindest und programmierst.
Komponentenliste
– Arduino Uno
– Potentiometer (3-beinig)
– LED
– 220Ω-Widerstand
– Breadboard
– Jumper-Kabel
Verbindungen
1. Potentiometer:
– Das Potentiometer
hat drei Anschlüsse:
– Links: Verbinde
diesen Anschluss mit GND (Masse).
– Mitte: Verbinde
diesen Anschluss mit einem analogen Pin des Arduino (z.B. A0).
– Rechts:
Verbinde diesen Anschluss mit 5V.
2. LED:
– Verbinde den
längeren Anschluss der LED (Anode) über einen 220Ω-Widerstand mit Pin 9 des
Arduino.
– Verbinde den
kürzeren Anschluss der LED (Kathode) mit GND.
Beispielcode
Der folgende Code liest den Wert des Potentiometers ein und
verwendet diesen Wert, um die Helligkeit der LED zu steuern.
const int ledPin = 9; // Pin, an dem die LED angeschlossen ist
const int potPin = A0; // Pin, an dem das Potentiometer angeschlossen ist
Erklärung des Codes
1. Pin-Definitionen:
– `potPin`: Der
Pin, an dem das Potentiometer angeschlossen ist (A0).
– `ledPin`: Der
Pin, an dem die LED angeschlossen ist (Pin 9).
2. Setup:
– Die serielle
Kommunikation wird gestartet (`Serial.begin(9600)`), um die Werte im seriellen
Monitor anzeigen zu können.
– Der LED-Pin wird
als Ausgang konfiguriert (`pinMode(ledPin, OUTPUT)`).
3. Loop:
– Der Wert des
Potentiometers wird gelesen (`analogRead(potPin)`), was einen Wert zwischen 0
und 1023 zurückgibt.
– Dieser Wert wird
mithilfe der `map`-Funktion auf einen Bereich von 0 bis 255 skaliert, da
`analogWrite` Werte in diesem Bereich erwartet, um die Helligkeit der LED zu
steuern.
– Der skalierte
Wert wird verwendet, um die Helligkeit der LED mit `analogWrite` einzustellen.
– Der
Potentiometerwert und der entsprechende LED-Helligkeitswert werden im seriellen
Monitor angezeigt (`Serial.print` und `Serial.println`).
Visuelle Darstellung
– Potentiometer auf Minimum: LED ist aus (Helligkeit 0).
– Potentiometer auf Maximum: LED leuchtet voll (Helligkeit
255).
– Potentiometer in der Mitte: LED leuchtet mit halber
Helligkeit (Helligkeit etwa 127).
Durch Drehen des Potentiometers kannst du die Helligkeit der
LED stufenlos verändern. Das Potentiometer fungiert hierbei als analoger
Eingaberegler, dessen Werte zur Steuerung der LED-Helligkeit verwendet werden.
