Schaltplan

• Pins: 12, 8 und 7
• Widerstände: 220 Ohm, ¼ Watt
• Jede LED bekommt einen eigenen Vorwiderstand

int rot = 12;
int gruen = 8;
int blau = 7;
int wartezeit = 1500;

void roteLed() {
  for (int zaehlerRot = 0; zaehlerRot < 5; zaehlerRot++) {
    digitalWrite(rot, HIGH);
    delay(wartezeit);
    digitalWrite(rot, LOW);
    delay(wartezeit);
}  
}

void grueneLed() {
    digitalWrite(gruen, HIGH);
    delay(wartezeit);
    digitalWrite(gruen, LOW);
    delay(wartezeit);
}

void blaueLed() {
    digitalWrite(blau, HIGH);
    delay(wartezeit);
    digitalWrite(blau, LOW);
    delay(wartezeit);
}

void setup() {
  pinMode(rot, OUTPUT);
  pinMode(gruen, OUTPUT);
  pinMode(blau, OUTPUT);
}

void loop() {
  roteLed();
  delay(wartezeit);
  grueneLed();
  delay(wartezeit);
  blaueLed();
  delay(wartezeit);
}

Erklärung Schritt für Schritt

Variablen

Mit int erstellen wir Variablen vom Typ Ganzzahl. Andere Datentypen (z. B. für Fließkommazahlen oder Buchstaben) haben jeweils eigene Kürzel.

Eine Variable bekommt von uns einen Namen.
Dafür gibt es ein paar einfache Regeln:

• Mit Kleinbuchstaben beginnen
• Keine Umlaute verwenden
• Bei zusammengesetzten Wörtern den zweiten Teil mit einem Großbuchstaben beginnen

Beispiele:
lampeGruen
motorRechts

Mit dem Zeichen = weisen wir einer Variablen einen Wert zu.
Jeder Befehl endet mit einem Semikolon ;

Funktionen

Eine Funktion beginnt in unserem Beispiel mit void und einem selbst gewählten Namen. Innerhalb der geschweiften Klammern { } stehen die Befehle, die zur Funktion gehören.

Der Vorteil: Statt die Befehle jedes Mal neu zu schreiben, können wir die Funktion später einfach über ihren Namen aufrufen. Das macht den Code übersichtlicher und spart Arbeit.

Schleifen

Die for- Schleife ist ein praktisches Mittel, um Wiederholungen zu programmieren.
Sie besteht aus drei Teilen:

1. Variable (Startwert)
2. Bedingung (wann die Schleife endet)
3. Veränderung (wie sich die Variable bei jedem Durchlauf verändert)

Beispiel:
for (int zaehlerRot = 0; zaehlerRot < 5; zaehlerRot++)

In diesem Fall wird die Variable zaehlerRot in der Klammer erzeugt und von 0 bis 4 hochgezählt. Insgesamt läuft die Schleife also fünfmal.

Alternativ könnte man die Variable auch außerhalb der Schleife anlegen:
int zaehlerRot = 0;
for (zaehlerRot; zaehlerRot < 5; zaehlerRot++)

Das funktioniert ebenfalls, führt aber zu einem etwas anderen Verhalten.

Ablauf unseres Programms

• Die rote LED blinkt fünfmal – jeweils 1,5 Sekunden an, 1,5 Sekunden aus
• Danach leuchtet die grüne LED einmal für 1,5 Sekunden
• Anschließend die blaue LED ebenfalls für 1,5 Sekunden
• Danach beginnt der Ablauf wieder von vorne

Das Ganze läuft endlos im loop()

Der Beitrag Coden Teil 1 – LEDs erschien zuerst auf Druckerbude.com.

Benötigte Bauteile:
Arduino UNO
Ultraschallsensor HC-SR04
LED
220 Ohm Widerstand
Kabel

Der Sensor:
GRD = Ground = minus
VCC = plus (5V) den Wert habe ich vom Hersteller
TRIG = Signal aussenden
ECHO = Signal empfangen

Im nachfolgenden Code schaltet der Sender eine LED ein, wenn der Abstand zum Sensor größer als 5cm ist.
Am Anfang wird die fertige Bibliothek vom Sensor eingebunden (zum jetzigen Wissensstand von mir braucht man die wohl in diesem Fall nicht einbinden, da das Programm auch ohne funktionierte).
Wir müssen den Schall noch umrechnen.
Schall hat eine Geschwindigkeit von 343,2m/s.
343,2m * 100 = 34320cm/s
1sec = 1000 Millisekunden
34320cm : 1000 Millisekunden = 34,32cm/ Millisekunde
34,32cm/Millisekunde : 1000 (um auf Mikrosekunden (us) zu kommen = 0,0343cm/us
Weil das Signal gesendet und dann wieder empfangen wird (hin, zurück), teilen wir den Wert später durch 2.

#include <hcsr04.h>  //Biliothek für Ultraschall einbinden

# define sender 9  //Weist Pin 9 die Bezeichnung sender zu
# define empfang 8  //Weist Pin 8 die Bezeichnung empfang zu
# define lampe 12  //da wir auf Pin 12 die LED setzen, nennen wir ihn lampe

long zeit;  //eine Variable mit der Bezeichnung zeit erstellen
long entfernung; //eine Variable mit der Bezeichnung entfernung erstellen

void setup() {
  pinMode( sender, OUTPUT );  //dem Pin9 mitteilen, dass er Ausgang ist
  pinMode( empfang, INPUT );  //dem Pin8 mitteilen, dass er Eingang ist
  //mit pinMode legen wir fest welche Rolle der jeweilige Pin uebernimmt
}

void loop() {
digitalWrite(sender, LOW);  //sagt Pin9 soll ausgeschaltet sein

digitalWrite(sender, HIGH);  //sagt Pin9 er soll einschalten
delayMicroseconds(10); //der Sender braucht diese Zeit zum Senden

digitalWrite(sender, LOW);  //Sender ausschalten

zeit = pulseIn(empfang, HIGH);  //die Variable zeit bekommt nun den Wert
//von Pin8 zugewiesen

entfernung = (zeit / 2) * 0.03432;  //da der Sender eine gewisse Strecke
// in einer gewissen Zeit zuruecklegt, muessen wir nun auf cm umrechnen
//und weisen diesen Wert dann der Variablen entfernung zu

if (entfernung > 5)  //wenn entfernung groesser als 5 ist, dann soll...
{
delay(1000);  //1sec warten, verzoegern, bis der naechste Schritt kommt
digitalWrite(lampe, HIGH);  //jetzt gibt der Pin12 Strom aus
}
else  //ist der Abstand kleiner 5cm, dann fuehre folgendes aus
{
digitalWrite(lampe, LOW);  //Pin12 kein Strom schalten
}
}

Nun sollte die LED also leuchten, wenn ein Gegenstand weiter als 5cm vom Sensor entfernt ist.
Im Code ist eine Verzögerung von 1sec eingebunden, die ich für meine Zwecke brauche. Es geht mir dabei um eine Flaschenablage, damit das Kondenswasser nicht auf mein Laminat läuft. Und weil ich nachts das Tuch nicht sehen kann, wo die Flasche drauf steht, drucke ich mir eine Ablage, wo später die Flasche abgestellt wird. Nehme ich die Flasche, dann wird mit Verzögerung das Licht eingeschaltet. Stelle ich sie wieder zurück, weil ich ja sehen kann wohin sie muß, dann geht das Licht wieder aus.

Der Beitrag Ultraschall-Sensor erschien zuerst auf Druckerbude.com.

Um die Programme aufzuspielen, nutze ich bisher einen Arduino Nano. Später werde ich auch mal einen UNO oder einen Adapter, den ich schon liegen habe, anschließen.

Da das Überspielen mit dem Nano sehr gut funktioniert und der Nano selbst für schmales Geld erhältlich ist, ist er momentan meine erste Wahl.

Die LED brauchen wir, weil wir damit den richtigen Anschluss testen.
Im Grunde ist das eine Art „Hallo Welt“, wenn man das Programmieren lernt.

Den Kondensator brauchen wir, damit der Stromfluss stabilisiert wird – sowas in der Art.
Und ja, ich habe ihn tatsächlich gebraucht. Dauerhaft stecken lassen ging nicht, und gar nicht einbauen ging auch nicht.

Rechte Seite vom Arduino:

• Arduino D13 → Tiny 7
• Arduino 5V → Steckbrett Plusversorgung
• Arduino RST → Kondensator +Pol, der -Pol an Steckbrett Minusversorgung
• Arduino GND → Steckbrett Minusversorgung

Linke Seite vom Arduino:

• Arduino D12 → Tiny 6
• Arduino D11 → Tiny 5
• Arduino D10 → Tiny 1

Nur am Tiny:

• Tiny 4 → Steckbrett Minusversorgung
• Tiny 8 → Steckbrett Plusversorgung
• Tiny 3 → LED Pluspol
• LED Minuspol mit Widerstand → Steckbrett Minusversorgung

Zur Arduino IDE.

Das Programm Arduino IDE starten.
Wir brauchen noch eine zusätzliche Datei, die wir einbinden müssen.
Dazu folgende Schritte:
Auf Einstellungen gehen und in dem Fenster ganz unten bei Zusätzliche Boardverwalter URLs folgenden Link eintragen:
https://raw.githubusercontent.com/damellis/attiny/ide-1.6.x-boards-manager/package_damellis_attiny_index.json

Alles mit OK bestätigen.
Dann folgendes, die Erweiterung installieren.
Auf dem Bild ist alles zu sehen, was wichtig ist.

Wenn du das alles soweit hast, kannst du die Anleitung nutzen. Entweder hier lesen
oder auch runterladen.

Dokument anzeigen oder herunterladen

Zur Teileliste für dieses Vorhanben

brew install arduino-cli

Der Beitrag ATTiny bespielen erschien zuerst auf Druckerbude.com.

Das lange Bein einer LED ist der Pluspol (Anode), das kurze Bein ist der Minuspol (Kathode).

Wir rechnen für jede LED mit einer Durchlassspannung von 1,9 V.
Bei 4 LEDs in Reihe addieren sich die Spannungen:

4 × 1,9 V = 7,6 V Spannungsabfall

Die 9-Volt-Batterie hat noch folgende Restspannung für den Widerstand übrig:

9 V – 7,6 V = 1,4 V

Der benötigte Widerstand bei einem gewünschten Strom von 0,02 A (20 mA):

1,4 V ÷ 0,02 A = 70 Ω

Die Verlustleistung des Widerstands:

(0,02 A)² × 70 Ω = 0,028 W

Ein handelsüblicher Widerstand mit 70 Ω und 0,25 W Belastbarkeit wäre hier ausreichend.

Jetzt hat unsere Batterie je nach Herstellungsmaterial eine Kapazität zwischen 150 mAh und 1200 mAh.
Nehmen wir 800 mAh als realistischen Wert für eine durchschnittliche Batterie.

Jede LED verbraucht 20 mA. Wir haben 4 Stück, also:
4 x 20 mA = 80 mA Verbrauch.

Unsere Batterie hat 800 mAh:
800 mAh : 80 mA = 10h Laufzeit

Wir sehen aber auch:
Eine 5. LED würde jetzt nicht mehr funktionieren, da wir nur noch 1,4 V übrig hätten – und das reicht nicht aus.

Deshalb müssen wir auf die Parallelschaltung wechseln.

Parallelschaltung von LEDs – Berechnung des Widerstands

Bei der Parallelschaltung versorgen wir den ganzen Strang mit 9 V.
Das heißt, die rote Leitung ist durchgehend mit 9 V versorgt, und die schwarze Leitung liegt auf 0 V.

Wir erinnern uns:
Bei der Reihenschaltung war der Ausgang einer LED (Minuspol) der Eingang (Pluspol) der folgenden LED.

Entsprechend haben wir hier aber nur einen Spannungsabfall von 1,9 V pro LED, mit dem wir rechnen müssen:

9 V Batterie – 1,9 V Spannungsabfall = 7,1 V

Der benötigte Widerstand bei einem gewünschten Strom von 0,02 A (20 mA):

7,1 V ÷ 0,02 A = 355 Ω

Die Verlustleistung des Widerstands: P = I² x R

(0,02 A)² × 355 Ω = 0,142 W

Ein handelsüblicher Widerstand mit 360 Ω und 0,25 W Belastbarkeit wäre hier ausreichend.

Hinweis: Dieser Widerstand muss vor jeder LED sitzen.

Warum jede LED ein eigener Widerstand?
In einer Parallelschaltung teilt sich der Strom auf die einzelnen LEDs auf. Ohne eigenen Widerstand könnte eine LED mehr Strom ziehen als die andere und dadurch überlastet werden oder schneller durchbrennen.
Mit einem Widerstand pro LED stellen wir sicher, dass jede LED genau den richtigen Strom bekommt.

Der Beitrag Reihe vs. Parallelschaltung erschien zuerst auf Druckerbude.com.

Low-Power und High-Power hängen mit der Kommunikation der Geräte zusammen – also wie viel Strom angefordert wird. Bei LEDs ist das meist nebensächlich.

LED-Strip = 3-poliger JSA-SM-Anschlussstecker (schwarz mit Rastnase)

LED-Infos für das Netzteil

Einfarbige LEDs

Stromstärke einer LED meist 20 mA (0,02 A) – gilt für LEDs mit nur einer Farbe.

Lichtleisten – LED-Strips

Grundformeln

Beispielrechnung (Reihenschaltung)

• LED-Spannungsabfall (Mittelwert): 1,9 V
• Stromstärke: 0,02 A (20 mA)
• Batteriespannung: 9 V

Berechnung Widerstand:
7,1 V (Restspannung) ÷ 0,02 A = 355 Ω

Leistung Widerstand:
0,02² × 355 Ω = 0,142 W

Batterie-Daten

Verdeutlichung

Beispiel: 3 × WS2812B-LED (je 60 mA) → 0,18 A Gesamtstrom
Leistung: 5 V × 0,18 A = 0,9 W

Ein 1A Netzteil reicht locker. Theoretisch bis zu 16 LEDs möglich – in der Praxis lieber Reserve einplanen.

Netzteil-Anforderung:

• 5 V
• mind. 1 A
• mind. 1 W

Mehr Ampere/Watt sind unproblematisch – Spannung darf nicht über 5 V liegen (außer mit passenden Vorwiderständen).

Batteriebetrieb

3 × 1,5 V = 4,5 V → ausreichend für WS2812B
4,5 V × 0,06 A = 0,27 W pro LED
× 3 LEDs = 0,81 W pro Stunde

Mit 2500 mAh-AA-Batterien → ca. 833 Minuten bzw. 13,8 Stunden Dauerbetrieb.

USB-Betrieb

USB liefert nur begrenzten Strom.
Ältere Netzteile sind oft zu schwach und überhitzen leicht.
Daher: Immer Angaben prüfen und lieber größeres Netzteil verwenden (Ampere/Watt) – aber die Volt beachten!

Die Tabelle oben zeigt die maximal mögliche Versorgung der jeweiligen USB-Typen.

Der Beitrag Grundlagen erschien zuerst auf Druckerbude.com.