Mikrocontroller-Praxiskurs für Arduino-Einsteiger (Leseprobe)

Page 1

Mikrocontroller-Praxiskurs für Arduino-Einsteiger mit dem neuen Elektor Arduino Nano Trainingsboard MCCAB Einführung in die Grundlagen der Hard- und Software mit vielen praktischen Beispielen www.elektor.de/20293 (Buch) www.elektor.de/20295 (Board)

Alle Rechte vorbehalten.

Die in diesem Buch veröffentlichten Beiträge, insbesondere alle Aufsätze und Artikel sowie alle Entwürfe, Pläne, Zeichnungen und Illustrationen sind urheberrechtlich geschützt. Ihre auch auszugsweise Vervielfältigung und Verbreitung ist grundsätzlich nur mit vorheriger schriftlicher Zustimmung des Herausgebers gestattet.

Die Informationen im vorliegenden Buch werden ohne Rücksicht auf einen eventuellen Patentschutz veröffentlicht. Die in diesem Buch erwähnten Soft- und Hardwarebezeichnungen können auch dann eingetragene Warenzeichen sein, wenn darauf nicht besonders hingewiesen wird. Sie gehören dem jeweiligen Warenzeicheninhaber und unterliegen gesetzlichen Bestimmungen.

Bei der Zusammenstellung von Texten und Abbildungen wurde mit größter Sorgfalt vorgegangen. Trotzdem können Fehler nicht vollständig ausgeschlossen werden. Verlag, Herausgeber und Autor können für fehlerhafte Angaben und deren Folgen weder eine juristische Verantwortung noch irgendeine Haftung übernehmen. Für die Mitteilung eventueller Fehler sind Verlag und Autor dankbar.

● Erklärung

Der Autor und der Herausgeber dieses Buches haben alle Anstrengungen unternommen, um die Richtigkeit der in diesem Buch enthaltenen Informationen sicherzustellen.

Sie übernehmen keine Haftung für Verluste oder Schäden, die durch Fehler oder Auslassungen in diesem Buch verursacht werden, unabhängig davon, ob diese Fehler oder Auslassungen auf Fahrlässigkeit, Unfall oder andere Ursachen zurückzuführen sind.

ISBN 978-3-89576-523-0

(Ebook 978-3-89576-524-7

Umschlaggestaltung: Elektor, Aachen

Satz und Aufmachung: Wolfgang Trampert

Druck: Ipskamp Printing, Enschede, Niederlande

● Elektor-Verlag GmbH, Aachen — www.elektor.de

Elektor ist Teil der Unternehmensgruppe Elektor International Media (EIM), der weltweit wichtigsten Quelle für technische Informationen und Elektronik-Produkte für Ingenieure und Elektronik-Entwickler und für Firmen, die diese Fachleute beschäftigen. Das internationale Team von Elektor entwickelt Tag für Tag hochwertige Inhalte für Entwickler und DIY-Elektroniker, die über verschiedene Medien (Magazine, Videos, digitale Medien sowie Social Media) in zahlreichen Sprachen verbreitet werden.

● © 2023: Elektor Verlag GmbH, Aachen.

V V o orrw w o orrt t

Jeder, der nicht grade als Einsiedler in einer Höhle im Wald haust, hat in der heutigen Zeit Berührung mit Mikrocontrollern. Oft nehmen wir das gar nicht bewusst wahr, aber in die meisten Geräte unseres täglichen Lebens (Mikrowelle, Kaffeeautomat, Smartphone, KFZ, Waschmaschine, Heizungs-, Garagentor- und Aufzugsteuerung … ) ist heute – mindestens – ein Mikrocontroller „eingebettet“, der ihre Steuerung übernimmt. Man spricht hier von einem »Embedded System«. In unserem Mikrocontroller-Praxiskurs für Einsteiger werden wir lernen, wie man auch ohne große Erfahrung in Elektronik und Programmiersprachen eigene Projekte mit einem Mikrocon troller realisieren kann. Beim Googeln im Internet findet man viele Berichte von Leuten, denen es ohne jegliche Vorkenntnisse gelang, mit einem Arduino®-Mikrocontrollerboard z.B. eine automatische Fischfütterungsanlage für ihren Karpfenteich , eine Lichtschranke zur Personenzählung, einen Temperatur- und Feuchtigkeitsregler für ihre Räucherkammer oder ihre Hausbrauerei, einen Alkoholtester oder ein Schneehöhenmessgerät selbst zu entwickeln und zu bauen Für den Modellbauer ist der Mikrocontroller das Universalwerkzeug zum Aufpeppen seine r Modelle. Schülern und ihren Lehrern bietet der Mikrocontroller im Hinblick auf die aktuell besonders intensive Förderung der MINT-Fächer (Mathematik, Informatik, Naturwissenschaft und Technik) in den Sch ulen ein großartiges Mittel zur Umsetzung ihrer Ideen

Bei der Realisierung unserer Projekte hilft uns die Arduino IDE , eine Software -Entwicklungsumgebung, die man kostenlos aus dem Internet auf den eigenen PC herunterladen kann und die das gesamte Softwarepaket enthält, das man für ein eigenes Mikrocontroller -Projekt braucht: Wir schreiben unsere Programme ( „Apps “) mit dem Editor der Arduino IDE auf dem PC , übersetzen sie mit dem in die IDE integrierten Compiler in die Bits und Bytes , die der Mikrocontroller versteht und laden sie über ein USB-Kabel in den Speicher des Mikrocontrollers. Zur Erstellung unserer Programme müssen wir das relativ komplizierte Innenleben eines Mikrocontrollers gar nicht kennen, denn das »Arduino-Konzept« unterstützt uns durch viele kostenlos verfügbare Bibliotheken (Libraries , eine Art „App Store“) bei der Steuerung der internen Bausteine des Mikrocontrollers. Diese Libraries ent halten quasi fertige „Software-Pakete“ sogenannte Functions , die wir wie eine »Black Box« in unsere Programme einbinden können.

Realisieren werden wir unsere Projekte auf dem MCCAB Trainingsboard, einer Leiterplatte , die über ein USB-Kabel mit dem PC verbunden ist und die neben einem Arduino®-Mikrocontrollermodul alle für unsere Übungen benötigten Bauteile wie Leuchtdioden, Schalter, Taster, akustische Signalgeber etc. enthält. Auch externe Sensoren, Motoren oder Baugruppen können mit unserem Mikroc ontroller-Übungssystem abgefragt oder gesteuert werden.

Der Schwerpunkt des Kurses liegt auf den praktischen Übungen, denn wir werden uns die erforderlichen Kenntnisse durch „Learning by Doing“ aneignen. Ganz ohne Theorie geht es allerdings nicht, deshalb finden wir im vorderen Teil des Buches die nötigen Grundlagen der Hard - und Software eines Mikrocontrollersystems. Doch dann folgt auch schon der umfangreiche praktische Teil, der zuerst noch recht einfach gehalten ist . Mit jeder weiteren Übung kommen jedoch neue Hard- und Software-Komponenten hinzu, die jeweils ausführlich erklärt werden. So erhält der Einsteiger Schritt für Schritt einen stetig zunehmenden Kenntnisstand der vielfältigen Möglichkeiten, die ein Mikrocontroller bietet.

Wie soll man nun dieses Buch verwenden? Ein absoluter Neuling auf dem Gebiet der Elektronik und der Programmierung sollte dieses Buch von Anfang bis Ende durcharbeiten , um zuerst einen Grundstock an Wissen aufzubauen, bevor er mit dem praktischen Teil des Kurses beginn t Falls man aber bereits über einige Vorkenntnisse verfügt und zu den Leuten gehört, die dazu neigen, ein neues Gerät gleich einzuschalten und damit zu experimentieren und nur im Bedarfsfall auf das entsprechende Kapitel im Theorieteil zurückgreifen möchte, kann man auch mit Kapitel 4 –dem Praxisteil des Buches – starten.

Vorwort 3

Eine weitere Möglichkeit besteht darin, zuerst die zahlreichen Übungen zu bearbeiten. Falls die gestellten Aufgaben problemlos gelöst werden können, kann der entsprechende Abschnitt – zumindest vorläufig – übersprungen werden.

Allerdings sollte jeder Leser in allen Fällen zuerst die Betriebsanleitung des MCCAB Trainingsboards genau studieren (siehe Abschnitt 2.8), bevor er es zum ersten Mal in Betrieb nimmt, um eventuelle Schäden zu vermeiden.

Dem Arduino-Konzept ist es zu verdanken, das s auch Laien eigene Elektronik -Ideen verwirklichen können. Dies ist umso bemerkenswerter, wenn man bedenkt, dass für eine wirklich intensive Behandlung des Themas »Mikrocontroller« fundierte Kenntnisse in Informatik, Programmierung und elektronischer Schaltungstechnik erforderlich sind. Nicht umsonst dauert eine Ausbildung oder ein Studium dieser Fachrichtung mehrere Jahre.

Wir werden mit diesem Arduino-Praxiskurs bereits genügend Wissen aufbauen, um erste Projekte selbst realisieren zu können , denn wir schaffen den Grundstock für ein effizientes Arbeiten mit den faszinierenden Möglichkeiten der Arduino -Welt: Wir lernen die elementaren Grundlagen der Hardware und des Programmierens in der Programmiersprache C kennen.

Wer tiefer einsteigen und mehr zu diesem faszinierende Thema wissen möchte – und das wird jeder, wenn er nach ersten Erfolgserlebnissen einmal „Blut geleckt“ ha t – kann weitermachen mit der demnächst erscheinenden Fortsetzung des Arduino-Praxiskurses (Literaturhinweis [16]), in der es dann ans „Eingemachte“ geht, denn neben einem tieferen Einstieg in die Sprache C werden wir Projekte realisieren, in denen wir z.B. Sensoren abfragen, physikalische Größen messen, den Mikrocontroller auf dem MCCAB Trainingsboard via Bluetooth mit dem Smartphone steuern, sogar ein Mini -Speicheroszilloskop bauen und vieles mehr.

Und nun wünsche ich allen Wissbegierigen viel Erfolg beim Durcharbeiten dieses Buches und be i der Lösung der gestellten Übungsaufgaben.

Wolfgang Trampert

Mikrocontroller-Praxiskurs für Arduino-Einsteiger 4
Inhalt 5 I I n n h h a allt t Vorwort ...................................................................................................................... 3 Inhalt ......................................................................................................................... 5 1 Einführung ........................................................................................................... 8 2 Die Hardware -Grundlagen ................................................................................. 10 2.1 Die elektronische Verarbeitung von Daten und Signalen........................................10 2.1.1 Signalzustände und Zahlenbildung in der Digitaltechnik 12 2.1.2 Datenverarbeitung »digital« statt »analog« ...................................................13 2.2 Was ist ein Mikroprozessor? 14 2.3 Die Bestandteile eines Mikroprozessor -Systems ...................................................15 2.4 Vom Mikroprozessor zum Mikrocontroller ............................................................16 2.5 Die Unterschiede zwischen Mikrocontroller und PC 17 2.6 Die Vorgehensweise beim Einsatz eines Mikrocontrollers .......................................19 2.7 Der Datenverkehr mit der „Außenwelt“ 20 2.7.1 Digitale Ein- / Ausgänge (GPIOs ) .................................................................20 2.7.2 Analoge Ein- / Ausgänge.............................................................................21 2.7.3 Serielle Ein- / Ausgänge 25 2.8 Das MCCAB Trainingsboard ...............................................................................29 3 Die Software -Grundlagen................................................................................... 37 3.1 Zahlensysteme ................................................................................................37 3.1.1 Das Dual- / Binärsystem .............................................................................37 3.1.2 Das Hexadezimalsystem 38 3.1.3 Zahlensysteme in der Programmiersprache C ................................................40 3.2 Die ALU, das „Rechenzentrum“ des Mikrocontrollers .............................................40 3.3 Zeichencodes und Zeichenketten .......................................................................42 3.3.1 Der ASCII-Zeichencode ..............................................................................42 3.3.2 Zeichenketten ( Strings ) 42 3.4 Datentypen, Variablen und Konstanten .............................................................. 43 3.4.1 Der Datentyp void......................................................................................44 3.4.2 Skalare Datentypen ...................................................................................45 3.4.3 Variablen ..................................................................................................47 3.4.4 Zusammengesetzte Datentypen ( Arrays und Structures ) 49 3.4.5 Konstanten ...............................................................................................54 3.4.6 Der Operator »sizeof()« zur Ermittlung der Datengröße ..................................56 3.5 Das Anwenderprogramm ( Sketch) 57 3.6 Die integrierte Entwicklungsumgebung ( Arduino IDE ) ...........................................61 3.6.1 Download und Installation der Arduino IDE 61 3.6.2 Starten der IDE .........................................................................................62 3.6.3 Die Bedienungsoberfläche der IDE ...............................................................62 3.7 Operatoren und Ausdrücke 70 3.7.1 Die arithmetischen Operatoren –, +, *, /, %, ++, ..............................70 3.7.2 Die Vergleichsoperatoren ==, !=, >, >=, <, <= 72 3.7.3 Die logischen Operatoren !, &&, || ............................................................73 3.7.4 Die Operatoren >> und << zur Verschiebung von Bits ...............................74 3.7.5 Die Zuweisungsoperatoren =, +=, –=, *=, /=, %=, <<=, <<=   74 3.7.6 Hierarchie der Operatoren in C ....................................................................75 3.7.7 Übungen zu Abschnitt 3.7 75 3.8 Anweisungen und Blöcke .................................................................................78 3.9 Auswahlanweisungen .......................................................................................78 3.9.1 Die bedingte Anweisung  (if … else … ) 78 3.9.2 Die Mehrfachauswahl (switch – case) ..........................................................80
Mikrocontroller-Praxiskurs für Arduino-Einsteiger 6 3.9.3 Übungen zu Abschnitt 3.9 ...........................................................................81 3.10 Schleifen 83 3.10.1 Die for-Schleife .........................................................................................84 3.10.2 Die while -Schleife 86 3.10.3 Die do–while-Schleife .................................................................................87 3.10.4 Die »break«-Anweisung zum vorzeitigen Verlassen einer Schleife ....................88 3.10.5 Übungen zu Abschnitt 3.10 89 3.11 Functions ........................................................................................................92 3.11.1 Deklaration einer Function 93 3.11.2 Definition einer Function .............................................................................94 3.11.3 Aufruf einer Function ..................................................................................94 3.11.4 Interrupt-Functions 95 3.11.5 Methoden - die Functions von Objektvariablen in der Sprache C++ ..................96 3.11.6 Übungen zu Abschnitt 3.11 .........................................................................97 3.12 Die wichtigsten Arduino-Functions......................................................................99 3.12.1 Function setup() zur Initialisierung............................................................. 100 3.12.2 Function loop(), die Endlosschleife 100 3.12.3 pinMode() zur Konfiguration der digitalen Ein- und Ausgänge ........................ 100 3.12.4 digitalRead() zum Einlesen eines digitalen Eingangssignals ........................... 101 3.12.5 digitalWrite() zur Ausgabe eines digitalen Signals ........................................ 102 3.12.6 analogRead() zum Einlesen eines Analogwerts ............................................ 103 3.12.7 analogReference() zur Auswahl der Referenzspannung des ADCs 104 3.12.8 analogWrite() zur Ausgabe eines PWM-Signals ............................................ 105 3.12.9 bitClear(), bitSet(), bitWrite(), bitRead() zur Bit-Bearbeitung ........................ 106 3.12.10 delay() und delayMicroseconds() zur Verzögerung der Programmausführung 107 3.12.11 millis() und micros() zur Zeitmessung ........................................................ 109 3.12.12 random() und randomSeed() zur Generierung von Zufallszahlen 110 3.12.13 map() zur Bereichsanpassung ................................................................... 113 3.12.14 Serial zur Kommunikation mit dem Seriellen Monitor / Seriellen Plotter .......... 115 3.13 Bibliotheken (Libraries) 123 3.14 Die Library »MCCAB_Lib« für das MCCAB Trainingsboard .................................... 125 3.14.1 Die Klasse KeySwitch 126 3.14.2 Die Klasse Matrix ..................................................................................... 129 3.14.3 Die Klasse LED ........................................................................................ 131 3.14.4 Die Klasse LedBlock 131 3.14.5 Die Klasse Sound ..................................................................................... 133 3.15 Die Library »LiquidCrystal_I2C« zur Steuerung des LC -Displays 137 4 Der Praxisteil mit Projekten und Übungen ....................................................... 143 4.1 Projekt 1: Begrüßung der Welt mit dem Seriellen Monitor der Arduino IDE ........... 143 4.2 Übung 14: Dauerausgabe auf den Seriellen Monitor 147 4.3 Übung 15: »Echo«-Sketch für die Eingaben des Seriellen Monitors ...................... 149 4.4 Übung 16: Formatierte Ausgabe eines Zählerstandes ........................................ 152 4.5 Übung 17: Ausgabe von Zahlenwerten in verschiedenen Zahlenformaten ............. 155 4.6 Übung 18: Überprüfung der Größe der C -Datentypen ........................................ 158 4.7 Projekt 2: Ein - und Ausgabe digitaler Werte mit den Functions der Arduino IDE 162 4.8 Übung 19: Blinklicht mit Arduino-Functions ...................................................... 165 4.9 Übung 20: Wechselblinker mit Arduino-Functions.............................................. 168 4.10 Übung 21: Geschaltetes Blinklicht mit Arduino-Functions ................................... 171 4.11 Übung 22: Blinklichter mit unterschiedlichen Frequenzen (Arduino -Functions) ...... 174 4.12 Projekt 3: Blinkende LED mit der Klasse LED der Library »MCCAB_Lib« 178 4.13 Übung 23: Drei mit unterschiedlichen Frequenzen blinkende LEDs ...................... 180 4.14 Übung 24: Verkehrsampel ............................................................................. 182 4.15 Projekt 4: Einlesen eines (prellenden) Schalters mit der Function digitalRead() 186
Inhalt 7 4.16 Projekt 5: Einlesen eines (prellenden) Schalters mit der Klasse KeySwitch ........... 192 4.17 Übung 25: Rastende Ein - / Aus-Funktion mit Tastschalter (Stromstoßschalter) 196 4.18 Übung 26: Geschaltetes Blinklicht mit den Klassen KeySwitch und LED................ 199 4.19 Übung 27: Blinklichter mit unterschiedlichen Frequenzen ( KeySwitch und LED) 202 4.20 Projekt 6: Ein - und Ausgabe analoger Werte .................................................... 206 4.21 Übung 28: Leuchtbalken mit Arduino-Functions ................................................ 210 4.22 Übung 29: Vergleich der Einlesedauer analoger und digitaler Werte 212 4.23 Projekt 7: Lauflicht mit der Klasse LedBlock der Library MCCAB_Lib .................... 215 4.24 Übung 30: Einzelpunkt-Lauflicht mit der Klasse LedBlock 219 4.25 Übung 31: Ausgabe von Binärzahlen mit der Klasse LedBlock ............................. 222 4.26 Übung 32: Leuchtbalken mit der Klasse LedBlock.............................................. 226 4.27 Projekt 8: Steuerung einer 3 x 3 - LED-Matrix mit Arduino-Functions 228 4.28 Projekt 9: Steuerung einer 3 x 3 - LED-Matrix mit der Klasse Matrix ................... 234 4.29 Übung 33: Rotierender Leuchtbalken auf der 3 x 3 - LED-Matrix ......................... 236 4.30 Übung 34: Zufallsmuster auf der 3 x 3 - LED-Matrix.......................................... 241 4.31 Übung 35: Reaktionstest 1 ............................................................................. 245 4.32 Übung 36: Elektronischer Würfel 251 4.33 Übung 37: Gleichverteilung von Zufallszahlen................................................... 254 4.34 Projekt 10: Polizei im Einsatz: Martin-Horn und Blaulicht mit Arduino-Functions ... 260 4.35 Projekt 11: Martin -Horn und Blaulicht mit der Klasse Sound der MCCAB_Lib......... 266 4.36 Übung 38: Ausgabe von Tonimpulsen .............................................................. 271 4.37 Übung 39: Nano-Klavier 274 4.38 Übung 40: Big Ben ........................................................................................ 281 4.39 Übung 41: Heul doch! ................................................................................... 285 4.40 Projekt 12: Verwendung und Darstellungsmöglichkeiten des LC -Displays 290 4.41 Übung 42: Der Zeichensatz des LCDs .............................................................. 299 4.42 Übung 43: Wir definieren eigene Zeichen für das LCD 303 4.43 Übung 44: Die Ausführungszeiten der LCD-Methoden ........................................ 307 4.44 Übung 45: Reaktionstest 2 ............................................................................. 311 4.45 Übung 46: LCD-Voltmeter 316 5 Problembehandlung – Fehlersuche mit dem Seriellen Monitor ......................... 323 6 Literaturverzeichnis ......................................................................................... 324 7 Stichwortverzeichnis........................................................................................ 325 8 Anhang ............................................................................................................ 328 8.1 ASCII-Tabelle 328 8.2 Download-Quellen.......................................................................................... 330

Schaut man sich einen der frühen James Bond - Filme mit Sean Connery an, so steht im Labor des Schurken meist ein Computer mit einer Front platte, die bedeckt ist mit blinkenden Lichtern. Für ein Theaterstück an ihrer Schule sollten einmal drei fünfzehnjährige Schüler ohne jegliche Elektronikkenntnisse als Requisite für das Stück einen solchen „Computer“ bauen. Doch das ist leichter gesagt als getan: Wenn man zwei Stunden lang auf ein Brett montierte Schalter mit der Geschwindigkeit von blinkenden Lichtern ein - und ausschalte t, kann man seinen Arm wegwerfen! Eine von einem Elektromotor angetriebene Walze mit Nocken oder Stiften, die Schaltkontakte heben und senken, um so Stromkreise zu öffnen und zu schließen? Auch nicht der Weisheit letzter Schluss! Wie schön wäre es da, ein elektronisches „Universalwerkzeug“ zu haben, mit dem Steuerungsaufgaben jeglicher Art auch für einen Laien eine Einfachheit wären! In Form des Mikrocontrollers gibt es dieses Universalwerkzeug bereits seit längerem, jedoch war sein e Verwendung für den Laien aufgrund des relativ komplexen Innenlebens zu schwierig. Um einen Mikrocontroller einsetzen zu können, muss te man sich mit einem mehrere 100 Seiten umfassenden Datenblatt auseinandersetzen (siehe Literaturhinweis [7]) und sich in elektronischer Schaltungstechnik genauso gut auskennen wie in mindestens einer Programmiersprache. Die vielen leistungsfähigen Funktionsblöcke im Inneren des Mikrocontrollers werden nämlich über sogenannte Register (siehe hierzu Abschnitt 3.2 und Literaturhinweis [7]) gesteuert, die zum Beispiel unter anderem die Datenrichtung von Ein - und Ausgängen oder die Taktfrequenz von Zeitgebern (englisch: Timer) festlegen

Solche und ähnliche Probleme könnten den italienischen Professor Massimo Banzi und seine Freunde bei einem Birra oder Vino in ihrem Stammlokal „Arduino“ im italienischen Ivrea auf den Gedanken gebracht h aben, den Einsatz von Mikrocontrollern einem breiten Kreis von Interessierten, aber elektronisch weitgehend Ahnungslosen zugänglich zu machen. So entwickelten sie eine Reihe von standardisierten Mikrocontroller-Boards und eine zugehörige Entwicklungsumgebung (englisch: Integrated Development Environment , IDE), die alle Werkzeuge vom Edi tor zur Erstellung des Quel lprogramms (englisch: Source Code) über den Compiler zur Übersetzung des Quellprogramms in den Maschinencode des Mikrocontrollers bis zum Bootloader zur Übertragung des Maschinencodes in den Mikrocontroller enthält (siehe Abbildung 11). Durch die preiswerten Ardui no®-Boards haben auch Laien jetzt die Möglichkeit, ihre elektronischen Ideen zu verwirklichen, insbesondere da die Arduino IDE kostenlos aus dem Internet auf den PC des Anwenders heruntergeladen werden kann.

Die zugehörige Software entwickel t der Anwender mit der Arduino IDE, die auf dem GCC (GNU C-Compiler) aus der GNU Compiler Collection basiert, einem sehr leistungsfähigen Compiler für die Programmiersprachen C und C++. Die Arduino IDE stellt also einem geschulten Programmierer die volle Leistungsfähigkeit eines C- und C++ - Compilers zur Verfügung. Nun stellt aber das Arbeiten mit diesem aufgrund seiner Lei stungsfähigkeit ziemlich komplexen Compiler doch sehr hohe Anforderungen an einen Einsteiger, um es noch harmlos auszudrücken. Damit sich der Laie gar nicht erst mit Themen wie den oben erwähnten Registern zur Steuerung der Mikrocontroller-Interna auseinandersetzen und auch nicht zu tief in die Welt der C-Programmierung eindringen muss , hat das Team um Massimo Banzi in sich gekapselte Programmteile, sogenannte Functions kreiert und in die Arduino IDE eingebaut , die diese Aufgaben für den Einsteiger erledigen. Der Anwender muss mithilfe dieser Functions nur noch erklären , dass z.B. der Anschluss stift (englisch: Pin) des Mikrocontrollers mit der Nummer 3 ein Eingang sein soll, weil an diesen ein Schalter angeschlossen ist und der Pin 8 als Ausgang konfiguriert wird, weil er mit einer Leuchtdiode verbunden ist Die Function erledigt dann im Hintergrund und vom Anwender unbemerkt alle nötigen Registereinstellungen auf dem Chip des Mikrocontrollers, um die gewünschte Eigenschaft des Pins zu realisieren.

Mikrocontroller-Praxiskurs für Arduino-Einsteiger 8 1
1 E Eiin nffü ü h hrru u n n g g

Auf dem Elektronikmarkt sind inzwischen viele Arduino ®-kompatible Zubehörschaltungen mit Sensoren, Motoren, Displays … erhältlich. Zu ihrer Steuerung stehen dem Anwender bei der Verwendung der Arduino IDE umfangreiche Bibliotheken (englisch: Libraries , siehe Kapitel 3.13) zur Verfügung. Der Anwender muss die entsprechende Library lediglich in sein Programm einbinden und verfügt dann über alle Tools, die er zur Steuerung eines Objektes in seinem Projekt benötigt.

In den folgenden Kapiteln werden wir uns alle Kenntnisse der Hard - und Software aneignen, die wir zur Umsetzung eigener Arduino-Projekte brauchen , um dann in der Folge anhand vieler Übungen unser Wissen zu vertiefen und unsere Kreativität zu testen. Wie wir in mehreren Übungen sehen werden, ist es mit dem Arduino -System z.B. eine Leichtigkeit, Lichter wie in der obigen Aufgabenstellung für das Theaterstück blinken zu lassen.

Für einen Schreinermeister ohne jegliche elektronische Ausbildung war es jedenfalls sehr einfach, bereits nach kurzer Einarbeitungszeit mithilfe des Arduino -Konzeptes eigene Projektideen umzusetzen und zu realisieren. Und sogar Künstler, denen ja häufig eine nicht gerade große Affinität zu naturwissenschaftlichen Fächern nachgesagt wird, setzen Arduino-Komponenten für ihre Licht- und Musik-Installationen ein.

1 Einführung 9

Das zentrale Thema unseres Einsteigerkurses ist der Mikrocontroller , ein Universal-Baustein zur Steuerung von elektroni schen Geräten.

Um mit einem Mikrocontroller arbeiten zu können, brauchen wir die entsprechende Hardware , nämlich ein Mikrocontroller-System, bestehend aus der in Abbildung 1 gezeigten integrierten Mikrocontroller-Schaltung, die zusammen mit einigen zur Ein - und Ausgabe von Daten erforderlichen Komponenten auf eine Platine gelötet ist.

In diesem Kapitel werden wir uns mit den Eigenschaften ein es Mikrocontrollers beschäftigen und wir werden das MCCAB Trainingsboard kennenlernen, auf dem wir unsere Übungen durchführen.

Abbildung 1: Der

2.1 Die elektronische Ver arbeitung von Daten und Signalen

Die Welt in der wir leben, ist eine analoge Welt: Zwischen zwei Farben gibt es unendlich viele andere Farben, zwischen 2 Tönen gibt es unendlich viele Zwischenfrequenzen und zwischen zwei Temperaturen liegen unendlich viele weitere Temperaturwerte.

Zur Durchführung von Berechnungen stehen uns in unserer analogen Welt verschiedene Hilfsmittel zur Verfügung: Seit vielen Jahrtausenden ist der Abakus in Gebrauch, mit dem nicht nur die vier Grundrechnungsarten Addition, Subtraktion, Multiplik ation und Division, sondern auch das Radizieren durchgeführt werden können . Ab dem späten Mittelalter standen mechanische Rechenmaschinen zur Verfügung. Vielen älteren Technikern ist der Rechenschieber noch ein Begriff, der vor allem die schnelle Multipli kation und Division durch die grafische Addition von Logarithmen ermöglicht.

In der Elektronik können analoge Spannungen mit Hilfe von Operationsverstärker n und speziellen integrierten analogen Rechenschaltungen addiert, subt rahiert, multipliziert, dividiert, radiziert, quadriert, integriert und differenziert werden.

Zur Durchführung von Messungen stehen in der Analogtechnik z.B. das links in Abbildung 2 gezeigte elektromechanische Zeigerinstrument, Oszilloskope und X-Y Schreiber zur Verfügung.

Abbildung 2: Analoges und digitales Einbaumessgerät (Quelle: Conrad Electronic SE, Hirschau)

Mikrocontroller-Praxiskurs für Arduino-Einsteiger 10 2 2 D Diie e H H a arrd d w w a arre e--G Grru u n n d dlla a g g e e n n
Mikrocontroller ATmega328P

Bei dem analogen Zeigerinstrument links in Abbildung 2 ist der Ausschlag des Zeigers proportional zur angelegten Analogspannung, der Zeiger kann somit stufenlos jeden beliebigen Wert innerhalb des Messbereichs anzeigen. Die durch die stufenlose Anzeige theoretisch unbeschränkte Genauigkeit analoge r Zeigerinstrumente ist allerdings ebenso wie die der anderen oben genannten Analogmessgeräte eingeschränkt, z.B. durch Fertigungstoleranzen, ihre mechanische Konstruktion, ihren Innenwiderstand, Reibungs- und Leitungsverluste, Ableseungenauigkeit (P arallaxe) etc. Kleinere Fehler als zirka  1 % sind hier nur mit großem Aufwand erreichbar. Z usätzlich reagieren analoge Messgeräte empfindlich auf elektromagnetische Störfelder, überlagertes Rauschen und Te mperaturschwankun gen.

Bei dem digitalen Messgerät rechts in Abbildung 2 wird das Messergebnis dagegen direkt als Zahlenwert dargestellt. Genauigkeitseinschränkungen durch mechanische Einflüsse oder Ablesefehler entfallen somit. Um z.B. eine analoge Spannung oder einen Temperaturwert auf einem Digitalinstrument anzeigen zu können, ist es erforderlich , die physikalische Analoggröße in einen Zahlenwert umzuwandeln, den das Display des Messgeräts anzeigen kann. Diese Aufgabe erledigt der in Abschnitt 2.7.2.1 beschriebene Analog / Digital - Converter (ADC), der das analoge Signal quantisiert, d.h. in Stufen einer bestimmten Schrittweite aufteilt. Der ADC misst den aktuellen Spannungswert an seinem Analogeingang zu einem bestimmten Zeitpunkt und wandelt ihn in einen der Höhe der Spannung entsprechenden Zahlenwert Z um. Je kleiner die Quantisierungsstufen gewählt werden, desto besser nähern sich die Zahlenwerte dem tatsächlichen Verlauf des Eingangssignals an , wie Abbildung 3 und Abbildung 4 zeigen.

u(t), Z

Analogsignal u(t) quantisiertes Signal Z

Abbildung 3: Analog / Digital - Wandlung mit vier Quantisierungstufen

u(t), Z

Analogsignal u(t) quantisiertes Signal Z

Abbildung 4: Analog / Digital - Wandlung mit sechzehn Quantisierungstufen

2.1 Die elektronische Verarbeitung von Daten und Signalen 11

Das digitale Messinstrument rechts in Abbildung 2 ist zwar keinen mechanischen Einflüssen oder Ablesefehlern unterworfen, dafür ist es aber aufgrund der Quantisierung durch den Analog / Digital - Converter lediglich in der Lage, Ergebnisse i n Schritten von einer Dezimalstelle nach dem Komma anzuzeigen. Die theoretisch unendlich vielen Werte zwischen zwei Ziffernschritten der niederwertigsten Stelle können nicht angezeigt werden, sie entfal len.

Wie sich Abbildung 3 und Abbildung 4 entnehmen lässt, kann die Auflösung eines Digitalmessgerätes aber durch eine immer feinere Quantisierung auf (theoretisch) unen dlich viele Nachkommastellen gesteigert werden. Die „eingebauten“ Analog / Digital - Converter gängiger Mikrocontroller quantisieren das analoge Eingangssignal mit 256 bis 4096 Stufen (dies entspricht einer Auflösung von 8 … 12 Bits, siehe folgenden Abschnitt 2.1.1), spezielle integrie rte ADCSchaltungen wandeln mit 65536 (entspricht 16 Bits) und mehr Stufen.

Bei einem Messbereich von 5 Volt führen 65536 Stufen zu einer Auflösung von

V V 0,000076 65536 5  für eine Quantisierungsstufe.

Auch die Übertragungswege von digitalen Signalen sind weit störsicherer als die analoger Signale. Während analoge Messleitungen meist mit einer Schirmung versehen sein müssen, um sie gegen äußere Einflüsse wie Rauschen und elektromagnetische Einkopplungen zu schützen, ist dies bei digitalen Signalen zumeist nicht erforderlich, denn sie übertragen, wie wir im Folgenden sehen werden, nur die Zustände »Spannung vorhanden« bzw. »Spannung nicht vorhanden« .

2.1.1 Signalzustände und Zahlenbildung in der Digitaltechnik

Digitale Systeme sind »binäre« Systeme (lateinisch bina „doppelt, paarweise “), denn sie kennen nur die beiden Zustände logisch 0 und logisch 1 entsprechend »Spannung vorhanden« bzw. »Spannung nicht vorhanden«. Eine logische 0 wird auch als LOW-Signal (niedrige Spannung) und eine logische 1 als HIGH-Signal (hohe Spannung) bezeichnet.

Dieses Prinzip lässt sich sehr einfach mit einem Schalter realisieren, der entweder geöffnet oder geschlossen sein kann. Dem offenen Schalter weist man den Wert 0 und dem geschlossenen Schalter den Wert 1 zu .

Schalter offen

5 V S = 0

Schalter geschlossen

5 V S = 1

Abbildung 5: Mögliche Zustände eines Schalters und den Zuständen zugeordnete binäre Werte

In digitalen Schaltkreisen kommen natürlich keine mechanischen Schalter zum Einsatz, sondern entsprechende Schalttransistoren.

Wie man in Abbildung 5 erkennt, kann ein Schalter oder Schalttransistor zwei verschiedene Zustände annehmen und somit die beiden binären Zahlenwerte 0 und 1 bilden. Vergrößert man die Anzahl der Schalter, so vergrößert sich auch die Anzahl der möglichen Zustandskombinationen. Auf diese Weise ist es möglich, mit der entsprechenden Anzahl von Schaltern beliebig große, aus Nullen und Einsen bestehende Binärzahlen zu realisieren. Die folgende Abbildung 6 zeigt die mit 2 Schaltern möglichen Kombinationen.

Mikrocontroller-Praxiskurs für Arduino-Einsteiger 12

Abbildung 6: Mögliche Zustandskombinationen zweier Schalter und die zugeordneten binären und dezimalen Werte

Bestimmte Größen von Binärzahlen haben in der Digitaltechnik eigene Bezeichnungen erhalten:

 Eine Stelle einer binären Zahl bezeichnet man als » Bit«.

 Eine aus 4 Bits bestehende Binärzahl bezeichnet man als »Nibble «.

 Eine aus 8 Bits bestehende Binärzahl bezeichnet man als » Byte«.

Beispiel:

Mit einer Anzahl von N Bit lassen sich 2 N Kombinationen bilden und somit sind 2 N verschiedene natürliche Zahlenwerte möglich.

Der größte mit N Bit darstellbare Zahlenwert ist 2 N – 1 (da die Reihe mit der 0 beginnt).

Beispiel:

Mit 1 Byte = 8 Bit (also N = 8) kann man 28 = 256 verschiedene Dualzahlen zwischen 0000 0000 ... 1111 1111, somit also die Zahlenwerte 0 (28 – 1) = 0 255 realisieren.

Mit 2 Bytes = 16 Bit (N = 16) kann man 216 = 65536 verschiedene Dualzahlen, also die Zahlenwerte 0 ... (216 – 1) = 0 ... 65535 realisieren.

2.1.2 Datenverarbeitung »digital« statt »analog«

Unter Berücksichtigung der erzielbaren Genauigkeit, der fehlenden Mechanik und der weitgehenden Unempfindlichkeit gegenüber äußeren Einflüssen digitaler Schaltungen i st es kein Wunder, dass mit dem Auftreten der ersten integrierten Logik -, Zähler- und Rechenschaltungen – wie der TTL-Familie 74xxx oder der CMOS-Serie CD4xxx – der Siegeszug der Digital technik begann

Um die Größen unserer analogen Welt digital verarbeiten zu können, müssen sie von entsprechenden Sensoren aufgenommen, in ein en digitalen Zahlenwert gewandelt, von einem Controller digital verarbeitet und anschließend wieder in ein analoges Signal umgesetzt und ausgegeben werden. Abbildung 7 zeigt den Ablauf am Beis piel einer digitalen Temperatursteuerung.

Der Widerstand R links in Abbildung 7 ist temperaturabhängig. Mit steigender Temperatur  verringert sich sein Widerstandswert , mit fallender Temperatur nimmt sein Wert zu. R  bildet mit dem Widerstand RV einen Spannungsteiler für die Referenzspannung V REF. Der aus RV und R bestehende Spannungsteiler verändert somit die analoge Eingangsspannung des Analog / Digi -

2.1 Die elektronische Verarbeitung von Daten und Signalen 13 Schalterzustände Binärzahl Dezimalzahl 0 0 0 0 1 1 1 0 2 1 1 3
1 0 1 1 0 0 1 1 Bits Nibble Nibble Byte

tal - Converters (ADC) der aktuellen Temperatur entsprechend. Am Ausgang des ADCs steht der mit der Temperatur korrespondierende digitale Zahlenwert.

Abbildung 7: Beispiel zur digitalen Steuerung analoger Größen

Dieser Digitalwert wird von dem Controller seinem Programm entsprechend verarbeitet. Das Resultat der Verarbeitung wird über den Digital / Analog- Converter (DAC) an die Treiberstufe V ausgegeben, deren Ausgangsleistung z.B. einen Ofen – in Abbildung 7 symbolisiert durch den Heizwiderstand RH – entsprechend aufheizt. Der Controller, der in Abbildung 7 die Verarbeitung der digitalen Signale übernimmt, ist in der heutigen Zeit zumeist ein Mikrocontroller.

2.2 Was ist ein Mikroprozessor ?

Bereits die Verfügbarkeit der ersten integrierten Digitalschaltungen – etwa aus der TTL-Familie 74xxx oder der CMOS-Serie CD4xxx – führte zu einer regelrechten Revolution in der bis dahin weitgehend analogen elektronischen Schaltungstechnik . Einen absoluten Quantensprung brachte aber die Einführung der ersten Mikro prozessoren.

Durch die schnell voranschreitenden Verbesserungen bei der Herstellung integrierter Schaltungen gelang es um 1970, auf Basis der zu dieser Zeit bereits erhältlichen digitalen ICs (Integrated Circuits = integrierte Schaltungen) mit digitalen Logikgattern, Zählern, Addierern etc. eine Ablaufsteuerung zusammen mit eine r ALU (Arithmetic and Logic Unit – also einem Rechenwerk, siehe Abschnitt 3.2) auf einem einzigen Halbleiterchip zu kombinieren – der Mikroprozessor war geboren.

Durch die Ablaufsteuerung ist der Mikroprozessor in der Lage, eine Liste von Anweisungen sequentiell abzuarbeiten und im Bedarfsfall auch an eine andere Stelle der Liste zu springen und von dort weiterzuarbeiten.

Die ALU (das Rechenwerk) ermöglicht dem Mikroprozessor die Ausführung mathematischer und logischer Operationen.

Die Verwendung eines Mikroprozessors hat gegenüber einer fest verdrahteten Logikschaltung aus einzelnen integrierten Schaltungen einen entscheidenden Vorteil: Die fest verdrahtete Logikschaltung ist nur für diese eine Funktion verwendbar, für die sie entwickelt wurde. Wenn eine Änderung erforderlich wird, muss die gesamte Hardware verschrottet und durch eine neue ersetzt werden.

Mikrocontroller-Praxiskurs für Arduino-Einsteiger 14
Ablaufsteuerung Rechenwerk (ALU) Mikroprozessor VREF Verarbeitung  R RV ADC DAC V Controller RH A D D A

2.3 Die Bestandteile eines Mikroprozessor -Systems

Eine Mikroprozessorschaltung ist dagegen universell einsetzbar, denn wie wir in unseren Übungen in diesem Kurs sehen werden, kann ein - und dieselbe Hardware für viele unterschiedliche Zwecke eingesetzt werden. Und wenn die Mikrocontrollerschaltung Bestandteil eines Gerätes ist, genügt es im Falle einer erforderlich werdenden Änderung häufig, eine neue Software in den Befehlsspeicher des Mikroprozessors laden (Stichwort »Upgrade«) . Die Hardware kann zumeist unverändert weiterverwendet werden .

2.3 Die Be standteile eines Mikroprozessor -Systems

Die Ablaufsteuerung und die ALU auf seinem Chip genügen dem Mikroprozessor (englische Bezeichnung CPU = Central Processing Unit ) allerdings noch nicht, um seine Aufgaben erfüllen zu können. Benötigt werden neben der CPU auch die in Abbildung 8 gezeigten Peripheriekomponenten, die bei einem Mikroprozessor system in Form separater integrierter Schaltungen oder externer Geräte (Festplatte etc.) auf der Leiterplatte (engl. Motherboard) vorhanden sein bzw. an diese angeschlossen werden müssen.

Abbildung 8: Die Komponenten eines Mikroprozessorsystems

Zum Betrieb eines Mikroprozessors erforderlich sind …

 der Befehlsspeicher (ROM = Read Only Memory , ein Speicher, aus dem der Prozessor Daten im laufenden Betrieb nur lesen kann). Das ROM enthält die Liste der Anweisungen (das Programm), die die CPU im Programmablauf ausführen soll, sowie konstante Daten. Da das Programm nach dem Aus- und Wiedereinschalten des Systems noch vorhanden sein soll, müssen die ROM-Daten nach dem Abschalten der Betriebsspannung erhalten bleiben. Man spricht in diesem Zusammenhang von einem „nichtflüchtigen“ Speicher.

 der Arbeitsspeicher (RAM = Random Access Memory , ein Speicher für die „flüchtigen “ Daten, den der Prozessor im laufenden Betrieb lesen und neu beschreiben kann). Da es sich bei den RAM-Daten um Zwischenergebnisse handelt, die nach dem Ausschalten des Systems nicht mehr benötigt werden, dürfen sie nach dem Abschalten der Betriebsspannung verloren gehen.

 die Ein- / Ausgabe - Einheit (Input / Output Unit), über die der digitale Datenverkehr mit der Außenwelt abläuft.

 zusätzliche Hardware-Bausteine zur Realisierung wünschenswerter Zusatzfunktionen wie Analog / Digital - Wandler, Zeitgeber (Timer) / Zähler, serielle Schnittstellen etc.

 der Systembus , über den der systeminterne Datenaustausch zwischen den peripheren Ko mponenten und der CPU stattfindet.

15
CPU ROM RAM Input / Output ZusatzFunktion ZusatzFunktion Bus

2.4 Vom Mikroprozessor zum Mikrocontroller

In unserer technisierten Welt werden Steuerungen benötigt, die speziell auf ein bestimmtes Gerät wie etwa einen Fotoapparat, eine Waschmaschine, eine sprechende Spielzeugpuppe oder ein Modellflugzeug zugeschnitten sind, um nur einen kleinen Ausschnitt aus der schier unbegrenzten Fülle von Anwendungsmöglichkeiten zu nennen.

Befehlsspeicher ROM (Flash)

Arbeisspeicher RAM (SRAM)

Central Processing Unit (CPU )

Analog / Digital -Converter

TWI

Serielle Schnittstellen

Input / Output (Ports )

Abbildung 9: Blockschaltbild des Mikrocontrollers ATmega328P (Microchip Technology Inc.)

Mikrocontroller-Praxiskurs für Arduino-Einsteiger 16
(= I 2C) USART SPI
Timer

Bei einer solchen Steuerung – man spricht hier von einem »Embedded System «, weil die Steuerung sozusagen in ihr Gerät „eingebettet“ ist – ist es sinnvoll, die benötigten Peripheriekomponenten aus Abbildung 8 gleich auf den Chip des Mikroprozessors zu integrieren. Eine integrierte Schaltung, die einen Mikroprozessor, dessen Befehls - und Arbeitsspeicher und seine Ein - / Ausgabe-Einheiten auf einem Chip vereinigt, wird als »Mikrocontroller « bezeichnet. Darüber hinaus verfügen die meisten Mikrocontrollerchips zusätzlich über Bausteine zur Realisierung wünschenswerter Zusatzfunkti onen wie zum Beispiel Analog / Digital - Wandler, Zeitgeber (Timer), Spannungskomparatoren, serielle Schnittstellen …

Abbildung 9 zeigt das „Innenleben “ des auf dem MCCAB Trainingsboard verwendeten Mi krocontrollers ATmega328P mit allen seinen Komponenten . Der Befehlsspeicher (ROM) ist in Abbildung 9 aufgrund seiner Technologie als Flash bezeichnet und das RAM hat die Bezeichnung SRAM, um zu verdeutlichen, dass es sich um ein statisches RAM handelt, das keinen Refresh-Zyklus benötigt, wie er z.B. beim RAM des PCs erforderlich ist (siehe folgenden Abschnitt 2.5).

2.5 Die Unterschiede zwischen Mikrocontroller und PC

Um die Zusammenhänge für den Einsteiger etwas anschaulicher zu machen, wollen wir im Folgenden die einzelnen Komponenten aus Abbildung 8 im Falle des Mikrocontrollers und im Vergleich dazu des uns allen bestens bekannten PCs (Personal Computer) näher betrachten und die nicht unerheblichen U nterschiede zwischen den beiden Systemen aufzeigen.

Im Prinzip sind sich PC und Mikrocontroller sehr ähnlich, denn beide benötigen die in Abbildung 8 gezeigten Komponen ten. Andererseits liegen Welten zwischen ihnen, denn beide zielen auf völlig unterschiedliche Marktsegmente. Abbildung 10 zeigt die wesentlichen Gemeinsamkeiten, aber auch die Unterschiede zwischen den beiden Systemen auf.

Komponente PC Mikrocontroller

1. Prozessor, CPU CISC-Architektur 1)

Taktfrequenz: einige Giga-Hertz

2. Programmspeicher Festplatte / SSD 3)

Kapazität: einige Tera-Bytes

3. Arbeitsspeicher (dynamisches) RAM

Kapazität: einige Giga-Bytes

RISC-Architektur 2)

Taktfrequenz: mehrere Mega-Hertz

FLASH-Memory

Kapazität: mehrere Kilo-Bytes

(statisches) RAM

Kapazität: einige Kilo-Bytes

4. Bedienung und Anzeige Maus, Tastatur und Bildschirm Schalter, Taster, Potenziometer, LEDs, LC -Display

5. Energiebedarf groß (bis zu einigen 100 W) klein (wenige mW)

6. Preis 300,00 … 2.000,00 € 0,50 … 20,00 €

7. Ziel-Anwendung Verarbeitung von Massendaten (Textverarbeitung, Bildbearbeitung, Spiele …)

Steuerung / Überwachung eines bestimmten Geräts (»embedded system«) 4)

Abbildung 10: Die wesentlichen Unterschiede zwischen PC und Mikrocontroller

1) Complex Instruction Set Computer (Rechner mit komplexem Befehlssatz, näheres z.B. unter Literaturhinweis [10]

2) Reduced Instruction Set Computer (Rechner mit reduziertem Befehlssatz, näheres z.B. unter Literaturhinweis [11]

3) Solid-State-Drive („Halbleiterlaufwerk“, näheres z.B. unter Literaturhinweis [12]

4) eingebettetes System , näheres z.B. unter Literaturhinweis [13]

2.5
17
Die Unterschiede zwischen Mikrocontroller und PC

Ein PC eignet sich hervorragend zur Verarbeitung von Massendaten, wie sie z.B. in der Bild- und Textverarbeitung anfallen. Entsprechend groß ist sein Bedarf an Arbeitsspeicher und Festplattenkapazität.

 Um den oft hohen Datendurchsatz zu schaffen, ist eine hohe Taktfrequenz des Prozessors (einige Gigahertz) erforderlich. Diese Eigenschaften müssen mit einem entsprechenden Preis bezahlt werden: Ein Prozessor für einen PC kostet mehrere 100 Euro.

 Das ROM des PCs splittet sich in zwei Komponenten. Zum einen gibt es auf dem Motherboard den Bootstrap-Speicher, eine integrierte Schaltung, aus der die CPU nach dem Einschalten der Betriebsspannung ihre er sten Befehle zum Laden des Betriebssystems ausliest. Dieses und die Anwendungsprogramme befinden sich auf einer Festplatte oder SSD3) auf Seite 17 Die Festplatte ist zwar kein „echtes “ ROM, da die CPU neben den ablauffähigen Programmen auch Daten auf ihrer Festplatte speichert, also während des Programmablaufs auf die Fes tplatte auch schreiben kann, aber sie hat wie das klassische ROM die Funktion eines permanenten Massenspeichers , der seinen Inhalt nach dem Abschalten der Betriebsspannung nicht verliert. Die Speicherung erfolgt entwe der auf einem elektromechanischen Laufwerk mit ma gnetischer Festplatte oder auf einem deutlich schnelleren SSD-„Laufwerk“ (Solid State Drive ), bei dem die Daten in integrierten , nichtflüchti gen Halbleiterspeichern abgelegt werden.

 Das RAM des PCs ist ein dynamisches Halbleiterspeicher-Modul , das auf das Motherboard aufgesteckt ist und in das die CPU das Programm über den Systembus zur Ausführung von der Festplatte lädt. Der PC legt also in sein em RAM nicht nur Zwischenergebnisse ab, sondern auch der eigentliche Programmablauf findet beim PC in seinem Arbeitsspeicher, dem RAM statt. Ein dynamisches RAM muss periodisch im Abstand von einigen Millisekunden aufgefrischt werden (Refresh-Zyklus), das heißt, die gespeicherten Daten müssen ausgelesen und wieder zurück geschrieben werden, sonst gehen sie verloren

 Bei den Ein- / Ausgabe-Einheiten zur Kommunikation mit der Umwelt handelt es sich im Fall des PCs hauptsächlich um Anschlüsse für Bildschirm, Tastatur, Maus, Drucker ….

 Die zusätzlichen Funktionsblöcke des PCs können unter anderem eine USB -, Ethernet-, WLAN-Schnittstelle, Soundkarte etc. sein.

 Die einzelnen Komponenten sind über ein Bussystem auf der System-Leiterplatte ( dem Motherboard) verbunden, über das der Datenaustausch stattfindet.

Dem Mikrocontroller genügen zur Steuerung „seines“ Geräts dagegen meist wenige Megabyte (häufig genügen sogar einige Kilobyte) an Befehlsspeicher. Auch sein Arbeitsspeicher und seine Taktfrequenz sind bei weite m kleiner als bei einem PC. Dafür ist der Preis ein entscheidendes Kriterium, denn Mikrocontroller werden oft in Artikeln mit Massenstückzahlen eingesetzt , bei deren Herstellungskosten auf jeden Cent geachtet werden muss Abhängig von der bestellten Stückzahl ist ein Mikrocontroller je nach Ausstattung zu Preisen von weniger als einem Euro bis zu ca. 20 Euro erhältlich.

 ROM und RAM des Mikrocontrollers sind reine Halbleiterschaltungen, die sich direkt auf seinem Chip befinden. Das RAM ist in statischer Technologie ausgeführt (SRAM) und benötigt daher keinen Refresh-Zyklus.

 Seine Ein- / Ausgabe-Einheiten sind digitale Transistorschal tstufen – sogenannte Ports – deren Datenrichtung per Software zwi schen Ein- und Ausgang umgeschaltet werden kann.

 Seine zusätzlichen Funktionsblöcke sind zum Beispiel serielle Schnittstellen (USB, UART , SPI, I 2C … ), Analog / Digital - und Digital / Analog - Wandler, Timer- und Zählerschaltungen ...

 Der Datenaustausch erfolgt über ein Chip-internes Bussystem, das alle Komponenten miteinander verbindet

Wie man sieht, muss der direkte Vergleich der beiden Systeme zwangsläufig hinken, denn die Zielsetzungen gehen doch sehr weit au seinander (Item 7 in Abbildung 10). Tatsache bleibt aber,

Mikrocontroller-Praxiskurs für Arduino-Einsteiger 18

dass beide über die wesentlichen Komponenten eines Computers, wie CPU, Programm - und Arbeitsspeicher sowie Einrichtungen zur Ein - und Ausgabe von Daten verfügen.

2.6 Die V orgehensweise beim Einsatz ein es Mikrocontrollers

Die Verwendung eines Mikrocontrollers ist im Prinzip recht einfach:

Der Anwender schreibt auf seinem PC in der Arduino IDE (integrierte Entwicklungsumgebung, siehe Kapitel 3.6) ein Programm, das die auszuführenden Aktionen fes tlegt.

Abbildung 11 zeigt die Vorgehensweise bei der Programmerstellung : Ein in die IDE integrierter Compiler übersetzt den mithilfe des Editors in der IDE erstellten Source Code (Quelltext) mit den Programmanweisungen in den für den Mikrocontroller verständliche n Maschinencode, der aus Kombinationen binärer Nullen und Einsen besteht (siehe Abschnitt 2.1.1). Nach der Kompilierung wird das Programm über die USB-Schnittstelle des PCs in den Befehlsspeicher des Mikrocontrollers geladen.

Editor:

...

// setup function:

setup() {

// initialize serial:

Abbildung 11: Vorgehensweise bei der Erstellung eines Mikrocontroller-Programms

Der Mikrocontroller arbeitet das Programm von oben nach unten ab. Bei Mikrocontrollern läuft das Programm zumeist in einer sogenannten Endlosschleife , das heißt, es wird bis zum Abschalten der Betriebsspannung immer wieder von Neuem ausgeführt.

Die Ablaufsteuerung der CPU holt nacheinander die auszuführenden Anweisungen aus dem B efehlsspeicher (ROM), analysiert sie und veranlasst die auszuführende Operation. Wenn z.B. die (fiktive) binäre Bit-Kombination 1001 0010 0011 1110 eingelesen wird, „weiß“ die Ablaufsteuerung, dass der Inhalt von Register A zum Inhalt von Register B addiert werden soll, bei 1100 1101 1110 1111 soll ein Wert aus dem Arbeitsspeicher in ein Register gel aden werden usw. Register sind spezielle Speicherzellen innerhalb der CPU mit besonderen Eige nschaften. Aus Kapitel 1 wissen wir, dass die Hardware auf dem Chip des Mikrocontrollers durch Register gesteuert wird. Falls eine logische oder eine Rechenoperation auszuführen ist, werden die in Registern gespeicherten Operanden an die ALU (Arithmetic and Logic Unit, siehe Abschnitt 3.2) übergeben. Die Operanden sind in Form von Variablen (siehe Abschnitt 3.4) im Arbeitsspeicher (RAM) abgelegt. Die zur Ausführung seiner Aufgaben erforderlichen Informationen holt sich der Prozessor mithilfe seiner Ein - / Ausgabe - Einheit (Input / Output Unit) von der Außenwelt, ebenso gibt er über sie die Ergebnisse an die angeschlossenen Bauteile oder Geräte aus.

Nach der Abarbeitung einer Anweisung wird die Sequenz mit dem Einholen des nächsten Befehls fortgesetzt …

Aufgrund logischer Entscheidungen im Programmablauf oder durch Interrupts (Programmunterbrechungen, die von einem externen Gerät oder einem der Bausteine für Z usatzfunktionen auf dem Mikrocontrollerchip veranlasst werden, siehe Abschnitt 3.11.4) kann der sequentielle Ablauf der Programmabarbeitung auch durch einen Sprung in einen anderen Teil des Programms unterbrochen und von einer anderen Stelle aus fortgesetzt werden.

2.6
19
Die Vorgehensweise beim Einsatz eines Mikrocontrollers
Code (Quelltext) Compiler: ... 1001 0010 0011 1110 1100 1101 1110 1111 1000 0001 1101 0010 1010 0101 1100 0110 0000 0001 1101 0111 ... Maschinencode USB
Serial.begin(9600); } ... Source
-Transfer Mikrocontroller-Board

2.7 Der Datenverkehr mit der „Außenwelt“

Damit ein Mi krocontroller überhaupt sinnvoll arbeiten kann, muss er Daten aus der „Außenwelt“ – z.B. von einem Schalter, einem Sensor oder einem veränderbaren Widerstand ( Potenziometer) – einlesen und Daten an die Außenwelt ausgeben – z.B. an eine Leuchtdiode, ein Display oder eine n Motor

Bei der Ein- und Ausgabe von Daten muss zwischen digitalen und analogen Daten untersch ieden werden. Nur digitale Daten kann der Mikrocontroller direkt verarbeiten. Zur Verarbeitung analoger Daten (z.B einer Analogspannung, eines Temperatur- oder Helligkeitswerts oder der Drehzahl eines Motors) werden Wandler benötigt, die die analoge Größe in einen digitalen Zahlenwert umwandeln.

2.7.1 Digitale Ein - / Ausgänge (GPIOs)

Die digitalen Ein- / Ausgangs-Pins eines Mi krocontrollers werden als GPIOs bezeichnet (General Purpose Input / Output), um ihre allgemeine Verwendbarkeit für digitale Ein- / Ausgaben auszudrücken, denn der Anwender kann einen GPIO je nach Erfordernis in seinem Programm als Eingang oder als Ausgang konfigurieren.

Bei GPIOs gibt es nur zwei Zustände:

1. Entweder ist Spannung vorhanden (man nennt diesen Zustand logisch 1 oder HIGH)

2. oder es ist keine Spannung vorhanden (Zustand logisch 0 oder LOW).

Alle Werte, die kleiner sind als die halbe Betriebsspannung, werden als logisch 0 bzw. LOW und alle Werte, die größer sind als die halbe Betriebsspannung, we rden als logisch 1 bzw. HIGH betrachtet. Zwischenwerte werden nicht akzeptiert !

Digitaler Eingang

Wenn wir also später in unseren Übungen den Zustand eines digitalen Eingangs einlesen, so erhalten wir – wie in Abbildung 12 gezeigt – entweder HIGH-Pegel (logisch 1) oder wir erhalten LOW-Pegel (logisch 0), je nachdem, ob die an dem betreffenden Eingang anliegende Spannung größer oder kleiner ist als die halbe Betriebsspannung.

Der Zustand an einem unbeschalteten digitalen Eingang ist undefiniert! Mit einem MOSFET-Schalttransistor (in Abbildung 12 symbolisiert durch den Schalter S1) kann deshalb im Inneren des Mi krocontrollers der Widerstand RPU an den Eingangspin geschal tet werden.

Wenn der Schalter S1 geschlossen ist, zieht dieser sogenannte Pull Up - Widerstand RPU die Leitung bei offenem Eingang auf HIGH-Potenzial und sorgt so für einen definierten Eingangszustand.

Digitaler Ausgang

Abbildung 12: Digitaler Mikrocontrollereingang

Der Aufbau einer digitalen Ausgangs stufe ist in Abbildung 13 durch die beiden Schalter S2 und S3 symbolisiert.

Im realen Mi krocontroller sind S2 und S3 natürlich keine mechanischen Schalter, sondern es handelt sich um MOSFET-Schalttransistoren, die in der Lage sind, Ströme bis zu 40 mA zu schalten.

Um einen LOW-Pegel an den Ausgangspin zu legen, muss Schalter S2 offen und Schalter S3 muss geschlossen sein, wie in Abbildung 13 gezeigt. In dieser Konstellation wird

Mikrocontroller-Praxiskurs für Arduino-Einsteiger 20
+5 V 0 V +2,5 V LOW HIGH interner Systembus +5 V RPU S1 Mikrocontroller Pin

das Massepotenzial 0 V an den Ausgangspin geschaltet. Um den Ausgang auf logisch 1 (HIGH-Pegel) zu legen, muss Schalter S2 geschlossen und Schalter S3 geöffnet sein , um die Betriebsspannung +5 V an den Ausgangspin zu schalten. Eine interne Logik sorgt dafür, das s nicht beide Schalter gleichzeitig geschlossen sein kö nnen, denn dies würde einen Kurzschluss zwischen der Betriebsspannung +5 V und dem Massepoten zial 0 V der Schaltung bedeuten.

Abbildung 13: Digitaler Ausgang

Konfiguration des GPIO-Pins

Jeder GPIO - Pin des Mikrocontrollers ist mit einer Eingangs- und einer Ausgangsstufe beschaltet, wie in Abbildung 14 gezeigt.

Mit der Function pinMode() (siehe Abschnitt 3.12.3) kann der GPIO wahlweise als Eingang oder als Ausgang konfiguriert werden.

Wenn der GPIO als Eingang eingerichtet ist, sorgt eine interne Logik dafür, dass beide MOSFETSchalter S2 und S3 wie in Abbildung 14 geöffnet sind. Die gesamte Ausgangsstufe ist dadurch von dem GPIO-Pin getrennt.

Wenn der GPIO als Ausgang konfiguriert ist, kann der aktuelle Ausgangspegel über die Eingangsstufe auch eingelesen werden. Abbildung 14: GPIO-Konfiguration

Die Datenrichtung »Eingang« bzw. »Ausgang« eines GPIOs wird mit der Function pinMode() aus Abschnitt 3.12.3 konfiguriert.

Zur Ausgabe eines LOW - oder HIGH-Pegels an einen digitalen Ausgang gibt es die in Abschnitt 3.12.5 beschriebene Function digitalWrite() .

Um den Zustand an einem digitalen Eingang einzulesen, verwenden wir die in Abschnitt 3.12.6 beschriebene Function digitalRead()

2.7.2 Analoge Ein - / Ausgänge

Aus Abschnitt 2.1 wissen wir, dass ein Mikrocontroller intern ausschließlich digitale Daten – also Zahlenwerte – verarbeiten kann. Zur Kommunikation mit der analogen Außenwelt benötigt er Umsetzer, die analoge Größen in die von ihm verarbeitbaren digitalen Zahlenwerte und Umsetzer, die seine internen binären Zahlenwerte in analoge Größen konvertieren können (siehe Abbildung 7).

2.7.2.1 Die Analog / Digital - Umsetzung

Abbildung 9 zeigt, dass der Mikrocontroller ATmega328P auf dem MCCAB Trainingsboard, das wir in diesem Kurs für unsere Übungen verwenden, zur Umsetzung analoger Spannungen in die

2.7 Der Datenverkehr
21
mit der „Außenwelt“
i S2 0 V Interner Systembus +5 V RPU S1 S3 +5 V GPIO-Pin Interner Systembus Mikrocontroller +5 V S2 S3 Interner Systembus 0 V Pin

von ihm verarbeitbaren bi nären Zahlenwerte über einen Analog / Digital - Converter (ADC) auf seinem Chip verfügt In Abbildung 15 sehen wir eine Skizze des internen Aufbaus dieses ADCs

Das Ergebnis einer Analog / Digital - Wandlung ist eine 10 Bit große Binärzahl (zu »Binärzahlen« siehe Abschnitt 2.1.1). Der ADC des ATmega328P quantisiert das analoge Eingangssignal somit in 210 = 1024 Stufen (siehe hierzu Abbildung 3 und Abbildung 4 in Abschnitt 2.1).

Über den Analog-Multiplexer AMUX (ein Multiplexer ist das elektronische Äquivalent zu einem elektromechanischen Auswahlschalter, wie er in Abbildung 15 skizziert ist), kann eine von acht analogen Spannungen U A0 … U A7 an den Eingang des ADCs gelegt werden. Die Software wählt aus, um welchen Eingang es sich handeln soll. Der ADC des ATmega328P wandelt diesen analogen Spannungswert U ADC in einen natürlichen Zahlenwert Z (natürliche Zahlen sind ganzzahlig und größer oder gleich Null).

Der ADC bildet die Zahl Z aus der analogen Eingangsspannung U ADC gemäß der nachfolgenden Gleichung

Analog-Anschlüsse des Mikrocontrollers (zum Teil auf Stiftleiste SV6 des Trainingsboards herausgeführt)

AVcc = +5 V 1,1 V

Abbildung 15: Der Analog / Digital - Converter (ADC) des Mikrocontrollers ATmega328P

In Gleichung 1 ist U ADC die Eingangsspannung und UREF ist die Referenzspannung des Analog / Digital - Converters. N ist die Anzahl der Binärstellen des ADC -Ergebnisses, i m Fall des ATmega328P ist N = 10.

Über die Schalter REFS1 und REFS0 kann entweder die Betriebsspannung AVcc = +5 V des ADCs, eine Chip-interne +1,1 V-Spannung (in Abbildung 9 als »Internal Bandgap« bezeichnet) oder die Spannung UREF an Eingang REF der Stiftleiste SV6 auf dem MCCAB Trainingsboard als Referenzspannung für den ADC ausgewählt werden .

Der Zahlenbereich von Z hängt ab von der Auflösung des ADCs , d.h. von der Anzahl seiner Quantisierungsstufen. Allgemein wandelt ein N-Bit - ADC eine Spannung zwischen 0 V und UREF in 2N Zahlenwerte linear um. Die niedrigste Zahl hat den Wert 0 und die höchste Zahl hat den Wert 2N – 1. Für den 10 Bit - ADC unseres ATmega328P ergibt sich damit der Bereich

Z = 0 (210 – 1) = 0 1023

Mikrocontroller-Praxiskurs für Arduino-Einsteiger 22
1: Z = N REF ADC U U 2 = 1024 REF ADC U U , wobei 0  UADC < UREF (Gleichung 1)
ATmega328P
AMUX A1 A2 A3 A4 A5 A6 REF A7 A0 UREF REFS1 Z UADC REFS0 ADC A D

In der Grundeinstellung (Default) nach dem Einschalten der Betriebsspannung des MCCAB Trainingsboards befinden sich die Schalter REFS1 und REFS0 in der in Abbildung 15 gezeichneten Stell ung, d.h. die +5 V - Betriebsspannung AVcc des ADCs ist auch seine Referenzspannung UREF Der Eingang REF auf der Stiftleiste SV6 muss in diesem Fall unbeschaltet sein, da sonst über die beiden Schalter REFS1 und REFS0 eine Kurzschlussverbindung zwischen der Spannung an dem Anschluss REF und der Spannung AVcc besteht!

Mit seinen 210 = 1024 Quantisierungsstufen erreicht der ADC des ATmega328P bei der Referenzspannung U REF = +5 V eine Auflösung von

ULSB ist der kleinste auflösbare Spannungswert des ADCs, also der Spannungswert, der bei seiner A / D - Umsetzung die Zahl Z = 1 ergibt. Das LSB (Least Significant Bit) ist die niederwertigste Bitposition einer Binärzahl

Der zulässige Spannungsbereich an einem Analogeingang des Mikrocontrollers ist bei +5 V Referenzspannung somit U ADC = 0 +4,995 V.

Die Nichtbeachtung der folgenden Warnungen kann zu einer dauerhaften Beschädigung des ADCs oder des gesamten Mikrocontrollers führen!

1. Die Eingangsspannung U ADC des Analog / Digital - Converters muss immer kleiner sein als der Wert UREF der Referenzspannung!

2. Die Referenzspannung UREF des ADCs muss im Bereich +1,0 V  UREF  +AVcc liegen, sie darf keinesfalls größer als die Versorgungsspa nnung AVcc des Analog / Digital -Converters s ein! Auf dem MCCAB Trainingsboard ist die analoge Versorgungsspannung AVcc identisch mit der digitalen Versorgungsspannung Vcc = +5 V.

3. Wenn eine externe Spannung an den REF -Pin der Stiftleiste SV6 angeschlossen ist, dürfen die internen Referenzspannungen nicht verwendet werden (d.h. der Schalter REFS0 in Abbildung 15 muss geöffnet sein), da sonst ein Kurzschluss zwischen der mit Schalter REFS1 ausgewählten internen Spannung und der externen Spannung besteht.

Der Benutzer muss zuerst die gewünschte Referenzspannung einstellen, bevor er die externe Referenzspannung an den REF -Pin der Stiftleiste SV6 anschließt.

In der Arduino IDE gibt es die Function analogRead() – siehe Abschnitt 3.12.6 – zum Einlesen eines analogen Spannungswerts und die Function analogReference() – siehe Abschnitt 3.12.7 – zur Auswahl der Referenzspannung.

2.7.2.2 Die Digital / Analog - Umsetzung

Häufig muss ein Mikrocontroller die Ergebnisse seiner Arbeit wieder in einer analogen Form ausgeben, zum Beispiel um die Helligkeit von Leuchtmitteln oder die Drehzahl von Motoren zu steuern. Während aber fast alle Mikrocontroller über einen A / D - Converter (ADC) auf ihrem Chip verfügen, sind „echte“ D / A - Converter (DAC), die eine Gleichspannung als Ausgangswert liefern, eher selten und nur bei den h öherpreisigeren Mikrocontrollern anzutreffen. Doch praktisch alle Mikrocontroller verfügen über interne Timer -Bausteine (eine der »Zusatzfunktionen« in Abbildung 8), die in ihrem »PWM - Modus« (PWM = Pulsweitenmodulation) auf indirektem Wege die Ausgabe analoger Größen ermöglichen.

Bei einem PWM-Signal handelt es sich um ein Rechtecksignal uR , bei dem der Tastgrad (engl. duty cycle) variiert wird.

2.7 Der Datenverkehr mit
23
der „Außenwelt“
mV V U U N REF LSB 5 1024 5 2   
i

Der Tastgrad g ist das Verhältnis der Dauer des HIGH -Anteils tH (also der Pulsweite) eines Signals zu der gesamten Periodendauer T des Signals (siehe Abbildung 16):

Der Mittelwert UGl des PWM-Signals beträgt:

2)

wobei Û der Scheitelwert des Rechtecksignals uR ist (Abbildung 16).

Da Û und T konstante Größen sind, bewirkt demnach eine Änderung der Pulsweite tH eine proportionale Änderung des Mittelwertes UGl.

Ein dem Timerausgang zur Mittelwertbil dung nachgeschaltetes RC-Tiefpassfilter filtert aus dem Rechtecksignal uR den Gleichspannungsanteil UGl heraus (weitere Informationen hierzu zum Beispiel in [18] des Literaturverzeichnisses). Wenn man die Grenzfrequenz fg des Tiefpassfilters sehr klein gegenüber der Frequenz f = 1/T des PWM-Signals wählt, werden alle in dem Rechtecksignal enthaltenen höheren Frequenzanteile (fast) vollständig unterdrückt und man erhält am Ausgang des Tiefpassfilters nur noch den Gleichspannungsanteil des PWM -Signals.

Die nachfolgende Abbildung 16 zeigt drei PWM-Signale mit unterschiedlichen Tastgraden g und gestrichelt den daraus als Mittelwert resultierenden Gleichspannungsanteil UGl.

Abbildung 16: Gleichspannungsanteile verschiedener PWM-Signale

Je nach Anwendungsfall lässt sich der Effekt der Mittelwertbildung auch ohne ein nachgeschaltetes Tiefpassfilter erreichen. Voraussetzung ist, dass der angeschlossene Verbraucher eine au sreichende Trägheit aufweist.

Wenn wir z.B. eine Glühlampe oder eine Leuchtdiode direkt mit dem PWM -Signal dimmen, so wird die LED mit der Frequenz des PWM -Rechtecksignals (eini ge 100 Hz) ein- und ausgeschaltet, d.h. sie leuchtet für die Zeit des HIGH-Anteils „mit voller Kraft“ und für die Zeit des LOW -Anteils gar nicht. Für den „Dimmer -Effekt“ sorgt die Trägheit des menschlichen Auges, die es wie ein Tiefpassfilter wirken lässt. Ein „schnelles Auge“ würde tatsächlich eine mit der Frequenz des PWM-Signals flackernde LED sehen. Durch seine Trägheit nimmt das Auge aber nur den Mittelwert des eintreffenden Lichtsignals wahr, sodass wir eine kontinuierlich leuchtende LED mit der durch den Tastgrad eingestellten Helligkeit sehen.

Ein weiteres Beispiel ist die Steuerung der Drehzahl eines Gleichstrommotors. Auch er verhält sich durch seine mechanische Trägheit wie ein Tiefpassfilter, sodass wir durch Variation des Tastgrades g des PWM-Signals seine Drehzahl steuern können.

Wenn allerdings für ein Projekt eine echte Gleich spannung benötigt wird, müssen wir das erforderliche Tiefpassfilter als elektronische Schaltung realisieren, im einfachsten Fall mithilfe eines Widerstandes und eines Kondensators als RC -Tiefpassschaltung, Näheres hierzu findet man zum Beispiel in [18] des Literaturverzeichnisses

In der Arduino IDE gibt es die Function analogWrite()

siehe Abschnitt 3.12.8

zur Ausgabe einer digitalen 8 Bit - Zahl als PWM-Signal mit entsprechendem Tastgrad.

Mikrocontroller-Praxiskurs für Arduino-Einsteiger 24
T t g H 
U T t U g U H Gl ˆ ˆ     (Gleichung
i UGl UGl UGl T tH u u u t t t Û Û Û 0 0 0

Die Function analogWrite() wandelt natürliche Zahlenwerte (natürliche Zahlen sind ganzzahlig und größer oder gleich Null) in PWM-Signale mit entsprechendem Tastgrad um und gibt diese PWM-Rechtecksignale auf dem MCCAB Trainingsboard an der Stiftleiste SV5 aus (siehe Abschnitt 2.8) Da nicht alle GPIOs des Mikrocontrollers PWM-fähig sind, stehen nur die Anschlüsse ~IO3, ~IO5, ~IO6, ~IO9, ~IO10 und ~IO11 zur Verfügung. Das Zeichen »~« vor dem Namen des Anschlusses zeigt an, dass es sich um einen PWM -fähigen Ausgang des Mikrocontrollers handelt. Das PWM-Signal hat an den Anschlüssen ~D5 und ~D6 die Frequenz f PWM = 976 Hz und an allen anderen PWM-Anschlüssen die Frequenz f PWM = 490 Hz.

Allgemein können mit N Bit 2N verschiedene Zahlenwerte Z = 0 … (2N – 1) dargestellt werden Für den Tastgrad g des PWM-Signals bedeutet dies:

Der Function analogWrite() werden 8 Bit - Binärzahlen übergeben, d.h. N = 8, Z = 0 … 255. Daraus ergibt sich für den Tastgrad g des PWM-Signals:

(Gleichung 3)

Für den Mittelwert UGL des PWM-Signals erhalten wir:

2.7.3 Serielle Ein - / Ausgänge

Die AVRs, zu denen auch der ATmega328P auf dem Arduino® NANO Board zählt, sind »8 BitMikrocontroller«, d.h. es werden immer acht Bit ( = 1 Byte, siehe Abschnitt 2.1.1) gleichzeitig verarbeitet (siehe hierzu auch Abschnitt 3.2). Um ein Byte an die Außenwelt auszugeben, würden demnach acht parallele Leitungen und acht digitale Ausgangsports benötigt. Dies wurde in der Vergangenheit auch durchaus so gehandhabt (Stichworte: »Parallelport«, »Druckerschnittstelle«). Da aber die Anzahl der zur Verfügung stehenden Ein- / Ausgangspins bei einem Mikrocontroller begrenzt ist (auf dem Arduino® NANO stehen maximal 20 I/O-Ports zur Verfügung), muss zumeist sparsam mit ihnen umgegangen werden.

Um nun nicht acht „wertvolle“ – da nur in begrenzter Anzahl vorhandene – Ein- / Ausgabe-Pins (GPIOs) des Mikrocontrollers zu „verschwenden“ , werden zu einem Byte zusammengefasste Bits in den meisten Fällen nicht parallel über acht GPIOs gleichzeitig, sondern seriell, also Bit für Bit einzeln nacheinander über nur einen Pin ausgegeben, wie Abbildung 18, Abbildung 20 und Abbildung 21 beispielhaft zeigen Der Empfänger s etzt die acht nacheinander eintreffenden Bits wieder zu dem ursprünglichen Byte zusammen.

Bei der seriellen Datenübertragung werden die Bits mit einer definierten Taktfrequenz ausgegeben, die die Sendedauer der einzelnen Bits festlegt. Die Frequenz fT des Taktsignals bestimmt die Geschwindigkeit, mit der die Bits übertragen werden. Ist z.B. die Taktfrequenz fT = 1000 Hz, so hat ein Taktimpuls die Periodendauer TT = 1 / fT = 1 / 1000 Hz = 1 ms. Das bedeutet, dass die Übertragung eines Bits in diesem Beispiel 1 ms dauert bzw. in einer Sekunde 1000 Bits übertragen werden können.

Die Anzahl der Bits, die bei der eingestellten Taktfrequenz in einer Sekunde übertragen werden, wird als Bit-Rate bezeichnet ( bits per second, bits/s oder bps). Bei der Übertragung binärer Signale (also nur logisch 0 oder logisch 1) ist auch die Einheit Baud (symbols per second oder Bd) zulässig, die wir im Folgenden verwenden wer den, wenn es um die Einstellungen der seriellen Schnittstelle geht.

Bei seriellen Schnittstellen unterscheidet man zwischen synchroner und asynchroner Übertragung Bei einem synchronen Interface übermittelt der Sender auch das Taktsignal über einen separaten Ausgang an den Empfänger. Bei der asynchronen Schnittstelle muss der Empfänger

2.7 Der Datenverkehr
25
mit der „Außenwelt“
N H Z T t g 2  
256 28 Z Z g  
U Z U g U Gl ˆ 256 ˆ   (Gleichung 4)

durch die Messung der seit dem Startbit vergangenen Zeit den Beginn der einzelnen Bits selbst ermitteln. Dazu muss die durch die Baud Rate festgelegte Sendedauer der Bits exakt eingehalten werden. Dies ist bei den heutigen Mi krocontrollern sichergestellt, da deren Taktsystem quarzgenau arbeitet.

2.7.3.1 Synchrone Datenübertragung über die I2C-, SPI- und USART-Schnittstelle

Zum Datenaustausch mit externen integrierten Schaltungen, Sensoren oder Modulen kommen in der Elektronik häufig die I2C- oder die SPI-Schnittstelle zum Einsatz. Auf dem MCCAB Trainingsboard (Kapitel 2.8) zum Beispiel wird das LC -Display über die I2C-Schnittstelle gesteuert. Bei den AVR-Mikrocontrollern, zu denen auch der ATmega328P zählt, wird die I2CSchnittstelle als TWI-Schnittstelle (Two Wire Interface) bezeichnet. Die TWI-Schnittstelle ist funktionsgleich zur I 2C-Schnittstelle.

Wie Abbildung 9 zeigt, verfügt der Mikrocontroller ATmega328P auf seinem Chip sowohl über ein Hardware-SPI (Serial Peripheral Interface ), als auch über ein Hardware-I 2C (Inter-Integrated Circuit) - Interface, beides »Zusatzfunktionen« in Abbildung 8 zum synchronen seriellen Senden und Empfange n von Daten

Eine Sonderstellung nimmt der USART / UART des AVR in Abbildung 9 ein. Dieses Modul kann sowohl als U SART zur synchronen seriellen Übertragung als auch als UART zur asynchronen seriellen Übertragung nach dem RS -232 - Standard eingesetzt werden.

Bei Schnittstellen mit synchroner Übertragung (U SART, SPI, TWI = I 2C) synchronisiert ein Taktsignal den Empfänger mit dem Sender und zeigt an, wann der Sender ein neues Bit an seinen Datenausgang geschoben hat und wann der Empfänger es an dessen Dateneingang übernehmen kann.

Das Taktsignal wird von dem Sender erzeugt und ist mit dem Takteingang d es Empfängers verbunden Der serielle Datenausgang des Senders ist mit dem seriellen Dateneingang des Empfängers verbunden.

Arduino-Board)

Abbildung 17: Verbindung des Senders mit dem Empfänger bei einer synchronen seriellen Übe rtragung

Die nachfolgende Abbildung 18 zeigt den prinzipiellen Ablauf der synchronen seriellen Übertragung eines aus acht Bits B0 … B7 bestehenden Datenwortes.

 : nächstes Bit herausschieben  : Bit übernehmen

Abbildung 18: Prinzip der synchronen seriellen Übertragung von acht Datenbits

Mikrocontroller-Praxiskurs für Arduino-Einsteiger 26
B0 B1 B2 B3 B4 B5 B6 B7 1 2
t Takt Datenbits t TT Sender (z.B.
Daten Takt Daten Takt Empfänger (z.B. LC-Display)

Bei der synchronen seriellen Übertragung eines Bytes gemäß Abbildung 18 schiebt der Sender die acht Bits nacheinander an seinen seriellen Datenausgang , der mit dem seriellen Dateneingang der Gegenseite verbunden ist . Mit der steigenden Flanke des Taktsignals zeigt er dem Empfänger an, dass ein Bit zum Datenausgang geschoben wird und mit der fallenden Flanke signalisiert er dem Empfänger, dass das Bit nun stabil auf der Datenleitung anliegt und übernommen werden kann. Mit jeder fallenden Flanke des Taktsignals nimmt der Empfänger ein an seinem seriellen Dateneingang anliegendes Bit entgegen und schiebt es in das „Empfangsbyte“ hinein. Nach acht Taktimpulsen ist ein vollständiges Byte zum Empfänger übertragen.

2.7.3.2 Asynchrone Datenübertragung über den UART des Mikroc ontrollers

Der Mikrocontroller ATmega328P auf dem MCCAB Trainingsboard (Kapitel 2.8) verfügt auf seinem Chip über einen Hardware-UART (Universal Asynchronous Receiver / Transmitter, eine der »Zusatzfunktionen« in Abbildung 8) zum seriellen Senden und Empfangen von Daten. In dem Blockschaltbild in Abbildung 9 sehen wir die Bezeichnung USART (Universal Synchronous and Asynchronous Receiver / Transmitter), da diese serielle Schnittstelle wahlweise auch synchron betrieben werden kann. Um ein Byte über den UART auszugeben, muss die CPU das zu übertragende Byte lediglich in das Senderegister des UARTs schreiben, um alles Weitere kümmert sich der UART. Ein von einem externen Sender seriell empfangenes Byte schreibt der UART eigenständig in ein Empfangsregister, aus dem es die CPU auslesen kann. In der Arduino IDE (Kapitel 3.6) erfolgt das asynchrone serielle Aussenden und Einlesen von Daten über Buffer. Sowohl der Empfangs - als auch der Sende-Buffer sind 64 Byte große Bereiche im Arbeitsspeicher (RAM) , die – vom Anwender unbemerkt – von der Arduino IDE im Hintergrund verwaltet werden. Sobald ein Byte über den UART eintrifft, wird es aus dem Empfangsregister des UARTs automatisch in den Empfangs -Buffer übertragen, aus de m es das Anwender-Programm mit der in Abschnitt 3.12.14.4 besprochenen Methode Serial.read() auslesen kann. Wenn das Anwender-Programm ein Byte senden möchte, schreibt es dieses mit der in Abschnitt 3.12.14.2 besprochenen Methode Serial.print() in den Sende-Buffer und sobald der UART zur Übertragung bereit ist, wird das nächste Byte automatisch aus dem Buffer geholt und in das Senderegister des UARTs geschrieben.

Abbildung 19: Kommunikation zweier Geräte über die asynchrone serielle Schnittstelle

In Abbildung 19 sehen wir, wie zwei Geräte zur Kommunikation über die asynchrone serielle Schnittstelle verschaltet werden. Über seine n Ausgang Tx (Transmitter) sendet der UART die einzelnen Bits zum Empfänger, über seinen Eingang Rx (Receiver) empfängt der UART die vom gegenüberliegenden Sender geschickten Bits. D er Sendeausgang Tx des einen Gerätes muss deshalb jeweils mit de m Empfangseingang Rx des anderen Gerätes verbunden werden.

Abbildung 20 zeigt prinzipiell die asynchrone serielle Übertragung eines aus acht Bits bestehenden Bytes über den UART. Im Ruhezustand liegen die Leitungen Tx bzw. Rx auf +5 V-Pegel. Den Beginn einer Über tragung kündigt der Sender durch das Start -Bit an, das die Leitung Tx auf das Potenzial 0 V legt. Darauf folgen die einzelnen Datenbits, beginnend mit dem niederwertigsten Bit B0 des Bytes. In der Regel werden genau die acht Bits eines Bytes übertragen, b ei den meisten UARTs – auch dem des ATmega328P – kann aber auch eine davon abweichende Anzahl von Datenbits eingestellt werden.

2.7 Der Datenverkehr mit
27
der „Außenwelt“
Gerät 1 Gerät 2 Tx Rx UART Rx Tx UART

Nach dem letzten Datenbit kann zu einer einfachen Überprüfung der Korrektheit der Übertragung ein Paritätsbit folgen. Dabei kann man die Überprüfung auf gerade oder ungerade Parität einstellen. Bei Überprüfung auf gerade Parität wird das Paritätsbit so gewählt, dass die Summe aller Datenbits und des Paritätsbits eine gerade Zahl ergibt. Bei Überprüfung auf ungerade Parität wird das Paritätsbit so gewählt, dass die Summe aller Datenbits und des Paritätsbits eine ungerade Zahl ergibt. Wenn nun z.B. bei einem empfangenen Byte die Summe aller Datenbits und des Paritätsbits eine ungerade Zahl ergibt, obwohl gerade Par ität eingestellt wurde, kann das Anwenderprogramm daraus erkennen, dass ein Fehler bei der Übertragung aufgetreten sein muss.

Nach dem Paritätsbit oder – falls auf die Paritätsprüfung verzichtet wird – nach dem letzten Datenbit folgen ein oder zwei Stopp-Bits mit +5 V-Pegel auf der Datenleitung. Wenn eine weitere Datenübertragung ansteht, kann nach dem Stopp -Bit sofort wieder ein neues Start -Bit folgen, ansonsten geht die Leitung in den Ruhezustand über, d.h. sie bleibt auf dem +5 V-Pegel des Stopp-Bits.

Der Bedienungsanleitung des MCCAB Trainingsboards (siehe Literaturhinweis [6]) lässt sich entnehmen, dass beim Arduino® NANO die seriellen Anschlüsse TxD und RxD des ATmega328P über zwei Schutzwiderstände mit der integrierten Wandlerschaltung verbunden sind, die die USB-Schnittstelle des als Entwicklungsstation verwendeten PCs an die UART-Schnittstelle des ATmega328P anpasst.

Abbildung 20: Serielle asynchrone Übertragung eines Bytes über den UART

Die Grundeinstellung in der Arduino IDE für die asynchrone serielle Übertragung sind 8 Datenbits, keine Überprüfung der Parität und 1 abschließendes Stopp-Bit. Mittels der in Abschnitt 3.12.14.1 besprochenen Methode Serial.begin() können diese Einstellungen bei Bedarf geändert werden.

Beispiel: Übertragung des Datenbytes 0110 01012 = 6516 über die serielle Schnittstelle des Mikrocontrollers ATmega328P in der Konfiguration der Arduino IDE, d.h. ohne Paritätsbit.

Abbildung 21: Serielle asynchrone Übertragung des Bytes 0110 01012 über den UART

Mikrocontroller-Praxiskurs für Arduino-Einsteiger 28
t Tx / Rx Ruhezustand (Idle) StartBit Datenbits 0 … 7 StoppBit 0 1 2 6 3 5 4 7 +5 V 0 V t Tx / Rx Ruhezustand (Idle) StartBit Datenbits (logisch 0 oder 1) ParitätsBit StoppBit(s) 0 1 2 3 5 6 4 7 +5 V 0 V

2.8 Das MCCAB Trainingsboard

Im Prinzip könnten wir die für unsere praktischen Übungen in Kapitel 4 des Buches benötigten Schaltungen auch mit diskreten Bauteilen realisieren, die wir zusammen mit einer Menge von Verbindungskabeln auf ein Steckbrett (engl. Breadboard) stecken. Diese Steckerei nimmt aber oft mehr Zeit in Anspruch als das Schreiben des eigentlichen Programms und die Schaltung z.B. für ein Lauflicht mit 11 Leuchtdioden und den zugehörigen Vorwiderstä nden auf einem Breadboard ist alles andere als übersichtlich . Außerdem stellt ein solcher Har dwareaufbau eine nicht zu vernachlässigende Fehlerquelle dar! Aus diesen Gründen wurde das MCCAB Trainingsboard entwickelt. Auf dieser Leiterplatte ist eine umfangreiche Palette an Zubehörbauteilen (Schalter, Taster, Leuchtdioden, Potenziometer, Summer , LC-Display , Schnittstellen und Pegelwandler für serielle Verbindungen, Treiberstufen für externe Verbraucher) bereits mit dem aufgesteckt en Mikrocontrollermodul verschaltet oder kann durch einfache Steckbrücken (Jumper) mit ihm ve rbunden werden. Auch ganze externe Baugruppen können über eine Buchsenleiste an das MCCAB Trainingsboard angesteckt oder über die auf dem Trainingsboard vorhandenen seriellen Schnit tstellen mit ihm verbunden und von dem Mikrocontroller auf dem Trainingsboard gesteuert werden Dadurch entfällt der lästige Aufbau der Übungsschaltung en und wir können uns auf das Wesentliche – also unsere Software, das »Programm« – konzentrieren.

Die in unseren Übungen erstellten Programme werden wir also in den Mikrocontroller ATmega328P auf dem MCCAB Trainingsboard laden und von ihm ausführen lassen Abbildung 1 zeigt den Mikrocontroller-Chip ATmega328P. Einige der 32 in Abbildung 1 sichtbaren Ans chlusspins des Mikrocontrollers dienen zu seiner Spannungsversorgung, zum A nschluss eines Quarzes für seinen zur Taktgenerierung eingebauten Oszillator oder als Reset-Eingang für den Tastschalter auf dem Mikrocontroller-Modul (Pfeil (1a) in Abbildung 22), dessen Betätigung den Mikrocontroller in eine n definierten Ausgangszustand zurückversetzt und das Programm neu startet

Die große Mehrheit der Anschlüsse steht aber als allgemeine Ein- / Ausgänge (GPIOs, General Purpose Inputs / Outputs , siehe Abschnitt 2.7.1) zur Verfügung, über die der Mikrocontroller mit der Außenwelt in Verbindung treten kann. Auf dem MCCAB Trainingsboard sind diese Pins – bis auf wenige für interne Zwecke reserviert e Ausnahmen – an die Anschlussleisten SV5 und SV6 ( in Abbildung 22) herausgeführt. Bei den Anschlüssen D2 bis D13 handelt es sich um digitale Ein- / Ausgänge (GPIOs), die Anschlüsse A0 bis A3 können darüber hinaus auch wahlweise mit dem internen ADC (Analog / Digital Converter) des ATmega328P verbunden und so als analoge Ei ngänge verwendet werden.

Das MCCAB Trainingsboard ist mit vielen Hardware - Komponenten (Schalter, Taster , Leuchtdioden, Potenziometer, Summer , LC-Display ) bestückt, die die Durchführung zahlreicher – auch für Anfänger sehr gut geeigneter – Übungen ermöglichen.

Abbildung 22 zeigt eine Ansicht des MCCAB Trainingsboards mit seinen farblich markierten Funktionsblöcken. Die Bedienungsanleitung für das MCCAB Trainingsboard mit einer ausführlichen Beschreibung aller Komponenten kann über den in Abschnitt 8.2 genannten Link kostenlos auf den eigenen PC heruntergeladen werden.

Die Funktionsblöcke auf dem MCCAB Trainingsboard

(1) Mikrocontroller-Modul Arduino® NANO mit RESET-Taster (Pfeil 1a), Leuchtdiode »L« (Pfeil 1b) und Mini-USB - Buchse zur Verbindung mit dem PC des Anwenders.

(2) Anschlussleisten SV5 und SV6 für die Mikrocontroller-Ein- / Ausgänge . Über diese beiden Verteilerleisten können die GPIOs (General Purpose Inputs / Outputs) des Mikrocontrollers mittels Dupont-Kabeln mit internen Komponenten des Trainingsboards oder externen Modulen verbunden werden.

2.8 Das MCCAB Trainingsboard 29

(3) 11 LEDs LD10 … LD20 (Zustandsanzeigen für die Ein- / Ausgänge D2 … D12 des Mikr ocontrollers), jede LED kann über eine Steckbrücke (Jumper) auf der Pfostenleiste JP6 mit dem zugeordneten GPIO D2 … D12 verbunden werden .

(4) 3  3 - LED-Matrix LD1 … LD9 (9 rote Leuchtdioden). Die Spal tenleitungen sind fest mit den Ausgängen D6 … D8 des Mikrocontrollers verbunden, die Zeilenleitungen können durch Steckbrücken (Jumper) auf der Pfostenleiste JP1 mit den GPIOs D3 D5 verbunden werden.

Vorsicht: Wenn die Zeilenleitungen der 3  3 - LED-Matrix entweder über Jumper auf der Pfostenleiste JP1 mit den GPIOs D3 D5 oder über Dupont-Kabel mit anderen GPIOs des Mikrocontrollers verbunden sind, dürfen die se Zeilenleitungen sowie die Spaltenleitungen D6 D8 in einem Sketch keinesfalls für andere Aufgaben verwendet werden. Eine Doppelbelegung der Ma trix-GPIOs würde zu Fehlfunktionen oder sogar zur Beschädigung des MCCAB Trainingsboards führen!

(5) LC-Display mit 2 x 16 Zeichen, über den I 2C-Bus verbunden mit den Pins A4 und A5 des Mikrocontrollers. Die Betriebsspannung des LCDs kann in Übungen, in denen die Anzeige nicht verwendet wird, durch Ziehen der Steckbrücke JP5 abgeschaltet werden.

(6) Piezo-Summer Buzzer1, kann über eine Steckbrücke (Jumper) auf der Position »Buzzer« der Pfostenleiste JP6 mit dem GPIO D9 des Mikrocontrollers verbu nden werden.

Mikrocontroller-Praxiskurs für Arduino-Einsteiger 30
Abbildung 22: Blockschaltbild des MCCAB Trainingsboards 3.3 8 11 4 3 6 5 12 6 9 7 10 2 2 1a 9 1b 1

(7) 6 Schiebeschalter S1 … S6, parallelgeschaltet zu 6 Tastern K1 … K6. Sie können über Steckbrücken (Jumper) auf der Pfostenleiste JP2 mit den Eingängen A0 … A3, D12 und D13 des Mikrocontrollers verbunden werden.

(8) Potenziometer P1 und P2 , ihre Schleifer sind verbunden mit den Analog-Eingangspins A6 bzw. A7 des Mikrocontrollers . Über die Pfostenleiste JP3 kann wahlweise die Spannung 3,3 V oder 5 V an die Potenziometer gelegt werden.

Vorsicht:

Die Pins A6 und A7 des ATmega328P sind aufgrund der internen ChipArchitektur als analoge Eingänge festgelegt. Ihre Konfiguration mit der Function pinMode() (siehe Abschnitt 3.12.3) ist nicht gestattet und kann zu einem Fehlverhalten des Programms führen.

(9) Anschlussleisten SV1 und SV7, Schaltausgänge für externe Geräte .

(10) Pfostenleisten zum seriellen Anschluss externer SPI- und I2C-Module .

(11) Anschlussleiste SV2 mit 2 x 13 Pins zum Anschluss externer Module .

(12) Anschlussleiste SV4, Verteiler für die Betriebsspannungen des Boards . Die Spannungen können mittels Dupont-Kabeln mit internen Komponenten des Trainingsboards oder externen Modulen verbunden werden .

Auf die beiden etwas komplexeren Funktionseinheiten 3 x 3 - LED-Matrix ( in Abbildung 22) und LC-Display ( in Abbildung 22) wollen wir hier noch etwas ausführlicher eingehen, für alle anderen sei auf die oben erwähnte ausführliche Beschreibung in der Bedienungsanleitung des MCCAB Trainingsboards (Download-Link in Abschnitt 8.2) verwiesen.

Zur Steuerung der 3 x 3 - LED-Matrix , der LEDs LD10 … LD20, der Taster K1 … K6 und Schalter S1 … S6 sowie des Summers Buzzer1 steht die Bibliothek MCCAB_Lib (siehe Kapitel 3.14) zur Verfügung, die von den Käufern des Boards kostenlos von der in Abschnitt 8.2 genannten Website heruntergeladen und in die Arduino IDE integriert werden kann.

Zur Steuerung des LC -Displays verwenden wir die Bibliothek LiquidCrystal_I2C (siehe Kapitel 3.15), die kostenlos aus dem Internet in die Arduino IDE heruntergeladen werden kann.

Die 3  3 - LED-Matrix

Auf dem MCCAB Trainingsboard befinden sich neun Leuchtdioden, die in Form ei ner Matrix angeordnet sind ( in Abbildung 22). Abbildung 23 zeigt ihre prinzipielle Beschaltung.

Die Matrix besteht aus drei Spalten und drei Zeilen. Die Spalten sind mit A, B und C bezeichnet, die Zeilen sind von 1 bis 3 durchnummeriert. An jedem der neun Kreuzungspunkte einer Zeile mit einer Spalte ist eine Leuchtdiode platziert, deren Anode mit der Spaltenleitung und deren Kathode mit der Zeilenleitung verbunden ist. Die neun LEDs sind nach den an sie a ngeschlossenen Spalten und Zeilen bezeichnet, z.B. liegt LED »B2« an Spalte B und Zeile 2.

Damit eine LED leuchtet, muss ihre Spaltenleitung auf logisch 1 (+5 V) und Ihre Zeilenleitung auf logisch 0 (0 V) liegen.

Der Bedienungsanleitung für das MCCAB Trainingsboard ist zu entnehmen, dass die Spaltenleitungen fest mit den GPIOs D6, D7 und D8 des Mikrocontrollers verbunden s ind.

Die Zeilenleitungen können über Steckbrücken auf der Pfostenleiste JP1 mit den GPIOs D3, D4 und D5 des Mikrocontrollers verbunden werden.

2.8 Das MCCAB Trainingsboard 31
i

Wenn die Zeilenleitungen der 3  3 - LED-Matrix entweder über Jumper auf der Pfostenleiste JP1 mit den GPIOs D3 D5 oder über Dupont-Kabel mit anderen GPIOs des Mikrocontrollers verbunden sind, dürfen diese Zeilenleitungen sowie die Spaltenleitungen D6 … D8 in einem Sketch nicht für andere Aufgaben verwen det werden. Eine derartige Beschaltung der Matrix-GPIOs würde zu Fehlfunktionen oder schlimmstenfalls sogar zur Beschädigung des MCCAB Trainingsboards führen!

Wenn die Matrix in einem Sketch nicht verwendet wird, sollten die Steckbrücken (Jumper) auf der Pfostenleiste JP1 des MCCAB Trainingsboards entfernt werden.

Vorteil der Matrix-Anordnung

Würden wir neun Leuchtdioden einzeln steuern, so wären dazu 9 GPIOs des Mikrocontrollers erforderlich. Durch die Anordnung der LEDs in Form einer Matrix benötigen wir dagegen nur 6 GPIOs. Je mehr LEDs angesteuert werden, umso mehr tritt der Vorteil der Matrixsteuerung zutage: Mit einer aus 8 Spalten und 8 Zeilen bestehenden Matrix kann man 64 LE Ds steuern. Gegenüber der Einzelansteuerung können so 48 GPIOs eingespart werden!

LED-Matrizen kennen wir z.B. aus der Bandenwerbung in Fußballstadien, wo farbige Hochleistungs-LEDs in Matrix -Anordnung zur Erzeugung bewegter Bilder zum Einsatz kommen.

Ansteuerung der Matrix im Multiplexbetrieb

Abbildung 23 kann man entnehmen, dass jede Spal tenleitung und jede Zeilenleitung der Matrix auf dem MCCAB Trainingsboard mit jeweils drei LEDs verbunden ist. Somit würde die gleichzeitige Ansteuerung al ler Zeilen und Spalten nicht funktionieren, da ungewollt LEDs, die eigent lich ausgeschaltet sein sollten, ebenfalls leuchten würden. Stattdessen darf – wie in Abbildung 24 gezeigt – immer nur eine Zeilenleitung aktiv sein und die Spaltenleitungen müssen das Bitmuster für die drei LEDs der gerade aktivierten Zeile anlegen. Die beiden anderen Zeilenleitungen müssen während dieser Zeit offen oder durch einen angelegten HIGH-Pegel abgeschaltet sein, sodass über sie kein Strom fließen kann.

Wenn die drei Zeilen in genügend rascher Folge wie in Abbildung 24 zyklisch aktiviert werden, sieht der Betrachter aufgrund der Trägheit des menschlichen Auges ein stehendes Bild aller neun LEDs. Die Ansteuerung der LED -Matrix durch das Anwenderprogramm erfolgt in einer Endlosschleife, in welcher zyklisch eine der drei Zeilen 1, 2 oder 3 auf LOWPotenzial gelegt wird, während die beiden anderen Zeilen auf HIGH-Pegel liegen. Die Spaltenanschlüsse aller Leuchtdioden, die in der gerade aktiven Zeile (LOW-Pegel) leuchten sollen, werden auf HIGH-Pegel gelegt. Die Spaltenanschlüsse der LEDs in der aktiven Zeile, die nicht leuchten sollen, liegen auf LOW-Potenzial.

Um z.B. die beiden LEDs A3 und C3 leuchten zu lassen, müssen Zeile 3 auf LOW-Pegel und die Spalten A und C auf HIGH-Pegel liegen, während die beiden Zeilenleitungen 1 und 2 auf HIGH-Pegel liegen und Spalte B LOW-Pegel führt.

Mikrocontroller-Praxiskurs für Arduino-Einsteiger 32
A1 B1 C1 C2 B2 A2 A3 B3 C3 Zeile 2 D4 Zeile 3 D5 Spalte A D8 Spalte B D7 Spalte C D6 Zeile 1 D3
Abbildung 23: 3 x 3 LED - Matrix

Abbildung 24: Periodische schrittweise Aktivierung der drei Zeilen der Matrix

Das LC (Liquid Crystal) - Display

Das MCCAB Trainingsboard ist mit einem LC-Display (LCD) ausgerüstet, das die Ausgabe von Texten, Zahlenwerten und sogar selbstdefinierten Sonderzeichen ermöglicht. Das eingesetzte Display verfügt über 2 Zeilen mit jeweils 16 Spalten, in jeder Spalte kann ein Zei chen dargestellt werden. Jedes Zeichen wird aus den Punkten einer 5  8 - Matrix gebildet, wie in Abbildung 26 zu sehen ist. Die erforderlichen Bitmuster der 5  8 - Punktmatrix für jedes einzelne Zeichen sind gemäß der ASCII-Tabelle aus Abschnitt 8.1 im Inneren des LCD-Controllers abgespeichert. Nun ist der ASCII -Code (siehe hierzu Abschnitt 3.3.1) ein 7 Bit-Code (das achte Bit des ASCIIZeichencodes hat den Wert 0), unser Mikrocontroller ATmega328P ist aber eine »8 Bit - Maschine«, er kann demnach ein Byte in einem Arbeitsschritt verarbeiten und speichert auch seine Daten im Byte -Format. Die Entwickler des Display -Controllers HD44780 (der in dieser Kategorie Standard ist und sich auf fast allen LCD -Modulen befindet) wollten das achte Bit des Bytes nicht ungenutzt lassen und haben den ASCII-Zeichensatz um weitere 128 Zeichen codes erweitert, bei denen das achte Bit auf logisch 1 liegt. Daher sind bei unserem LCD auch die Zeichencodes 128 bis 255 (mehr oder weniger durchgehend, siehe Abbildung 25) mit Zeichen belegt.

Der ASCII-Code weist neben den 95 druckbaren Zeichen mit den Codes 32 … 126 auch 33 Steuerzeichen mit den ASCII-Codes 0 … 31 und 127 auf, die nicht druckbar sind. Das Display wertet diese Steuerzeichen nicht zu Steuerungszwecken aus . Der Display -Controller HD44780 ist in zwei Versionen lieferbar: Mit dem ROM -Code A00 oder alternativ mit dem ROM -Code A02. Die Version A00 zeigt bei den Codes 16 … 31 sowie 128 … 159 leere Punktmatrizen an. Die Version A02 dagegen nutzt auch diese Adressräume zur Zeichenausgabe (siehe Abbildung 25). Welche der beiden ROM-Varianten i n dem LC-Display des MCCAB Trainingsboards verbaut ist, kann nicht vorhergesagt werden, diese Auswahl trifft der Hersteller des LCD-Moduls.

Für den Anwender besteht die Möglichkeit, bis zu acht eigene Sonderzeichen selbst zu definieren und auf dem LCD anzuzeigen. Diesen acht Sonderzeichen sind die ASCII -Codes 0 bis 7 zugewiesen. Wahlweise können die gleichen acht Sonderzeichen auch über die ASCII -Codes 8 bis 15 angesprochen werden.

Die Tabelle in Abbildung 25 zeigt die Belegung des Zeichenspeichers der beiden Varianten. In Übung 42 zeigen wir den Zeichensatz des LCDs auf unserem MCCAB Trainingsboard an.

Abbildung 25: Belegung des Zeichenspeichers der beiden HD44780-Varianten

2.8 Das MCCAB Trainingsboard 33
Zeichen-Code ROM -Code A00 ROM -Code A02 0 … 7 Sonderzeichen des Anwenders Sonderzeichen des Anwenders 8 … 15 Sonderzeichen des Anwenders Sonderzeichen des Anwenders 16 … 31 (keine Anzeige ) sichtbare Zeichen 32 … 127 sichtbare Zeichen sichtbare Zeichen 128 …
(keine Anzeige ) sichtbare Zeichen 160 … 255 sichtbare Zeichen sichtbare Zeichen
159
Zeile 1 Zeile 2 Zeile 3 LOW HIGH HIGH Zeile 2 Zeile 1 Zeile 3 LOW HIGH HIGH Zeile 3 Zeile 1 Zeile 2 LOW HIGH HIGH Zeile 1 Zeile 2 Zeile 3 LOW HIGH HIGH Schritt 1 Schritt 2 Schritt 3 Schritt 1 …

Abbildung 26 kann die Nummerierung der Zeilen und Spalten des Displays entnommen werden, die in beiden Fällen mit 0 beginnt. Durch die Angabe dieser Koordinaten kann ein Zeichen gezielt an eine bestimmte Stelle des Displays geschrieben werden. Zu diesem Zweck verfügt das LCD über einen Cursor, der die Position des zu schrei benden Zeichens festlegt. Die in Kapitel 3.15 beschriebene LCD-Bibliothek enthält Methoden zur Positi onierung dieses Cursors (siehe Tabelle in Abbildung 83).

Das Display kann zwar in jeder Zeile nur 16 Zeichen anzeigen, der Speicher, in dem die Zeichen im Display-Controller abgelegt werden, verfügt aber für jede Zeile über 40 Speicherplätze. Wie man in Abbildung 27 sieht, besteht zwischen der letzten Display -Adresse 39 der ersten Zeile und der Anfangsadresse 64 der zweiten Zeile eine Lücke von 24 Speicherplätzen.

Durch Schiebebefehle, die in der in Kapitel 3.15 beschriebenen LCD -Bibliothek enthalten sind (siehe Tabelle in Abbildung 83), kann der im Display sichtbare Speicherbereich wie ein Fenster über den gesamten Speicherbereich geschoben werden (siehe hierzu auch Abbildung 160 und Abbildung 161).

Abbildung 26: Prinzipdarstellung des verwendeten LC-Displays mit 16  2 darstellbaren Zeichen

Abbildung 27 zeigt oben das sichtbare Fenster des Displays in der Grundeinstellung ohne vorherige Schiebeoperationen , in der Mitte den Displayinhalt der Grundeinstellung nach einer Schiebeoperation nach links und unten den Displayinhalt der Grundeinstellung nach einer Schiebeoperation nach rechts.

Abbildung 27: Der sichtbare Inhalt des Displays vor und nach Schiebeoperation en

Mikrocontroller-Praxiskurs für Arduino-Einsteiger 34
16 17 36 37 38 39 00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 100 101 102 103 00 17 36 37 38 39 64 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 100 101 102 103 15 16 17 36 37 38 00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 64 65 66 67 68 69 70 71 72 72 74 75 76 77 78 79 80 81 100 101 102 39 103 Adressen des Display- Zeichenspeichers Sichtbarer Bereich nach Rechts - Shift Sichtbarer Bereich nach Links - Shift 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 Fenster - Position 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 Fenster - Position 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 Fenster - Position 0 1 2 4 3 15 14 13 12 11 10 5 6 7 9 8 0 1 Spalten-Nr. ZeilenNr.

Die Einstellung des LCD -Kontrastes

Im Auslieferungszustand des MCCAB Trainingsboards ist der Kontrast des Displays bereits eingestellt. Da sich der Kontrast des Displays aber durch die Umgebungsbedingungen (Temperatur) oder durch Alterung geringfügig verändern kann, hat das LCD zur Einstellung des Kontrastes ein Trimmpotenziometer, das von de r Unterseite des MCCAB Trainingsboards zugänglich und mit einem Pfeil markiert ist. So kann der Kontrast bei Bedarf mit einem kleinen Schraubendreher jederzeit nachjustiert werden.

Die Übertragung der Daten vom Mikrocontroller zum LC -Display

Auf jedem LCD -Modul befindet sich ein Display -Controller HD44780, der die vom Mikrocontroller gesendeten (ASCII-)Codes der Zeichen über ein Interface entgegennimmt, aus den Codes die entsprechenden Zeichen der oben erwähnten 5  8 - Punktmatrix generiert und diese auf der Anzeigefläche darstellt.

Der LCD-Controller HD44780 verfügt nur über eine parallele Schnittstelle zum Empfang der darzustellenden Daten, d.h. der Mikrocontroller schreibt ein aus acht Bits D0 … D7 bestehendes Datenbyte mithilfe dreier Steuersignale RS, RW, E in das Eingangsregister des Display-Controllers HD44780 auf dem LCD, wie in Abbildung 28 gezeigt. Dieses Verfahren der parallelen Datenübertragung würde die Ressourcen auf dem MCCAB Trainingsboard erheblich einschränken, denn von den insgesamt 16 frei verfügbaren Pins des Mi krocontrollers ATmega328P wären bereits 11 alleine durch das LCD belegt!

Abbildung 28

Auch die zweite Möglichkeit der Datenübertragung zum LCD -Controller HD44780, bei der die 8 Datenbits in zwei Paketen zu je 4 Bits nacheinander übertragen werden, bringt noch keine wirkliche Abhilfe, denn auch in diesem Fall wären immerhin noch 7 Pins des Mikrocontrollers durch das LCD gebunden , da die drei Steuersignale RS, RW, E auch in diesem Fall benötigt werden.

Aus diesem Grund wird das LC -Display auf dem MCCAB Trainingsboard über den I 2C-Bus, einen synchronen seriellen Bus gesteuert, der nur aus einer Datenleitung SDA und einer Taktleitung SCL besteht und die Daten nacheinander Bit für Bit nach einem ähnlichen Ve rfahren wie dem in Abbildung 18 gezeigten überträgt. Der Datenverkehr über die I 2C-Schnittstelle erfolgt dabei über die beiden Leitungen A4 (SDA) und A5 (SCL) des Mikrocontrollers ATmega328P (Abbildung 29). Ein zusätzlicher Adapter an der Unterseite des LCD -Moduls setzt die I 2C-Signale in die parallelen Sign ale gemäß Abbildung 28 um.

Abbildung 29

Wie Abbildung 29 zeigt, nutzt der Adapter dabei das oben erwähnte Verfahren der Übertragung von zweimal 4 Bits nacheinander über die Datenleitungen D4 … D7, es werden also zuerst die Datenbits D4 D7 und danach die Datenbits D0 D3 über dieselben Leitungen D4 D7 übertragen.

Da die beiden Leitungen A4 und A5 des Mikrocontrollers auf dem MCCAB Trainingsboard ohnehin für die I 2C - Schnittstelle reserviert sind, gehen bei dieser Art der Datenübertra gung zum LCD keinerlei Ressourcen verloren, denn an den I 2C-Bus können per Prinzip mehrere Teilnehmer gleichzeitig angeschlossen werden. Da jeder an den Bus angeschlossene Teilnehmer seine eigene I 2C-Adresse hat, fühlt er sich nur dann angesprochen, wenn ein Datenpaket mit seiner Adresse eintrifft.

2.8 Das MCCAB Trainingsboard 35
RS RW E D0 D1 D2 D3 D4 D5 D6 D7 LCDisplay Adapter Mikrocontroller A4 A5 SDA SCL Mikrocontroller RS RW E D0 D1 D2 D3 D4 D5 D6 D7 LCDisplay

Das LC -Display auf dem MCCAB Trainingsboard hat im Normalfall die I2C-Adresse 0x27 Falls die Adresse herstellerbedingt einmal abweichen sollte, ist dies auf dem Display angegeben .

Mikrocontroller-Praxiskurs für Arduino-Einsteiger 36
i
Issuu converts static files into: digital portfolios, online yearbooks, online catalogs, digital photo albums and more. Sign up and create your flipbook.