Erik Bartmann - Mit Arduino die elektronische Welt entdecken

Die PWM-Ansteuerung

Kommen wir zur Ansteuerung einer LED über PWM. Was das ist, habe ich kurz in Kapitel 1erwähnt. Nun ist es an der Zeit, es in die Tat umzusetzen. Wir wollen eine LED über eine analoge Ansteuerung langsam aufblenden und sie beim Erreichen des Maximalwertes schlagartig verlöschen lassen, bevor das Spiel von vorne beginnt. Dabei handelt es sich quasi um ein sanftes Blinken im Gegensatz zum abrupten Blinken in der vorherigen Schaltung. Die Ansteuerung erfolgt dabei über die digitalen Pins, die eine Tilde vor der Nummerierung besitzen. Das sind die Pins D3, D5, D6, D9, D10 und D11. Für unser Beispiel habe ich Pin 3 verwendet. Der Sketch-Code sieht folgendermaßen aus:

int ledPin = 3; // Variable mit Pin 3 deklarieren + initialisieren int pwmValue = 0; // Variable für PWM deklarieren + initialisieren void setup() { /* Kein Code erforderlich */ } void loop() { analogWrite(ledPin, pwmValue++); // LED mit PWM-Wert ansteuern delay(10); // Kurze Pause if(pwmValue > 255) pwmValue = 0; // Wenn PWM-Wert > 255 -> // auf 0 setzen }

Zu Beginn deklarieren und initialisieren wir zwei globale Variablen, die die Namen ledPin und pwmValue aufweisen und vom ganzzahligen Datentyp int (int = Integer) sind. Sehen wir uns den Befehl analogWrite genauer an.

Er nimmt zwei Argumente auf, wobei das erste den Pin bestimmt und das zweite den PWM-Wert, der sich im Bereich von 0 bis 255 bewegen darf. Über

pwmValue++

wird die Variable pwmValue nach der Verwendung über die beiden nachfolgenden Pluszeichen um den Wert 1 erhöht. Dieser Vorgang wird in der Programmierung Inkrementieren genannt. Konventionell würde man das gleiche Verhalten mit der folgenden zusätzlichen Codezeile erreichen:

pwmValue = pwmValue + 1;

Würden wir das Inkrementieren der Variablen pwmValue ohne nachfolgende Überwachung in der loop -Endlosschleife laufen lassen, wäre irgendwann ein unzulässiger Wert größer 255 erreicht. Um das zu verhindern, erfolgt über die if -Anweisung eine Abfrage auf Werte größer 255. Wird diese Bewertung positiv beantwortet, erfolgt die Ausführung des nachfolgenden Befehls:

pwmValue = 0;

Darüber erfolgt eine Rücksetzung auf den Anfangswert 0, was zur Folge hat, dass die LED beim nächsten Aufruf des analogWrite -Befehls erlischt. Ändern wir doch den Code derart ab, dass die LED nicht schlagartig erlischt, sondern langsam abblendet.

Für die PWM-Ansteuerung eines digitalen Pins mit dem analogWrite -Befehl ist keine vorherige Programmierung über den pinMode -Befehl erforderlich, um diesen als Ausgang festzulegen. Wir sehen, dass die setup -Funktion keinen derartigen Befehl enthält und komplett frei von Code ist.

Weitere Informationen zu PWM sind unter der folgenden Adresse zu finden:

http://www.arduino.cc/en/Tutorial/PWM

https://www.arduino.cc/en/Reference/AnalogWrite

Wir haben gesehen, wie man mit ein paar Codezeilen eine LED blinken lässt. Es geht jedoch noch ein wenig kürzer:

int ledPin = 13; // Variable mit Pin 13 deklarieren + initialisieren void setup() { pinMode(ledPin, OUTPUT); // Digitaler Pin 13 als Ausgang } void loop() { digitalWrite(ledPin, !digitalRead(ledPin)); // Toggeln der LED delay(1000); // Eine Sekunde warten }

Die entscheidende Zeile lautet:

digitalWrite(ledPin, !digitalRead(ledPin));

Wir nutzen an dieser Stelle zwei neue Konstrukte. Da ist zum einen der Befehl zum Ermitteln des Status eines digitalen Pins über digitalRead .

Außerdem nutzen wir den sogenannten NOT-Operator‌ mithilfe des Ausrufezeichen‌s (!‌), der dazu verwendet wird, ein Ergebnis in das Gegenteil zu verkehren. In der Programmiersprache C/C++ existiert kein eigener Datentyp für logische Werte wie wahr oder falsch und deshalb wird ein Wert vom Datentyp int verwendet. Wir haben in der Tabelle 2 über die Konstanten gesehen, dass ein LOW-Pegel den Wert 0 und ein HIGH-Pegel den Wert 1 besitzt. Über den NOT-Operator wird zwischen beiden hin- und hergewechselt, was auch Togge‌ln genannt wird. Hinweise zu booleschen Operatoren sind unter dem folgenden Link zu finden:

https://www.arduino.cc/en/Reference/Boolean

Wenn du weiter in die Thematik der Widerstände eintauchen möchtest, dann rate ich dir einen Blick in mein Buch Elektronik verstehen durch spannende Experimente – Analog- und Digitaltechnik , ISBN 978-3-946496-23-6. Dort werden unter anderem Reihenschaltungen, Parallelschaltungen und Gemischtschaltungen von Widerständen angesprochen und detailliert erklärt.

Du hast die korrekte Deklaration und die korrekte Initialisierung einer globalen Variable kennen gelernt.

Es wurde die grundlegende Sketch-Struktur vermittelt.

Die Datenübertragungsrichtung eines einzelnen Pins hast du mit dem Befehl pinMode auf OUTPUT gesetzt, so dass du ein digitales Signal (HIGH bzw. LOW) über den Befehl digitalWrite zum Ausgang schicken konntest, an der die LED angeklemmt war.

Über den Befehl delay hast du eine zeitliche Unterbrechung des Sketches eingeleitet, damit die LED eine bestimmte Zeit an beziehungsweise aus war.

Mithilfe des NOT-Operators in Verbindung mit dem Befehl digitalRead haben wir eine verkürzte Variante des Codes für das Blinken der LED kennengelernt.

Wenn man eine LED betreiben möchte, ist ein entsprechend dimensionierter Widerstand – auch Vorwiderstand genannt – unerlässlich.

Wir haben gesehen, wie sich ein Vorwiderstand mit Hilfe des Ohmschen Gesetzes berechnen lässt.

Mithilfe der Farbtabelle ist es sehr einfach, einen Widerstandswert anhand der aufgedruckten Farbringe zu ermitteln.

Wir haben die Ansteuerung einer LED über einen PWM-Pin gesehen.

Ich möchte dir am Ende dieses Projektes die Aufgabe stellen, den Sketch so abzuändern, dass du die Zeit, in der die LED leuchtet beziehungsweise aus ist, in zwei Variablen auslagerst. Darüber kann der sogenannte Tastgrad‌ eingestellt werden. Er beschreibt das Verhältnis von Impulsdauer‌ und Periodendauer‌ . Das Ergebnis wird meist in Prozent angegeben. Auf dem folgenden Impulsdiagramm siehst du die unterschiedlichen Zeiten für t bzw. T :

Abb. 8:Der Verlauf des Pegels am digitalen Ausgang Pin 13 bei einem Tastgrad von 25%

t = Impulsdauer

T = Periodendauer

Die Formel zur Berechnung des Tastgrades lautet: