Unterrichts- und Lernmaterial für Mikrocontroller
Unterrichts- und Lernmaterial fürMikrocontroller

1 - Drucktaster

In dieser Übung werden ein Taster und eine LED eingesetzt. Sobald der Taster gedrückt wird, soll die LED angehen und ausgehen, wenn der Taster losgelassen wird.

Drucktaster und LED
Material
  • 1x  Steckbrett
  • 1x  Raspi 2 mit Internetzugang
  • 1x  kabellose Maus, Tastatur
  • 1x  HDMI-Kabel
  • 1x  Schaltnetzteil
  • 2x  Widerstand, 470Ohm
  • 1x  Widerstand, 10kOhm
  • 1x  LED, rot
  • diverse Steckdrähte
Aufgaben
  • Achte darauf, dass der Raspi nicht mit dem Netz verbunden ist.
  • Baue die Schaltung nach Abb. 1 auf dem Steckbrett auf.
  • Verbinde das Steckernetzteil des Raspi mit der Steckdose und warte, bis der Rechner gebootet ist und die grafische Benutzeroberfläche erscheint.
  • Starte über Menü - Entwicklung - Python 2 (IDLE) die Entwicklungsumgebung Python 2 und öffne anschließend mit File - New File eine neue Editoroberfläche.
  • Übertrage das Programm led_taster_pc4.py in den Editor.
  • Starte das Programm led_taster_pc4.py mit dem Befehl Run - Run Module (F5) aus dem Hauptmenü.
  • Überprüfe, ob die LED angeht, sobald der Taster gedrückt wird und erlischt, wenn der Taster losgelassen wird.
  • Beende deine Arbeit mit dem Raspi immer über Menu - Shutdown ...  und warte ca. zwei Minuten, bis der Rechner heruntergefahren ist. Ziehe anschließend den Netzstecker des Steckernetzteiles.

Schaltskizze und Schaltungsaufbau

Abbildung 1 - Schaltskizze zur Übung mit Taster und LED. Der 10kOhm Pull-Down-Widerstand definiert das Potential an P13, wenn der Taster offen ist; es wird auf GND gezogen. Sobald der Taster geschlossen ist, liegen ca. 3,3V am Eingang.
Abbildung 2 - Schaltungsaufbau und Schaltskizze zur Übung mit Taster und LED.

Das Programm led_taster_pc4.py

Abbildung 3 - Programm led_taster1.py. Die LED ist mit P7, der Taster T1 mit P13 über einen Pull-down-Widerstand verbunden.

Wie arbeitet das Programm led_taster1.py?

Nachdem die Bibliothek RPi.GPIO und die Funktion sleep aus time eingebunden wurden, wird der Zugriff auf die I/O Ports in den Modus BOARD (Pinbezeichnung) und P7 auf Ausgang und P13 auf Eingang gesetzt. An P7 ist eine LED und an P13 ein Taster angeschlossen (Abb. 1).

In der sich anschließenden Endlosschleife wird die Taste bei jedem Durchlauf darauf abgefragt, ob sie gedrückt ist; der sich dabei ergebende Wert (True oder False) wird der Variablen Taster zugewiesen.

Ist das der Fall (Wenn taster == True ist), dann liegt am Eingang von P13 eine 1 und an den Ausgang von P7 wird eine 1 (HIGH) gelegt; die LED an P7 beginnt zu leuchten. Ist der Taster nicht gedrückt (else), wird die LED an P7 ausgeschaltet.

Die mit while True eingeleitete Endlosschleife enthält keine Ausstiegsoption; der abschließende Befehl io.cleanup() hat damit keine Bedeutung für den Programmablauf. Wird das Programm über Strg-C abgebrochen und anschließend neu gestartet, erscheint nach dem Start des lauffähigen Programms trotzdem eine Fehlermeldung, die den Nutzer darauf hinweist, dass bestimmte Kanäle (Ports) bereits benutzt werden.

Pollen - Die Methode, einen Taster während des Programmablaufs ständig abzufragen, nennt man auch pollen.

2 - Umschalter

Umschalter
Material
  • 1x  Steckbrett (optional mit Pi-Cobbler)
  • 1x  Raspi 2 mit Internetzugang
  • 1x  kabellose Maus, Tastatur
  • 1x  HDMI-Kabel
  • 1x  Schaltnetzteil
  • 2x  Widerstand, 470Ohm
  • 1x  Widerstand, 10kOhm
  • 1x  LED, rot
  • diverse Steckdrähte
Aufgaben
  • Achte darauf, dass der Raspi nicht mit dem Netz verbunden ist.
  • Baue die Schaltung nach Abb. 1 auf dem Steckbrett auf.
  • Verbinde das Steckernetzteil des Raspi mit der Steckdose und warte, bis der Rechner gebootet ist und die grafische Benutzeroberfläche erscheint.
  • Starte über Menü - Entwicklung - Python 2 (IDLE) die Entwicklungsumgebung Python 2 und öffne anschließend mit File - New File eine neue Editoroberfläche.
  • Übertrage das Programm led_umschalter_pc5.py in den Editor.
  • Starte das Programm led_umschalter_pc5.py mit dem Befehl Run - Run Module (F5) aus dem Hauptmenü.
  • Überprüfe, ob die LED so reagiert wie besprochen; wechselt sie bei jedem Tastendruck ihren Zustand?
  • Beende deine Arbeit mit dem Raspi immer über Menu - Shutdown ...  und warte ca. zwei Minuten, bis der Rechner heruntergefahren ist. Ziehe anschließend den Netzstecker des Steckernetzteiles.

Schaltskizze und Schaltungsaufbau

wie in Übung 1 - Taster abfragen

-------------------------------------------------------------------------------------

 

Das Programm led_umschalter_pc5.py

Abbildung 4 - Programm led_umschalter_pc5.py

Wie arbeitet das Programm led_umschalter_pc5.py?

Bis zur Endlosschleife while True wiederholen sich die Programmzeilen aus dem vorherigen Programm der Übung 1, mit dem einzigen Unterschied, dass diesmal noch eine Variable led initialisiert wird. Sie setzt den Zustand der LED zum Programmstart fest.

In der Endlosschleife wird der Zustand am Eingang P13 abgefragt. Nach einer Pause von 10ms wird im Entscheidungsblock (IF ...) geprüft, ob die Taste gedrückt wurde. Wenn ja, dann wird die binäre Variable led (entweder 0 oder 1) invertiert; dies geschieht mit dem vorangestellten Symbol der Tilde (~). Anschließend wird der Ausgang P7, mit dem die LED verbunden ist, je nach Zustand der Variablen led, auf LOW oder HIGH gesetzt.

 

Das praktische Ergebnis ist nicht befriedigend. Man wird feststellen, dass die LED nicht sauber auf den Tastendruck reagiert. Mal geht sie bei jedem Tastendruck entweder an oder aus, mal geht sie mit einem Tastendruck an und wieder aus und ein anderes mal reagiert sie überhaupt nicht auf den Tastendruck. Die Ursache dafür lässt sich mit dem Stichwort Prellen eines Schalters umschreiben und wird im folgenden Abschnitt weiter untersucht.

3 - Taster entprellen

Ein Taster lässt sich auf zwei verschiedene Weisen entprellen: entweder geschieht dies durch Einsatz von Hardware (Kondensatoren und ggf. Widerständen oder durch Flip-Flops) oder Software.

Die Hardwarelösung ist aufwändiger und in der Regel kostenanfälliger als eine Softwarelösung, deshalb entscheiden wir uns für letztere.

Python stellt in seiner RPi.GPIO-Bibliothek Funktionen bereit, mit denen sich das Problem gut erledigen lässt. Wir stellen zwei vor.

  • wait_for_edge(<pin;BCM>, <RISING;FALLING;BOTH>, <opt.: bouncetime  in ms>)
  • Rückgabewert: pin oder BCM Nummer
  • wartet auf einen Flankenwechsel am Eingangspin pin bzw. BCM. Drei Möglichkeiten stehen zur Auswahl:

 

 

steigende Flanke

 

 

fallende Flanke

 

 

steigende und fallende Flanke

Optional kann mit bouncetime eine Verzögerungszeit in ms eingestellt werden.

 

Mit dem elektronischen Schaltungsaufbau aus Abschnitt 2 wird ein neues Programm entwickelt, das sich dieser Funktion bedient und zum Beispiel auf die steigende Flanke reagiert.

Schaltungsaufbau

Tasterverhalten unter der Funktion wait_for_edge
Aufgaben
  • Übertrage das Programm wait_for_edge.py in den Python Editor und speichere das Programm ab.
  • Starte das Programm und überprüfe, ob und wie der Taster und die LED auf Tastendruck reagieren.
  • Verändere die Flankenabfrage, indem du io.RISING durch io.FALLING bzw. io.BOTH austauschst.
  • Wie reagiert das Programm jetzt? Mache dir klar, warum die Schaltung anders reagiert. Ändere ggf. den Programmcode so ab, dass die LED bei jedem Tastendruck ein- bzw. ausschaltet.
  • Verändere auch die Verzögerungszeit und beobachte, ob sich Veränderungen im Ansprechverhalten des Tasters ergeben.

Das Programm zur wait_for_edge Funktion

Abbildung 5 - Programm wait_for_edge.py. Das Programm reagiert auf eine Flankenänderung am Eingang.

Eine praktische Überprüfung an der Schaltung zeigt, dass Taster und LED sauber auf jeden Tastendruck reagieren.

 

---------------------------------------------------------------------------------------------------------

 

Eine zweite Funktion ist

  • add_event_detect(<pin oder BCM>, <RISING;FALLING;BOTH>; callback=<name>, <optional: bouncetime in ms>)

Diese Interrupt-Funktion reagiert, sobald eine Taste am I/O Port pin oder BCM gedrückt wird auf eine steigende oder fallende Flanke oder auf beide und führt das aus, was in einer callback-Funktion name hinterlegt ist. Optional kann auch hier eine Verzögerungszeit über bouncetime eingestellt werden.

Das Programm zur add_event_detect  Funktion

Abbildung 6 - Programm add_event_detect.py reagiert mit einer Interrupt-Routine auf einen Tastendruck.

Wie arbeitet das Programm add_event_detect?

Nach dem Import der beiden Bibliotheken RPi.GPIO und time wird eine Funktion schalter definiert. In ihr wird abgefragt, ob am Eingang von P13 (Taster) eine 0 oder 1 anliegen. Liegt eine 1 an (d. h. der Taster wurde gedrückt), dann wird der Zustand der Led über die Variable led invertiert (led = ~led). Wird kein Taster gedrückt, passiert nichts. Die im Hauptprogramm benutzte Variable led muss in der Funktion global definiert werden, sonst gibt es eine Fehlermeldung.

Im Hauptprogramm ist nur der Funktionsaufruf der add_event_detect-Funktion neu. Diese Funktion arbeitet im Hintergrund und unterbricht das laufende Programm, sobald am Eingang von P13 (Taster) der Spannungspegel sich von 0 auf 1 ändert (steigende Flanke). Ist das der Fall, wird die bei callback angegebene Funktion (hier: schalter) ausgeführt und anschließend ins Hauptprogramm zurückgekehrt.

Der praktische Test zeigt, dass Taster und LED ohne Fehlfunktionen sauber arbeiten.

Das Programm add_event_detect.py reagiert zwar auf den Taster, aber bei einem Programmabbruch über Strg-C bleiben die getroffenen Einstellungen erhalten, und es gibt Fehlermeldungen unter Python, wenn neue Programme gestartet werden bis hin zu fehlerhaftem Verhalten des Programms, auch wenn keine syntaktischen Fehler gemacht wurden. Wie man das behebt, zeigt Abschnitt 4.

4 - Ein Reaktionszeitmesser

Der Reaktionszeitmesser arbeitet mit einer Duo-LED, die, sobald man das System per Tastendruck aktiviert, die LED auf rot schaltet; die Taste soll weiterhin gedrückt bleiben. Nach einer gewissen Zeit springt die LED auf grün um. So schnell wie möglich sollte man jetzt die Taste loslassen. Gemessen wird die Reaktionszeit und im Terminal angezeigt.

Schaltungsaufbau und Schaltskizze

Abbildung 7 - Schaltungsaufbau mit Taster und Duo-LED für einen Reaktionszeitmesser
Abbildung 8 - Schaltskizze mit Duo-LED und Taster für einen Reaktionstester

Strategie für den Programmaufbau

Der schematische Programmablauf lässt sich in groben Schritten präzisieren:

  • Initialisierung aller Variablen und GPIOs; die Duo-LED leuchtet grün.
  • Sobald der Taster gedrückt wird, initialisiert eine Interrupt-Service-Routine (ISR) oder auch Callback.
  • Die ISR sorgt dafür, dass die Duo-LED auf rot schaltet.
  • Die ISR sorgt dafür, dass nach einer gewissen Zeit die Duo-LED grün anzeigt.
  • Die ISR startet die Zeitmessung.
  • Die ISR stoppt die Zeitmessung.
  • Die ISR gibt die Zeitdifferenz im Terminal aus.

Programmaufbau

Fangen wir mit dem Programmaufbau an. Aus Gründen der Übersichtlichkeit und Lesbarkeit sollte  eine bestimmte Struktur bei einem Pythonprogramm eingehalten werden (Abb. 9).

Abbildung 9 - Formaler strukturierter Aufbau eines Python-Programms

Neu ist hier, dass im Hauptprogramm ein try - except-Block auftaucht. Wenn im Versuchsblock (try) ein Fehler auftaucht, dann wird er über den except-Block abgefangen oder der Nutzer wird über einen  Fehler informiert .

Im vorliegenden Fall enthält der try-Block eine Endlosschleife, in der nichts passiert (pass). Das vorliegende Programm würde immer weiter laufen, wenn es nicht - wie im except-Block benannt - durch Strg-C beendet würde. Nur ein Keyboard-Interrupt bricht das Programm ab; anschließend wird aufgeräumt. Das heißt, alle Verbindungen werden zurückgesetzt (io.cleanup) und zum Abschied erscheint im Terminal der Text "moin, moin ...".

Initialisierung der GPIOs und Variablen, Eingabe eines Kommentars

Nach Vorgabe der Schaltskizze werden die Pin 7, 11 und 13 von Schaltelementen belegt. P7 und P11 für eine Duo-LED (Ausgänge) und P13 für einen Taster (Eingang). Es wird die Pinbezeichnung benutzt. Soweit schon erkennbar, werden keine Variablen eingesetzt und als Kommentar wird etwas über den Zeitmesser stehen müssen (Abb. 10).

Abbildung 10 - Initialisierung der GPIOs, der Variablen und Eingabe eines Kommentars

Die Callback-Funktion

Sobald der Taster gedrückt wird, soll ein Interrupt ausgelöst werden. Dazu stehen verschiedene Funktionen unter Python zur Verfügung. Wir arbeiten mit der Funktion add_event_detect.

  • add_event_detect(pin, <FALLING;RISING;BOTH>,callback=<name>,opt. bouncetime=<ms>)

Parameter

pin                   Anschlusspin, über den das Signal ausgewertet wird

FALLING        die Funktion reagiert auf eine fallende Flanke

RISING           die Funktion reagiert auf eine steigende Flanke

BOTH             die Funktion reagiert auf die steigende und fallende Flanke

callback           benennt die aufzurufende Funktion <name>, die bei einem IR aktiv wird

bouncetime     Verzögerungszeit; die Variable ms gibt die Zeit in Millisekunden an

 

Das Programm aus Abb. 10 wird so erweitert, dass im Hauptprogramm die Duo-LED abgeschaltet wird und die Callback-Funktion Taster auf Tastendruck so reagiert, dass sie mit steigender Flanke am Pineingang die LED auf rot schaltet.

Abbildung 11 - Die Reaktion der Duo-LED auf die verschiedenen Flankenformen werden sichtbar gemacht.
  • Startet man das Programm, bleibt die Duo-LED dunkel. Mit dem ersten Tastendruck schaltet sie auf rot. Weitere Tastendrücke ergeben keine Veränderungen - nur manchmal. Wenn die LED auf grün schalten sollte (Tastenpreller), erhöhe den Wert von bouncetime auf 200.
  • Ändert man in der Funktion add_event_detect die Flankensensibilität von RISING auf FALLING, dann reagiert der Taster und die angeschlossene LED erst mit dem Loslassen des Taster und sie zeigt grün. Probiere es aus.
  • Bei BOTH schaltet die Duo-LED mit jedem Tastendruck um. Drückt man auf den Taster, leuchtet sie rot, lässt man ihn wieder los, grün. Probiere auch dies aus.

Die Zeitmessung

Die Zeitmessung erfolgt über die IR-Routine mit der Funktion time(). Sobald die Duo-LED auf grün umschaltet (IR bei steigender Flanke), wird der Wert der Zeitmarke in einer Variablen ta abgelegt. Sobald der Taster losgelassen wird (IR bei fallender Flanke) , wird die zweite Zeitmarke in einer zweiten Variablen te abgelegt. Aus der Differenz beider ergibt sich die Reaktionszeit. Das komplette Reaktionszeitprogramm zeigt Abb. 12.

Programm Reaktionszeit.py

Abbildung 12 - Programm zur Reaktionszeitmessung mit Interrupt-Routine
Abbildung 13 - Terminalausgabe der Reaktionszeit

Kommentar schreiben

Kommentare

  • olaf (Sonntag, 10. Dezember 2017 08:35)

    wow...die mit Abstand beste Site, die ich bisher zu diesem Thema gesehen habe :-))
    Vielen Dank dafür. Hilft super beim Erklären!!

  • David Eisenblätter (Sonntag, 11. Februar 2018 13:38)

    Sehr schön erklärt, und zufällig heute, wo ich nochmal nach einer detailierten Gedankenstütze diesbezüglich gesucht habe!

    Vielen vielen Dank!

    David.

Bitte geben Sie den Code ein
* Pflichtfelder
Druckversion Druckversion | Sitemap
© Reinhard Rahner - Gettorf