Mikrocontroller-Basics mit PIC (Leseprobe) by Elektor

Tam Hanna programmiert und entwickelt seit mehr als 15 Jahren Microcontrollerund Prozessrechner systeme für verschiedene Anwendungsfälle. Neben seiner Consultingtätigkeit hält er Vorträge auf Kongressen, verfasst Fachartikel für diverse Magazine und agiert als Tutor. Sein viel beachteter Instagram-Kanal liefert Hintergrundinformationen zu Messtechnik und Elektronik.

ISBN 978-3-89576-339-7

Die Einführung in die Mikrocontroller-Programmierung dekliniert der Autor an Mikrocontrollern aus der PIC-Familie durch. Der PIC mit seinem 8-Bit-Design ist nicht auf dem modernsten technischen Stand, aber dafür einfach zu verstehen. Er wird in einem DIP-Gehäuse angeboten, ist über all erhältlich und nicht besonders komplex. Das gesamte Datenblatt des PICs ist um Dekaden kürzer als die Architekturbeschreibung, die den Prozessor eines fortgeschrittenen Mikrocontrollers beschreibt. Die Einfachheit hat ihre Vorteile. Wer versteht, wie ein Mikrocontroller grundlegend funktioniert, kann sich später in fortgeschrittene Softcores einarbeiten.

Mikrocontroller-Basics mit PIC

Der Autor zeigt in diesem Buch alle wichtigen Aspekte der Mikrocontroller-Programmierung, ohne den Leser mit unnötigen oder nebensächlichen Informationen zu überladen. Am Ende der Lektüre ist der Leser in der Lage, 8-Bit-Mikrocontroller zu verstehen und zu programmieren.

Mikrocontroller-Basics mit PIC

●

Mikrocontroller-Basics mit PIC

Elektronik gar nicht schwer

Tam Hanna

Elektronik gar nicht schwer

Steht im ersten Teil des Buches Assembler als ausführende Programmiersprache im Vordergrund, so geht der Autor im zweiten Teil seines Buches vertiefend auf C ein. Quasi nebenbei entführt das Buch den Leser in die Tiefen der praktischen Arbeit mit Mikrocontrollern, erklärt interessante Messtechnik und zeigt Möglichkeiten zur Arbeitserleichterung und Fehlersuche.

Elektor-Verlag GmbH 52072 Aachen www.elektor.de

Tam Hanna LEARN DESIGN SHARE

LEARN DESIGN SHARE

ESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHAR E ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● ESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHAR hanna_mikro_basics_pic_140x210_new_3397.indd 1

16.05.19 17:45

Elektronik gar nicht schwer

Mikrocontroller-Basics mit PIC

● Von Tam Hanna

LEARN DESIGN SHARE

PIC gar nicht schwer 140x210 190319.indd 3

16-05-19 14:45

● © 2019: Elektor Verlag GmbH, Aachen. 1. Auflage 2019 ● 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. Umschlaggestaltung: Elektor, Aachen Satz und Aufmachung: D-Vision, Julian van den Berg | Oss (NL) Druck: WILCO, Amersfoort, Niederlande Printed in the Netherlands

● ISBN 978-3-89576-339-7 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. www.elektor.de

LEARN DESIGN SHARE

PIC gar nicht schwer 140x210 190319.indd 4

16-05-19 14:45

Inhalt Kapitel 1 • Einleitung und Motivation......................................................... 8 Statt einer Einleitung – wer einen NE555 kauft............................................ 8 Wieso PICs? Wieso Assembler?.................................................................. 9 Was brauchen wir?................................................................................... 9 MPLAB installieren................................................................................. 10 Kapitel 2 • Assemblerbefehle schrittweise abarbeiten............................. 14 Mein Testharnisch.................................................................................. 16 Lasset uns blinken................................................................................. 18 Von der Startsequenz............................................................................. 20 Dynamische Konfiguration...................................................................... 22 Was passiert im Hintergrund?.................................................................. 25 Das GPIO-Subsystem im Fokus................................................................ 27 Zusammenfassung und Ausblick.............................................................. 29 Kapitel 3 • Programm-Ablaufsteuerung................................................... 30 Sprungoperatoren und Pipelining............................................................. 31 Programmausführung mit NOP verlangsamen............................................ 33 Exkurs: Kommentare............................................................................. 36 Deklaration von “Variablen”.................................................................... 36 Bedingte Sprungoperationen................................................................... 40 Auf Fehlersuche..................................................................................... 45 Optimierung des Programms................................................................... 47 Subroutinen realisieren........................................................................... 50 Vom Stack und seinen Tücken................................................................. 53 Ausblick............................................................................................... 57 Kapitel 4 • Mathematik am PIC................................................................ 58 Exkurs: Binär und mehr.......................................................................... 58 Addition verschiedener Parameter............................................................ 60 Größenvergleiche................................................................................... 64 Vom Zweierkomplement......................................................................... 71 Logische Operationen............................................................................. 75 Schiebung!........................................................................................... 78 Fazit.................................................................................................... 81

●5

PIC gar nicht schwer 140x210 190319.indd 5

16-05-19 14:45

Elektronik gar nicht schwer - Mikrocontroller-Basics mit PIC Kapitel 5 • Interrupts und Schlafmodi...................................................... 82 Unscharf ohne Interrupts........................................................................ 84 Verbesserung der Reaktionszeit............................................................... 91 Strom sparen........................................................................................ 95 Überwachung mit WDT........................................................................... 97 Timer am Start.....................................................................................101 Fazit...................................................................................................102 Kapitel 6 • Indirekte Adressierung......................................................... 103 Diskret und kontinuierlich!.....................................................................103 Einrichten des DACs..............................................................................105 Lookup-Tabellen...................................................................................109 Tabellen aus dem Datenspeicher.............................................................112 Exkurs: Disassemblage und Konstanten...................................................114 Tabellenzugriff, zur Zweiten...................................................................117 Tabellen aus dem RAM..........................................................................120 Fehlersuche mit Assembler....................................................................126 Banksprünge........................................................................................133 Fazit...................................................................................................133 Kapitel 7 • C – wieso und wie?............................................................... 134 Der C-Workflow....................................................................................134 MCC installieren...................................................................................137 MCC anwerfen......................................................................................139 Blinkprogramm mit MCC konfigurieren.....................................................142 Codestruktur analysieren.......................................................................145 Realisierung des Blinkprogramms...........................................................151 Test in Schnell......................................................................................153 Fazit...................................................................................................159 Kapitel 8 • Interrupts und Timer in C..................................................... 160 Interrupt-Erfassung in C........................................................................160 Bereitstellung der Interruptlogik.............................................................164 Exkurs: Änderungen zusammenführen....................................................165 Bemessung der Ergebnisse....................................................................168

●6

PIC gar nicht schwer 140x210 190319.indd 6

16-05-19 14:45

Kleine Optimierung...............................................................................174 Timer im Überblick................................................................................177 Kernpunkt der Ergebnisse!.....................................................................188 Und jetzt mit Unterbrechung!.................................................................190 Nutzung des Schlafmodus......................................................................197 Pulsbreitenmodulation...........................................................................199 Spielereien mit der Frequenz..................................................................208 Fazit und Ausblick.................................................................................211 Kapitel 9 • I2C, SPI und mehr................................................................ 212 SPI – wenn es schnell gehen muss..........................................................214 Programmierung von SPI.......................................................................225 I2C – ein Bus für viele...........................................................................230 I2C zur Zweiten....................................................................................238 Serielle Daten auswerten.......................................................................252 Bit Banging: Zustandsautomat...............................................................266 Codierung des Bit Bangings....................................................................267 Fazit...................................................................................................273 Kapitel 10 • Dauermerker: Speicher länger frisch.................................. 274 Ins EEPROM schreiben...........................................................................274 Eine Frage der Geschwindigkeit..............................................................283 Adressierungsspiele..............................................................................292 HEF – oder – missbrauche den Programmspeicher....................................295 EXKURS: HEF, zur Mehrten.....................................................................302 Fazit...................................................................................................307 Appendix A: Such-Ranking..................................................................... 308 Appendix B: Schnelle Wellenanteile........................................................ 310 Eine Welle hat viele Teile.......................................................................311 Tiefergehende Analyse!.........................................................................313 Was habe ich davon?.............................................................................316 Was nun?............................................................................................... 317 Index..................................................................................................... 323

●7

PIC gar nicht schwer 140x210 190319.indd 7

16-05-19 14:45

Elektronik gar nicht schwer - Mikrocontroller-Basics mit PIC

Kapitel 1 • Einleitung und Motivation Vor vielen Jahren fand ein junger Mann die Möglichkeit, sein Leben durch das Design von Prozessrechnern zu verbessern: elektronische Komponenten kümmern sich nicht darum, ob du jung oder alt, Araber oder Zulu, reich oder arm, beliebt oder unbeliebt bist. Ein in Holland ansässiges Verlagshaus lieferte mit der schon damals legendären Serie Elektronik gar nicht schwer einen Klassiker, der sich von anderen Werken unterschied: einfach ausführbare Beispiele, die man mit kostengünstiger Hardware bewerkstelligen konnte. Das gewonnene Wissen ermöglichte dann die eigenmächtige Fortbildung, die in lukrativen Aufträgen endete. Nun, nach all diesen Jahren, möchte ich zu dieser Serie zurückkehren und mein gesammeltes Wissen in eine kompakte Form bringen. Auf der einen Seite möchte ich Ihnen in diesem Buch alle relevanten Aspekte der Mikrocontroller-Programmierung zeigen, andererseits sie aber nicht mit unnötigen Informationen überladen. Wenn wir fertig sind, sollten Sie in der Lage sein, 8bit-Mikrocontroller zu verstehen und nur darauf brennen, dieses Wissen für finanziell oder militärisch lohnende Aufgaben einzusetzen. Statt einer Einleitung – wer einen NE555 kauft Meine Wenigkeit hatte sich viele Jahre aus der Elektronik verabschiedet. Die Programmierung von Handcomputern sorgte für sichere Einnahmen, und erwies sich als mit Politiker-Lebensgefährtinnen kompatibel. Als ich in meine alte Wirkungsstätte zurückkehrte, hatte sich nur wenig verändert: Die Eigentümerin des kleinen osteuropäischen Distributors rauchte nach wie vor wie eine kleine Dampflok Zigarren, die allerdings dicker und teurer ausfielen. Ihr schnippischer Kommentar, dass sich auch mein Bauchumfang wesentlich vergrößert hatte, wollen wir an dieser Stelle ignorieren. Die Ursache meines Besuchs war das Kaufen eines Standard-IS: Vor rund zehn Jahren war das Bauteil leicht erhältlich. Meine Freundin informierte mich darüber, dass sich die Welt verändert hatte: Heute nutzen den NE555 nur noch die ganz Alten. Alle anderen würden heute einen PIC verwenden. Nicht nur aufgrund des bei mir aufgrund einer privaten Streitigkeit nicht besonders beliebten Massimo Banzi haben Mikrocontroller heute die gesamte Elektronik erobert. Dies hat durchaus seine Vorteile: Wer die Wellen-Erzeugung in Software realisiert, kann das zu testende Gerät (DuT, kurz für Device under Test) besser anregen und so mehr Informationen einsammeln. Digitale Sensoren ersparen den Aufwand mit Signal-Konditionierung: Wer sich einmal mit der Linea●8

PIC gar nicht schwer 140x210 190319.indd 8

●8

16-05-19 14:45

Kapitel 1 • Einleitung und Motivation Kapitel 1 • Einleitung und Motivation

risierung eines Sensors auseinandergesetzt hat, wird die Vorteile der schönen neuen Welt schnell verstehen. Ärgerlicherweise führt die Verfügbarkeit von Hochsprachen dazu, dass Anwender oft nur wenig über Grundlagen wissen. Mehr als einmal bekam ich von einem Start-up eine verzweifelte Anfrage, ob ich ihnen nicht helfen kann, „den Arduino aus der Lösung herauszubekommen“. Und nein, wir sprachen dann nicht von fortgeschrittenen ARM-Kernen: Es ging meist um primitive Achtbitter, die den in diesem Buch besprochenen nicht unähnlich sind. Kurz gesagt: Wer sich mit Mikrocontroller-Hardware gut auskennt, braucht sich keine Sorgen um das Finden von Consulting-Möglichkeiten zu machen. Wieso PICs? Wieso Assembler? Mein langjähriger Freund Mike Markowitz – er war einst Mikrocontrollerdesigner, und macht nun die PR von ST Microelectronics – fragte mich schnittig, warum ich meinen Lesern nicht 24 zusätzliche Bits Denkfähigkeit verpassen würde. Fortgeschrittene Controller wie der STM32 sind beeindruckend – so ermöglicht einer von ihnen die einst großen Prozessrechnern vorbehaltenen Visualisierungen in der Humidor-Hygrometer–Produktlinie der Tamoggemon. Wahr ist, dass der PIC – ein altes 8-Bit-Design – mit Sicherheit nicht auf dem modernsten technischen Stand ist. Andererseits ist er einfach zu verstehen, wird in einem DIP-Gehäuse angeboten, ist überall erhältlich und nicht besonders kompliziert. Das gesamte Datenblatt des durchschnittlichen PICs ist um Dekaden kürzer als die Architekturbeschreibung, die den Softcore (also das eigentliche Rechenelement) eines fortgeschrittenen Mikrocontrollers beschreibt. Die Einfachheit hat ihre Vorteile. Wer versteht, wie ein Mikrocontroller grundlegend funktioniert, kann sich später in fortgeschrittenen Softcores einarbeiten. Er kann zudem – zumindest in der Theorie – auch hinter die Schale des C-Compilers blicken, was bei der Suche nach Problemen hilfreich sein kann. Das sehen Sie im zweiten Teil dieses Buchs, in dem wir uns mit der Realisierung von Lösungen in C auseinandersetzen. Was brauchen wir? In ihrer Anfangszeit war Mikrocontroller-Programmierung ein teures Hobby: Die Einkaufsliste im Appendix A zeigt, dass dies heute nicht mehr der Fall ist. Im Bereich Computer brauchen wir ebenfalls nicht besonders viel: Dieses Buch entsteht auf einer AMD FX8320-Workstation, die man heute gebraucht günstig bekommt. Die acht Prozessorkerne sind Overkill – das sehr sparsame MPLAB ist nur leidlich paralellisiert.

●9

PIC gar nicht schwer 140x210 190319.indd 9

16-05-19 14:45

Elektronik gar nicht schwer - Mikrocontroller-Basics mit PIC

Kapitel 2 • Assemblerbefehle schrittweise abarbeiten Nachdem wir MPLAB im vorhergehenden Kapitel eingerichtet haben, wollen wir mit ersten Beispielen beginnen. Gleich am Anfang eine Entschuldigung: Es ist klar, dass Sie draufloshacken wollen. Wir müssen vorher allerdings ein wenig Theorie hinter uns bringen. Der PIC ist per se kein neues Produkt: In der Literatur findet sich eine Vielzahl von Legacy-Anwendungen. Wenn Sie mit einem vorhandenen Design beginnen, sollten Sie im ersten Schritt prüfen, ob der Controller noch hergestellt wird. Viele einst populäre Bauteile sind nicht mehr verfügbar oder werden (Abb. 1) bald abgekündigt.

Abb. 2.1: Die Lebensdauer dieses Chips dürfte eng beschränkt sein. Die expansionsfreudige Firma Microchip bietet zum Zeitpunkt der Drucklegung Tausende Controller an. Wir werden uns in diesem Buch auf Achtbitter beschränken, wo es vier Unterfamilien gibt. Sie unterscheiden sich in einer Gruppe von Attributen, die in Tab. 1 zusammengefasst sind.

● 14

PIC gar nicht schwer 140x210 190319.indd 14

16-05-19 14:45

Kapitel 2 • Assemblerbefehle schrittweise abarbeiten

Disziplin

Baseline

Mid-Range

Enhanced

PIC18

Mid-Range Typen

PIC10F2xx

PIC10F3xx

PIC12F1xxx

PIC12F5xx

PIC12F6xx

PIC16F1xxx

PIC16F5x

PIC12F7xx

PIC16F5xx

PIC16F6xx

PIC18Fxxx

PIC16F7xx PIC16F8xx PIC16F9xx Anzahl der Assemblerbefehle

Arbeitsspeichergröße in Bytes

144

368

4 KB

8 KB

Programmspeicher in Worten

32 K

128 K

Stacktiefe

In der Praxis beginnen wir damit, den Speicherbedarf festzulegen. Im nächsten Schritt besuchen Sie einen Distributor Ihrer Wahl, um geeignete Teilenummern zu finden. Diese wandern in Richtung von OEMSecrets, um die Einkäufe so günstig wie möglich zu erledigen. Als Hilfe bei der Entscheidungsfindung gibt es auf den folgenden Seiten einen Ausdruck einer Linecard von Microchip (http://ww1. microchip.com/downloads/en/DeviceDoc/30010068F.pdf). Sie ist zwar nicht komplett, zeigt aber viele interessante Aspekte auf. 8-bit PIC® Microcontroller Peripheral Integration Quick Reference Guide

HEF

10(2)

PIC16(L)F145X

14–20

1024

HEF

PIC1X(L)F157X

8–20

1.75–14

1024

HEF

PIC16(L)F153XX

8–48

3.5–28

2048

HEF

PIC1X(HV)F752/53

8–14

1.75–3.5

128

–

PIC1X(L)F1612/3

8–14

3.5

256

HEF

PIC16(L)F161X

14–20

7–14

1024

HEF

PIC16(L)F170X

14–20

3.5–14

1024

HEF

5/8

PIC16(L)F171X

28–40

7–28

2048

HEF

5/8

PIC16(L)F176X/7X

14–40

7–28

2048

HEF

5/10

PIC16(L)F183XX

8–20

3.5–14

2048

256

PIC16(L)F184XX

14–28

7–28

2048

256

12(3)

PIC16(L)F188XX

28–40

7–56

4096

256

10(3)

PIC16(L)F191XX

28–64

14–56

4096

256

12(3)

ü 5

5 ü

5/9

ü ü

16–128

3728

256–1K

10(3)

16–128

8192

256–1K

12(3)

PIC18(L)FXXJ94

64–100

32–128

32–64

4096

12(3)

28–40

128

3728

1024

10(3)

DIA/MAP

DMA/VI

IDLE/DOZE/PMD

PPS

LCD

HCVD ü

mTouch® Sensing

LIN Capable

USB with ACT ü

ü ü

I2C/SPI

UART with Protocols

EUSART/AUSART

WWDT

HLT

CRC/SCAN

MathACC

MULT

ü ü

28–64

–

Low Power and System Flexibility

ü ü ü

28–48

4096

User Interface

Communications

PIC18(L)FXXK40

PIC18(L)FXXK83

Safety and Monitoring

ü ü

PIC18(L)FXXK42

PIC18FXXQ10

RTCC

SMT (24-bit)

NCO (20-bit)

16-bit PWM (16-bit)

HLT (8-bit)

AngTMR

Logic and Math

CLC

HEF

1024

DSM

COG

16-bit PWM

10-bit PWM

CCP/ECCP

ZCD

SlopeComp

PRG

OPA

DAC (# of bits)

HSComp

Comp

256

7–14

Timing and Measurements(1)

TEMP/TS

HEF

3.5

14–20

NCO

ADC (# of bits)

384–896

PIC16LF155X/6X

PIC12LF1552

Waveform Control

CWG

PIC10(L)F3XX

Data EE (B)

Program Flash Memory (KB)

Product Family

RAM (B)

Pin Count

Peripheral Function Focus Intelligent Analog

ü(5)

www.microchip.com/8bit

Abb. 2.2 ● 15

PIC gar nicht schwer 140x210 190319.indd 15

16-05-19 14:45

Elektronik gar nicht schwer - Mikrocontroller-Basics mit PIC

Kapitel 3 • Programm-Ablaufsteuerung Programmierer leben in einer geradezu paradiesischen Welt. Moderne Handys haben mehr Rechenleistung als Großrechner: Meine Wenigkeit begann seine Karriere auf Maschinen, deren Festplatte kleiner war als der Arbeitsspeicher eines heutigen Mittelklasse-Smartphones. Der Nachteil ist, dass man den Computer heute als Blackbox betrachtet. Die Konsequenzen dieser Herangehensweise findet man in Arduino-Foren: es vergeht kaum ein Tag, in dem kein Quereinsteiger darüber mault, dass sein Programm aus unerfindlichen Gründen viel zu langsam laufen würde. Die im letzten Kapitel begonnene Programmierung in Assembler ist der hardwarenaheste Weg. Assembler-Befehle werden – auf Mehrkernprozessoren stattfindende Effekte wollen wir ignorieren – streng nacheinander ausgeführt. Hat ihr Assembler-Programm die Maschine komplett für sich alleine, so können Sie deterministische Performance erwarten. Zur Demonstration der Vorteile wollen wir in die Modulationsdomäne wechseln. Stellen Sie sich einen Modulationsdomänenanalysator wie ein Oszilloskop vor, das den Frequenzverlauf über die Zeit darstellt. Die Abbildungen 3.1 und 3.2 zeigen Rechteckwellen, wie sie einerseits von einem Prozessrechner, andererseits vom weiter unten erzeugten PIC-Programm ausgegeben werden.

Abb. 3.1: Die GPIO-Performance von Abb. 3.2: ...als die unseres PIC16F mit Android Things ist wesentlich weniger geschickter Programmierung. deterministisch... Aufgrund der Breite des Histogramms in Abbildung 3.1 sehen wir, dass die Wellenformstabilität des Prozessrechners nicht gut ist. Das liegt – unter anderem – daran, dass Unix mehrere Programme gleichzeitig ausführt und deshalb nicht sofort reagiert. ● 30

PIC gar nicht schwer 140x210 190319.indd 30

16-05-19 14:46

Kapitel 3 • Programm-Ablaufsteuerung

Sprungoperatoren und Pipelining Zum Verständnis dessen, was im Hintergrund abläuft, wollen wir ein weiteres Programm namens CH3-Demo1 erzeugen. Fügen Sie wie im letzten Kapitel eine neue Assemblerdatei hinzu und öffnen Sie den unter Window ▶ PIC Memory Views ▶ Configuration Bits bereitstehenden Konfigurationsbit-Editor. Der Gutteil der Einstellungen wird vom Vorgänger übernommen. Achten Sie darauf, das Feld CLKOUTEN auf den Wert ON zu setzen. Der Taktgenerator führt den Arbeitstakt dann über einen der Pins nach außen. Wir können ihn dort mit einem Oszilloskop abgreifen. Im Interesse der didaktischen Bequemlichkeit ändern wir den WORK-Teil des Programms diesmal ab: WORK MOVLW B‘00000000‘ MOVWF PORTA MOVLW B‘11111111‘ MOVWF PORTA GOTO WORK

; loop forever

END

Anstatt den Wert von PORTA über den Befehl COMF zu verändern, verwenden wir einen klassischen Lade-Ausschreibe-Zyklus. Der Rest des Codes wird vom vorherigen Beispiel übernommen. Konfigurieren Sie das Projektskelett, um Spannungsversorgung durch das PICkit zu deaktivieren. Schicken Sie das Programm danach wie gewohnt auf den PIC, um sich am in Abbildung 3.3 gezeigten Oszillogramm zu erfreuen.

● 31

PIC gar nicht schwer 140x210 190319.indd 31

16-05-19 14:46

Elektronik gar nicht schwer - Mikrocontroller-Basics mit PIC

Kapitel 4 • Mathematik am PIC Ein Blick auf die Assembler-Instruktionsbeschreibung des PIC zeigt, dass der Controller für komplexe Berechnungen eher schlecht als recht geeignet ist. Sowohl Multiplikationen als auch Divisionen erfolgen ohne Hardwarebeschleunigung und arten in Arbeit aus. Lehrbuchautoren reagieren auf diese Situation mit dem reflexartigen Herunterbeten komplizierter Assemblerprogramme, die man in der Praxis aber nur selten braucht. In den nachfolgenden Kapiteln sehen Sie, dass der C-Compiler sowohl die Multiplikation als auch die Division mit hochoptimiertem Code für Sie erledigt. Compilerunternehmen haben Assemblerspezialisten, im Fall von Microchip sitzen sie sogar direkt bei den Hardwareentwicklern. Daraus folgt eine immense Effizienz des Codes, die man von Hand kaum erreicht. Wer selbst mathematische Routinen realisiert, tut dies entweder aus Interesse oder legt sich Steine in den Weg. Wichtig ist, dass sie verstehen, was innerhalb des Controllers passiert. Dieses Wissen ermöglicht Ihnen die Bewertung von Algorithmen, Compilern und anderen Systemen. Auch wenn sie eine Multiplikation nie von Hand realisieren, sollten Sie wissen, dass sie Aufwand verursacht. In Algorithmen sollten Sie sie nach Möglichkeit vermeiden. Hier möchte ich anmerken, dass sie „Rechen-Orgien“ nicht mit hochoptimiertem Code auf einem Achtbitter erledigen sollten. 16-und 32 Bit-Controller sind für Berechnungsaufgaben besser geeignet, der etwas höhere Stromverbrauch kompensiert sich durch die kürzere Rechenzeit. Fortschritte im Bereich der Halbleiterfertigung machen die Preise weitgehend identisch – die zehn oder zwanzig Cent Aufpreis amortisieren sich bei Kleinserien durch eingesparte Zeit. Exkurs: Binär und mehr Warum der Mensch im Dezimalsystem rechnet, erschließt sich bei einem Blick auf ihre Hände. Der Schöpfer bzw. die Evolution hat sie mit zehn Fingern ausgestattet – aus der Logik folgt, dass man die nächste Ziffer aufmacht, wenn alle Finger verbraucht sind. In der Theorie spricht nichts dagegen, eine andere Basis zu wählen. Wären Sie ein Marsmännchen mit 16 Fingern, so wäre davon auszugehen, dass ihre „Basis“ die 16 wäre. Als Zeichen könnten sie dann statt 0-9 beispielsweise A bis P oder beliebige andere Symbole verwenden. Computer arbeiten von Haus aus mit zwei Zuständen – die in der UdSSR erfolgten Versuche mit mehrzuständigen Rechnersystemen wollen wir als Trivia ● 58

PIC gar nicht schwer 140x210 190319.indd 58

16-05-19 14:46

Kapitel 4 • Mathematik am PIC

ausbuchen. Daraus ergibt sich ein komplett anderes Zahlensystem, das man als Binärsystem bezeichnet. Die Abbildung 4.1 stellt die beiden Verfahren einander gegenüber.

Abb. 4.1: Wer nur einen Finger hat, rechnet zwangsläufig binär. Die mit zehn Fingern ausgestattete Person kann mit ihren Händen die Werte bis incl. 10 ausdrücken. Wer nur einen Mittelfinger hat, zählt von 0 bis 1. Mit dem Hinzufügen eines zweiten Mittelfingers erweitert er seinen Zahlenbereich auf 2^1 + 1. Es ist für Digitalelektroniker in höchsten Maße empfehlenswert, Binärzahlen bis zu einem gewissen Rahmen im Kopf umrechnen zu können. Die Konversion ist einfach – gesetzte Bits tragen ihren jeweiligen Wert zur Summe bei. Abbildung 4.2 zeigt ein handschriftliches Beispiel, dass das Verfahren illustriert.

Abb. 4.2: Mit etwas Übung erfolgt diese Umrechnung im Kopf. ● 59

PIC gar nicht schwer 140x210 190319.indd 59

16-05-19 14:46

Elektronik gar nicht schwer - Mikrocontroller-Basics mit PIC

Kapitel 5 • Interrupts und Schlafmodi Unsere bisherigen Programme funktionieren. Problematisch ist, dass das „aktive Warten“ den Controller auslastet. Stellen Sie sich eine Situation vor, in der unser Controller nicht nur Lichtsequenzen ausgibt, sondern auch einen kritischen Prozess überwacht. Wenn wir die Auswertung der kritischen Situation in den „Hauptteil“ der Schleife platzieren, so besteht mitunter eine hohe Latenz. Tritt das Ereignis am Beginn des Warteprozesses auf, so kann es erst nach dessen Ende abgearbeitet werden – ein Worst Case-Szenario, das je nach Länge der Warteschleife mehr oder weniger katastrophale Konsequenzen entfaltet. In einfachen Programmen könnte man dieses Problem umgehen, indem man innerhalb des Warteprozesses eine Abfrage platziert. Leider artet dies schnell in Arbeit aus. Ein vernünftiger Weg bestünde darin, den Prozessor mit Speziallogik auszustatten, die beim Auftreten spezieller Ereignisse eine Routine aufruft. Im angelsächsischen Bereich nennt man diese Interrupt – sie sind unser nächstes Themengebiet. Aus konzeptueller Sicht ist die Vorgehensweise einfach. Tritt ein Interrupt auf, so springt die Programmausführung zu einer als Interruptvektor bezeichneten Stelle im Speicher. Der PIC rödelt dort solange herum, bis er durch einen dedizierten Befehl zum “Aufgeben” animiert wird – danach kehrt er an die Stelle zurück, wo der Interrupt aufgetreten ist. Der Gutteil der in unserem Microcontroller enthaltenen Peripheriegeräte kann Interrupts ausgeben. Der genaue Umfang ist dabei von Chip zu Chip unterschiedlich – wichtig ist die in Abbildung 5.1 gezeigte Grundkonstruktion.

Abb. 5.1: Die Erzeugung von Interruptsignalen erfolgt vergleichsweise kompliziert. ● 82

PIC gar nicht schwer 140x210 190319.indd 82

16-05-19 14:46

Kapitel 5 • Interrupts und Schlafmodi

Moderne PICs bringen Dutzende von Interruptquellen mit. Vom ADC bis zu den diversen seriellen Einheiten gibt es kaum ein Peripheriegerät, das nicht mit der Interruptlogik verbunden ist. Was auf den ersten Blick attraktiv erscheint, erweist sich in der Praxis als problematisch. Die Verarbeitung von Interrupts nimmt auch Rechenleistung in Anspruch. In “blöden” Situationen kann dies das System komplett flachlegen. Ein Klassiker wäre die erste Version von Palms mittlerweile legendärem TT3, der sich selbst durch Interrupt-Vergiftung tötete: Additionally, palmOne recently heard reports about an apparent slowdown in performance after turning the Tungsten T3 handheld off then on again. After investigation, palmOne determined that there were unnecessary audio interrupts, which may appear to affect performance. This Tungsten T3 Update reduces unnecessary audio interrupts. Microchip umgeht dieses Problem durch eine mehrstufige Aktivierungskette: Bis ein Signal in Abbildung 5.1 rechts bei der CPU ankommt, muss es diverse Schritte überstehen. Als Erstes das GIE-Bit, dessen Namen für General Interrupt Enable steht. Ist es nicht gesetzt, so ist das gesamte Interrupt-Subsystem ohne Funktion. Interruptquellen besonderer Priorität werden „direkt“ mit dem Auslösegatter verdrahtet. Ist ihr jeweiliges Enable-Bit gesetzt, so führt eine Änderung des Zustands zum Triggern eines Interrupts. Interruptquellen niederer Bedeutung sitzen stattdessen hinter einem weiteren AND-Gatter, das als Ganzes über das PEIE-Bit ein- und ausgeschaltet wird. Ihre Quellen bringen wiederum AND-Gatter mit, die das feingranulare Regeln erlauben. Interessant ist in diesem Zusammenhang die Rolle der E- und der R-Bits. Mit dem E-Bit legt der Entwickler fest, ob er Interesse an einem bestimmten Ereignis hat. Das zum jeweiligen Event gehörende R-Bit dient der Hardware zum Anzeigen des Auftretens des jeweiligen Betriebszustands: Stellt der ADC eine relevante Änderung fest, so setzt er das R-Bit. Kritisch ist, dass das R-Bit vom Controller nicht gelöscht wird und auch bei deaktiviertem E-Bit aktiv bleibt. Setzen Sie das E-Bit, so kann ein in der Vergangenheit aufgetretenes Ereignis die Interruptroutine sofort triggern. Das Löschen des Bits ist ebenfalls alleinige Verantwortung des Entwicklers. Unterbleibt es, so löst ein Ereignis die Routine immer und immer wieder aus.

● 83

PIC gar nicht schwer 140x210 190319.indd 83

16-05-19 14:46

Kapitel 6 • Indirekte Adressierung

Kapitel 6 • Indirekte Adressierung Als „letzte“ Übung in Sachen Assembler wollen wir uns mit der indirekten Adressierung auseinandersetzen. Dahinter steht der Gedanke, dass die Zuweisung zwischen Adresse und Wert nun nicht mehr durch eine Konstante, sondern durch einen in einem anderen Register befindlichen Wert erfolgt. Stellen Sie sich dieses – am PC übrigens unter dem Begriff Pointer bekannte – Konzept wie einen Geschützturm vor, der auf einer fahrbaren Lafette steht. Durch die Position der Lafette lässt sich festlegen, wohin das Geschütz schießt. Indirekte Adressierung lässt sich bei modernen PICs sowohl im Daten- als auch im Programmspeicher verwenden. Wir demonstrieren die Vorgehensweise hier unter anderem deshalb, weil sie für Mess-, Steuer- und regelungstechnische Aufgaben von eminentester Bedeutung ist. Bevor wir mit der eigentlichen Adressierung beginnen, möchte ich Ihnen den DAC vorstellen. Die Ursache für diese Demonstration ist, dass wir „sprechende“ Wellenformen ausgeben wollen – diese Vorgehensweise ist interessanter als der Vergleich von Zahlenkolonnen. Schon in der Einleitung sei angemerkt, dass moderne PICs die Arbeit wesentlich erleichtern. In älteren Systemen müssen sie mehrere Speicherbänke verwalten, was die Aufgabe komplizierter macht. Da derartige PICs heute teurer als ihre modernen Kollegen sind, wollen wir auf das Verfahren nur sehr peripher eingehen. Diskret und kontinuierlich! Bevor wir uns mit den Möglichkeiten des DAC auseinandersetzen, wollen wir einen Blick auf Abbildung 6.1 werfen. Sie sehen hier diskrete und kontinuierliche Signale, die einander gegenübergestellt sind. Kontinuierliche Signale können innerhalb des Wertebereichs beliebige Stellen annehmen, während ihre diskreten Kollegen auf bestimmte Punkte beschränkt sind.

● 103

PIC gar nicht schwer 140x210 190319.indd 103

16-05-19 14:46

Elektronik gar nicht schwer - Mikrocontroller-Basics mit PIC

Abb. 6.1: Diese Grafik stellt diskrete und kontinuierliche Signale gegenüber. (Bildquelle: Wikimedia Commons / wdwd) Für uns ist hierbei die Wert-Diskretion von besonderer Bedeutung. Digital-Analog-Konverter unterteilen die Referenzspannung in eine Gruppe von Schritten, die die kleinste mögliche Spannungsänderung beschreiben. Im Fall unseres PICs arbeiten wir mit 5 Bit Auflösung (32 Stufen), weshalb die individuellen Stufen bei 5V Versorgungsspannung 0.156 Volt betragen. Bei der Ausgabe (oder dem Sampling) schneller Wellenformen ist auch die zeitliche Diskretisierung relevant: Unser DAC ist nicht in der Lage, beliebig schnell zu arbeiten. Dieser Wert ist – wie in der Abbildung gezeigt – von Microchip nicht garantiert, weshalb sie für anspruchsvolle Aufgaben mit schlechteren Werten rechnen sollten.

Abb. 6.2: Das Sternchen weist darauf hin, dass Microchip diesen Wert nicht garantiert. Achtung: Faszinierend-bösartiger Themenbereich Das Design von genauen Analog-Digital und Digital-Analog-Konvertern ist eine faszinierend-komplizierte Wissenschaft. Möchten Sie im Messbereich arbeiten, sollten Sie sich eigenständig mit der Thematik auseinandersetzen. Witziger● 104

PIC gar nicht schwer 140x210 190319.indd 104

16-05-19 14:46

Elektronik gar nicht schwer - Mikrocontroller-Basics mit PIC

Kapitel 7 • C – wieso und wie? Nachdem wir uns bisher mit der Assembler-Programmierung auseinandergesetzt haben, ist es nun an der Zeit, unsere Aufmerksamkeit auf die Programmiersprache C zu lenken. Außer Diskussion steht, dass C mit Sicherheit nicht die modernste Art der Programmierung ist: So bietet die Sprache keine wirkliche Möglichkeit, um objektorientiert zu arbeiten. Die Speicherverwaltung liegt alleine in den Händen des Entwicklers, was nicht für Freude sorgt. Die geringe Eigenaktivität von C macht sie für kleine Mikrocontroller ideal geeignet. Während das Verstehen von .net- oder Java-Code aufgrund der zwischengeschalteten virtuellen Maschine haarig ist, kann man – zumindest bei kleineren Programmen – einen gewissen Zusammenhang zwischen dem C-Code und der Assembler-Ausgabe erkennen. Andererseits bringt C eine Vielzahl von Schleifen und ähnlichen Hilfskonstrukten mit, die das bequeme Erzeugen von Programmen erlauben. Das weiter oben gesehene Hantieren mit Speicher, Bänken, W und Co. erledigt der Compiler für uns, Multiplikationen und Divisionen entstehen mit hoch optimiertem Code. Zudem steht eine mehr oder weniger umfangreiche Standardbibliothek zur Verfügung, die häufig benötigte Aufgaben erledigt. Im Pleistozän der Informatik sprach man davon, dass C-Code rund 30 % langsamer arbeitet als hochoptimierte Assemblerroutinen. Dies mag zutreffen – in Zeiten von mit 20 oder noch mehr Megahertz rechnenden PICs und wesentlich leistungsfähigeren 16- und 32 Bit-Controllern sei angemerkt, dass das manuelle Optimieren von Routinen in den seltensten Fällen ökonomisch sinnvoll ist. Der bisherige Kampf war aber nicht umsonst. Mit unseren Kenntnissen über die innere Struktur des Controllers können wir die Arbeit des C-Compilers besser nachvollziehen. In diesem Sinne – nichts wie los! Der C-Workflow Während zwischen Assemblerdatei und ausgegebenem Maschinencode eine mehr oder weniger direkte Korrelation besteht, entstehen C-Programme in einem komplizierteren Verfahren (siehe Abbildung).

● 134

PIC gar nicht schwer 140x210 190319.indd 134

16-05-19 14:46

Kapitel 7 • C – wieso und wie?

Abb. 7.1: Der Compiler verwandelt den C-Code in Objektdateien, die der Assembler danach weiterverarbeitet. Im ersten Schritt führt der Präprozessor dabei eine rein textuelle Analyse des vorliegenden Codes durch. Er ersetzt Makros und Definitionen durch den „endgültigen“ Code, und löst #include-Statements und Ähnliches auf. Darauf folgen Compiler und Assembler, die die einzelnen Dateien in Maschinencode umwandeln. Die Zusammenführung aller Dateien erfolgt erst im letzten Schritt, der als Linker bezeichnet wird. Er hat die Aufgabe, Bibliotheksfunktionen und dateiübergreifende Funktionsdeklarationen aufzulösen – danach ist die Datei zum Deployment bereit. Heute haben wir mit diesem Prozess nur selten direkt zu tun – integrierte Entwicklungsumgebungen erledigen die Schritte für uns. In der Praxis ist der Ablauf wichtig, weil er bei der Fehlersuche hilft: Tritt ein Linkerfehler auf, so wissen Sie, dass wahrscheinlich eine Bibliotheks- oder sonstige Funktion fehlt. Rein theoretisch spricht nichts dagegen, mit dieser Basis mit der C-Programmierung zu beginnen. Den XC8 genannten Compiler hatten wir schon im ersten Kapitel heruntergeladen: Für ein lauffähiges C-Programm benötigen wir eine Headerdatei, die den diversen Registern sprechende Namen zuweist. Danach könnten wir – ganz analog zu Assembler – beginnen, eine C-Applikation zusammenzustellen. ● 135

PIC gar nicht schwer 140x210 190319.indd 135

16-05-19 14:46

Elektronik gar nicht schwer - Mikrocontroller-Basics mit PIC

Kapitel 8 • Interrupts und Timer in C Am Ende des Kapitels 2 hatten wir die Verwendung von Interrupts in Assembler realisiert. Als „haarig“ erwies sich dabei neben der komplizierten Parametrisierung des Interruptsystems auch die Platzierung der Routine am „korrekten“ Platz im Speicher. MCC und der C-Compiler können uns das Leben an dieser Stelle massiv erleichtern – in diesem Kapitel lernen wir, wie man unter C mit Interrupts interagiert. Ein weiterer Job, der in Assembler in eine Konfigurationsorgie ausartet, ist die Verwendung der Englisch als Timer bezeichneten Zeitgeber. Bei korrekter Parametrisierung kann ein Geber „zeitgesteuerte“ Ereignisse ohne programmatische Unterstützung bereitstellen und/oder analysieren. Die ist in mehrerer Hinsicht hilfreich – nicht nur zur Vereinfachung des Programmcodes, sondern auch zur Erreichung von deterministischerem Programmverhalten und quasi nebenbei oft auch wesentlich reduziertem Energieverbrauch. Interrupt-Erfassung in C Zur Demonstration der Interrupts wollen wir ein neues Beispielprogramm anlegen, das in der Codesammlung zum Buch auf den Namen CH8-Demo1 hört. Arbeiten Sie den Assistenten wie gewohnt ab und öffnen Sie daraufhin MCC, um mit der Konfiguration der Interruptroutine zu beginnen. Wie im letzten Kapitel wollen wir auch diesmal einen „Spiegel“ realisieren. Öffnen Sie im ersten Schritt den Pin Manager und erzeugen Sie ein Eingangs- und ein Ausgangspin. Im Interesse der Bequemlichkeit nutzt der Autor in den folgenden Schritten RA0 als Eingang und RD2 als Ausgang. Die Verwendung von RD1 ist nicht zulässig – nicht alle Pins des PICs sind mit dem Interruptgenerator verbunden. Die in Abbildung 8.1 gezeigte Combobox zur Auswahl der für die Aktivierung vorgesehen Flanken scheint in diesem Fall nicht auf – ein Wink mit dem Zaunpfahl von MCC, der sie auf die Verwendung eines „unerwünschten“ Pins hinweist.

Abb. 8.1: IOC - kurz für Interrupt on Change beeinflusst das Verhalten des Interruptgenerators. ● 160

PIC gar nicht schwer 140x210 190319.indd 160

16-05-19 14:46

Kapitel 8 • Interrupts und Timer in C

Öffnen Sie im nächsten Schritt in der Rubrik Project Resources die Option Pin Manager, um die Parametrisierung der Pins zu anzupassen. Konfigurieren Sie die Hardware dann wie in Abbildung 8.2 gezeigt.

Abb. 8.2: Die Konfiguration der GPIO-Pins ist nicht sonderlich kompliziert. Öffnen Sie anschließend die Rubrik Interrupt Module. Es handelt sich dabei um eine „zentrale Einlaufstelle“, in dem sie in MCC die weiter vorne von Hand durchgeführte Einrichtung der diversen Interrupt-Quellen durchführen. Von Haus aus ist die Option Enable neben dem Pin Module deaktiviert – klicken Sie die Checkbox an, um das Modul zu aktivieren. Nach getaner Arbeit präsentiert sich das Fenster wie in Abbildung 8.3 gezeigt.

Abb. 8.3: Der Pin Module-Interruptgenerator ist von Haus aus deaktiviert. Die Checkbox Single ISR per Interrupt erlaubt die Einstellung des Codegenerators. Ist sie aktiviert, so bekommen Sie für jede Interruptquelle eine eigene Funktion, die beim Auftreten des jeweiligen Ereignisses aktiviert wird. Ist die Option deaktiviert, so erzeugt MCC nur einen Handler, der die Interrupts aufteilt. ● 161

PIC gar nicht schwer 140x210 190319.indd 161

16-05-19 14:46

Elektronik gar nicht schwer - Mikrocontroller-Basics mit PIC

Kapitel 9 • I2C, SPI und mehr Unsere bisherigen Systeme haben nicht nennenswert mit Peripheriegeräten interagiert. Im Kapitel zur Mathematik haben sie einige Leuchtdioden angesteuert, und die angelieferten Worte parallel ausgegeben. In diesem Kapitel bekommen wir es unter anderem mit seriellen Verbindungen zu tun. Zur Erklärung: Unter Vernachlässigung der minimalen Latenzen wurden alle acht Pins gleichzeitig aktualisiert. Die im Rahmen unserer Berechnungen entstandenen Worte wurden also in voller Breite ausgegeben. Im Laufe der Weiterentwicklung der Hardware wurden derartige parallele Systeme unpopulär: Es ist alles andere als angenehm, dem Layouter dreißig Traces mit kontrollierter Impendanz zuzumuten. Dass schnelle Steckverbinder mit jedem Pin teurer werden, folgt ebenfalls aus der Logik. Als Alternative haben sich serielle Bussysteme etabliert. Sie übertragen Informationen, wie in Abbildung 9.1 gezeigt, sequenziell – in der Praxis findet man heute nur noch selten klassische parallele Busse.

Abb. 9.1: Serielle Busse erweisen sich als leichter implementierbar. Die immense Popularität serieller Bussysteme hat dafür gesorgt, dass eine Gruppe von Standards etabliert wurden. Es handelt sich dabei – analog zu USB und Co – um Industrieübereinkünfte, die ein gewisses Kommunikationsprotokoll spezifizieren. Unterstützt der Mikrocontroller das jeweilige Protokoll, so kann er – im Regelfall – mit derartiger Peripherie kommunizieren.

● 212

PIC gar nicht schwer 140x210 190319.indd 212

16-05-19 14:47

Kapitel 9 • I2C, SPI und mehr

Ich möchte Ihnen in den folgenden Schritten eine Gruppe von Peripheriegeräten vorstellen, die verschiedene Aufgaben erfüllen. Die verwendete Hardware ist bei intelligenter Beschaffung sehr preiswert – das einzig wirklich teure ist der Wiegand-Leser. Diesen brauchen Sie in der Praxis allerdings nicht unbedingt – wie bisher mit dem Oszilloskop versuche ich Ihnen alles so zu demonstrieren, dass Sie es auch ohne reale Hardware nachvollziehen können. Eine Frage des richtigen Werkzeugs Wer logische Probleme serieller Busse mit einem klassischen Analog- oder Digitalspeicher-Oszilloskop analysiert und Bits von Hand dekodiert, ist auf dem Holzweg. Moderne Oszilloskope bringen integrierte Decoder für serielle Busse mit – leider sind derartige Geräte mit hoher Leistung auch gebraucht teuer. Zudem lehrt die praktische Erfahrung des Autors, dass der Gutteil der Fehler nicht auf physikalischer Ebene vorliegt: Die Korrektheit der elektrischen Wellenformen ist nur in den seltensten Fällen dafür verantwortlich, dass das Sensorsystem nicht funktioniert. Als Ärgernis #1 etablieren sich Programmierfehler – denken Sie an ein versehentlich falsch gesetztes Register oder eine Fehlprogrammierung des Controllers, die zur Ausgabe invertierter oder sonstwie ungültiger Werte führt. Anbieter von Messtechnik begegnen diesem Problem seit jeher durch das Anbieten von Logikanalysatoren: Denken Sie an ein Oszilloskop, das statt analoger Werte nur die Werte null und eins aufnehmen kann, dafür aber viele Kanäle mitbringt. Sie stehen sowohl als Standalone- als auch als PC-gebundene Systeme zur Verfügung. Allgemein lassen sich Programmierprobleme am besten auf einer Zweischirmworkstation finden, auf der man den Programmcode und die und die tatsächlichen Konditionen am Bus gegenüberstellen kann. Der Autor nutzt gerne PC-Logikanalysatoren aus dem Hause Saleae – wer die URL https://blog.saleae.com/saleae-discounts/ besucht, findet extrem aggressive Sonderkonditionen (Rabatte von mehr als 50 %). Noch preiswertere Logikanalysatoren, die meist ohne analoge Erfassung auskommen müssen, finden sich bei AliExpress. Beachten Sie dabei die unter https://sigrok.org/wiki/Supported_hardware bereitstehende Kompatibilitätstabelle – die Nutzung chinesischer Produkte mit alten Versionen von Saleae´s Software mag funktionieren, ist aber nicht zukunftssicher. Explizit abzuraten ist von klassischen Logikanalysatoren wie beispielsweise den HP 16500 und 16700. Die als Erregergeneratoren oder bei der Suche ● 213

PIC gar nicht schwer 140x210 190319.indd 213

16-05-19 14:47

Elektronik gar nicht schwer - Mikrocontroller-Basics mit PIC

Kapitel 10 • Dauermerker: Speicher länger frisch Unsere bisherigen Mikrocontroller-Programme litten darunter, dass sie zwischen den einzelnen Ein-und Ausschaltvorgängen des Controllers keine Informationen persistieren können. Über die im vorigen Kapitel angesprochenen Bussysteme haben Sie natürlich die Möglichkeit, externe Speicher anzuschließen. Diese Vorgehensweise ist allerdings nur teilweise vernünftig. Microchips 8-Bit-Serie bietet – je nach Ausbaustufe – mehrere Möglichkeiten an, um Informationen auf eine remanente Art und Weise zu speichern. Der Autor stellt Ihnen in diesem Buch absichtlich beide Methoden vor, da man insbesondere im Low-End-Bereich immer wieder Controller trifft, die nur eine der beiden Speichermethoden unterstützen. Ins EEPROM schreiben Wer Informationen „persistent“ speichern möchte, setzt auf jeher auf ein EEPROM. Hinter dem Begriff verbirgt sich die Abkürzung Electrically Erasable Programmable Read-Only Memory. Ein EEPROM unterscheidet sich von seinem Flash-Kollegen dadurch, dass man einzelne Bytes löschen kann – bei Flashspeicher muss man eine als „Page“ bezeichnete Gruppe bearbeiten. Da die EEPROMs vergleichsweise teuer sind, ist meist nur ein kleiner Teil des Speichers eines Controllers auf diese Art und Weise ausgeführt. Das zeigt sich in Abbildung 10.1, die die Speicherstruktur unseres PICs näher demonstriert.

Abb. 10.1: Ob der verschiedenen Zugriffsmöglichkeiten fällt die Tabelle kompliziert aus. ● 274

PIC gar nicht schwer 140x210 190319.indd 274

16-05-19 14:47

Kapitel 10 • Dauermerker: Speicher länger frisch

Zum Verständnis müssen wir mit der Abkürzung PFM beginnen, die für Programm Flash Memory steht. Ganz links finden sich in der Gruppe Master Value die Werte, unter denen der jeweilige Speicherbereich „physikalisch“ ansprechbar ist. Ganz rechts finden sich Adressen, über die die weiter oben besprochenen FSR-Register mit den jeweiligen Speicherbereichen interagieren. Zu guter Letzt findet sich in der Mitte eine weitere Gruppe von Adresswerten, die das NVMREGS-Speicherzugriffsystem parametrieren. Es handelt sich dabei um eine weitere Gruppe „indirekter“ Register, die sich aus technischer Sicht etwas anders verhalten. Wichtig ist, dass es im ROM-Bereich nicht nur die als User Memory bezeichnete Partition für „allgemeine“ Daten gibt. Die Config-Worte sowie Rev ID und Device ID enthalten Informationen über den Betriebszustand des PICs – Sie können sie beispielsweise verwenden, um Daten über den Versionsstand zu erhalten. Uns soll dies in der vorliegenden Stelle allerdings nicht weiter aufhalten. Wir erzeugen lieber ein neues Projekt, das auf den Namen CH11-Demo1 hört. Starten Sie danach wie gewohnt MCC und fügen Sie ein neues Peripheriegerät vom Typ Memory → Memory zur Projektkonfiguration hinzu. Auf unserem PIC präsentiert sich seine Konfiguration wie in Abbildung 10.2 gezeigt.

Abb. 10.2: Die Einrichtung des Flash-Speichers ist nicht sonderlich kompliziert. Das Peripheriegerät erzeugt von Haus aus eine Datei, die auf den Flashspeicher zugreift. Wer die Checkbox „Add DataEE Routines“ markiert, bekommt zusätzlich auch Routinen zum Zugriff auf das EEPROM. Wie wollen diese Option in den folgenden Schritten markieren, und achten zudem darauf, den Port B zur Gänze als „Ausgang“ zu deklarieren. An ihm schließen wir danach, wie in Abbildung 10.3 gezeigt, acht Leuchtdioden an, die zur Ausgabe von Informationen dienen. ● 275

PIC gar nicht schwer 140x210 190319.indd 275

16-05-19 14:47

Index

Index A Adressierung 103 AliExpress 217 AND 76 ANSEL 28 Assembler 126 Assemblercode 68 Auflösung 108

EUSART 255

F FIFO 51 FSR1 126

G GPIO 27

Baader-Meinhoff-Effekt 181 BANKSEL 28 Banksprünge 133 Binär 58 Binär-Dezimal-Konverter 72 Bit Banging 262 Bode100 314 BSR 38 BTFSC 41 BTFSS 69

HEF 295 Hexadezimalzahlen 60

C C 134 CLKOUTEN 60 COMF 27 Copy & Paste 51

I I2C 230 Inline 175 Interrupt 83, 160

K Kommentare 36 Kompilation 20 Konstanten 114

C-Programmierung 68

Latenz 84 Linecard 15 Logikgatter 75

DAC 105 DAC1CON0 106 Debug 174 Designpattern 266 Digital-Analog-Konverter 108 Disassemblage 114, 155 Division 121

MCC 137 MCLR 18 Microchip 14 Modulationsdomänenanalysator 154 MOVLP 157 MPASM 112 MUX 105

EEPROM 274 EPROM-Zugriff 113

NOP 33

● 323

PIC gar nicht schwer 140x210 190319.indd 323

16-05-19 14:47

Elektronik gar nicht schwer - Mikrocontroller-Basics mit PIC

OR 76

Versionskontrollsysteme 136

PCLATH 121 Performance 175 PIC16F1503 16 PIC 16F18877A 121 PIC16F18877A 95 PICkit 35 Pipelining 31 Polling 190 Pullup-Widerstand 86 Pulsbreitenmodulation 199 PWM-Wellenformen 202

WDT 97 WDTCCS 98 Wellenform 196 Wellenformstabilität 100 Widerstand 87

X XC8 153

Z Zweierkomplement 71

R Reaktionszeit 91 Rechtecksignal 310 Routine 52

S Schlafmodus 197 Selbsterwärmung 251 Serielle Daten 252 Skip 70 Speicherbereich 39 SPI 214 Sprungoperationen 40 Stack 53 Startsequenz 20 Subroutinen 50 Such-Ranking 308

T Textool 17 Timer 101, 177 Toggle 194

U Unix-Standard 265

● 324

PIC gar nicht schwer 140x210 190319.indd 324

16-05-19 14:47

ISBN 978-3-89576-339-7

Mikrocontroller-Basics mit PIC

●

Mikrocontroller-Basics mit PIC

Elektronik gar nicht schwer

Tam Hanna

Elektronik gar nicht schwer

Elektor-Verlag GmbH 52072 Aachen www.elektor.de

Tam Hanna LEARN DESIGN SHARE

LEARN DESIGN SHARE

16.05.19 17:45