Es gibt jedoch Fälle, in denen eine if-Abfrage eher ungünstig ist.

Manchmal kann eine Variable nämlich potentiell viele unterschiedliche Werte haben.
Diese unterschiedlichen Werte müsste man jeweils in einzelnen if-Abfragen auswerten.

Diese Auswertung der Variablen kann dann sehr aufwändig werden. Oft sind lange und geschachtelte if-/ else if- Abfragen die Folge.

Effektiver und deutlich lesbarer ist häufig eine Alternative, die ich heute vorstellen möchte.
Mit einer switch-case-Abfrage lassen sich solche Abfragen manchmal eleganter lösen.

Mit switch-case ist es möglich, sehr übersichtlich – abhängig vom aktuellen Wert der Variablen- unterschiedliche Anweisungen ausführen.

In der heutigen Folge möchte ich die Abfrage mit switch–case vorstellen:

Viel Spaß mit dem Video.

[ >> Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .]

Der Beitrag Bedingte Anweisungen mit switch–case erschien zuerst auf ET-Tutorials.de.

Ein sehr bekanntes und verbreitetes System für einen leichten Einstieg in die Mikrocontroller-Programmierung ist das System von Arduino
.

In einer Gast-Artikelreihe wird das Arduino-System und die Erstellung eigener Applikationen vorgestellt.
Dies ist die erste Folge der Gast-Reihe Arduino Lernen von fritzing.org hier bei ET-Tutorials.de.

In dieser Folge geht es zunächst einmal um die Vorstellung des verwendeten Arduino-Boards.

Im Gegensatz zu selbsterstellten Mikrocontroller-Platinen wird mit dem verwendeten Arduino-Board eine komplette Entwicklungsumgebung zur Verfügung gestellt.

Das fertige Arduino-Board ermöglicht es, sehr einfach den auf dem Board eingebauten Mikrocontroller in eigenen Projekten zu verwenden.

Zur Kommunikation mit dem PC wird das Arduino-Board über eine USB-Schnittstelle an den PC angeschlossen.

So können die auf dem PC entwickelten Programme sehr leicht auf das Board geladen werden.

Um das Board auch ohne PC, quasi als Embedded System, betreiben zu können, verfügt das Board über eine zusätzliche Stromversorgung. So ist der Anschluss eines PCs beim Betrieb des Boards nicht zwingend notwendig.

Zudem ermöglicht die zusätzliche Stromversorgung den Betrieb weiterer Hardware am Arduino-Board, bei der die Stromversorgung über die einfache USB-Schnittstelle nicht ausreichen würde.

Die Kommunikation mit der Außenwelt kann über die digitalen In&Out Pins realisiert werden. Zudem verfügt das Board auch über analoge Input Pins.
Eingangssignale für das Board müssen also nicht nur in digitaler Form darliegen. Auch analoge Werte können eingelesen und vom Arduino-Board verarbeitet werden.

Das Video zum Arduino-Board

Jetzt aber zum Video, in dem das Arduino-Board vorgestellt wird.

Der Beitrag Arduino Lernen – Arduino Überblick erschien zuerst auf ET-Tutorials.de.

Die Raspberry Pi Foundation ist eine Stiftung. Das Ziel dieser Stiftung ist, das Studium und die Ausbildung der Informatik und verwandter Themen zu fördern.

Wichtig ist der hohe Spaßfaktor beim Erlernen der Computergrundlagen und der Programmierung.
Mit dem Raspberry Pi sollen Schulen, Universitäten und Privatpersonen ein sehr kostengünstiger Rechner zur Verfügung gestellt werden mit dem man die Programmierung und die Handhabung von Rechnern erlernen kann.

Versionen vom Raspberry Pi

Es gibt zwei Versionen vom Raspberry Pi auf dem Markt, Version A und Version B.

Vor allem in der Netzwerkfunktionalität unterscheiden sich die beiden Versionen.
Während Version A einen USB 2.0 Anschluss hat, verfügt Version B über zwei USB-Anschlüsse und zusätzlich über einen 10/100 MBit Ethernet-Controller.
Ansonsten gibt es noch einen Klinke-Audio-Anschluss, einen Composite-Ausgang mit einem RGB-Signal und einen digitalen HDMI-Anschluss. Das Betriebssystem kann man per SD-Karte einstecken. Für die Stromversorgung nimmt man einen der USB-Anschlüsse.

Zusätzlich benötigt man ein HDMI-Kabel für den Monitor (und natürlich einen Monitor selbst), eine SD-Karte, eine Tastatur, eine Maus. Das war’s

… und los geht’s.

Im Gast-Video von homofaciens wird das Gesamtsystem einmal vorgeführt.

In diesem Video wird die Platine auch auf ihren Stromverbrauch hin untersucht.

Beim Booten lag die Stromstärke gerade einmal bei I=400mA. Bei 5 V Spannung sind das gerade einmal 2W.

Bei diesem geringen Stromverbrauch ist der Einsatz des Raspberry PI auch als Embedded Sysztem interessant.

Wie jedes ordentliche Linux lässt sich auch hier eine graphische Oberfläche verwenden.

Bei bunten Bildchen geht natürlich der Stromverbrauch in die Höhe.

Das Video zum Raspberry Pi

Im Video werden einige interessante Anwendungen gezeigt.

Bevor ich das aber hier schreibe, guck einfach ins Video.

Ich bin begeistert.

Der Beitrag Raspberry Pi erschien zuerst auf ET-Tutorials.de.

Mit Hilfe des Programmablaufplans ist das nun ganz einfach.

Nach der Definition der Variablen muss nur noch der Programmablaufplan Schritt für Schritt in den C-Code übersetzt werden.

Wichtig, und eine beliebte Fehlerquelle, ist die richtige Wahl des Variablentyps.
Die Variablen „slot“ und „temp“ sollen jeweils Werte von 0 bis 255 abspeichern können.
Wie benötigen also 8 bit, d.h. 1 Byte. Die Variablen müssen aber vorzeichenlos sein, damit bis 255 gezählt werden kann.

Also: unsigned char slot, temp;

Anschließend muss, wie gesagt, der Programmablauf in das C-Programm übersetzt werden.

Im heutigen Video zeige ich diesen Vorgang.

Weil der Mikrocontroller das Programm sehr schnell abarbeitet, sieht man in Realzeit nur, ob das Programm qualitativ funktioniert. Bei temp = 0 bleibt die Heizung ausgeschaltet, bei temp = 255 ist die Heizung eingeschaltet und bei Werten dazwischen wechselt der Zustand des Portpins für die Heizung.

In der nächsten Folge nutzen wir den Debugger von µVision und lassen das Programm einmal langsam, Schritt für Schritt ablaufen und beobachten dabei den Zustand der Variablen, Register und Portpins.

Der Beitrag Programmierung der Pulsweitenmodulation erschien zuerst auf ET-Tutorials.de.

Und zwar in Zusammenhang mit der Programmierung des Timers.

Der Timer soll jeweils nach 1 ms ablaufen. Da der Mikrocontroller mit 12 MHz getaktet ist, die Timer-Register also jede µs (Mikrosekunde)inkrementiert werden, müssen wir bis 1.000 zählen bis 1 ms vergangen ist.

Da wir dafür TH0 und TL0 benötigen, mit einem Byte kann man ja nur bis 255 zählen, wählen wir nicht den auto-reload Modus, sondern wählen den Modus 1, bei dem wir beide Timerregister für das Zählen zur Verfügung haben.

Berechnung der Initialisierungswerte für die Register TH0 und TL0:
Da wir bei 65536 einen Überlauf haben, müssen wir bei dezimal 64536 starten. Hexadezimal ist das FC18. Das bedeutet TH0=0xFC und TL0=0x18.

In dem Video zeige ich noch einmal die Berechnung und die Programmierung der Registerwerte.

Planung des Programms mit Hilfe eines Programmablaufplans, PAP

In der Interrupt Service Routine des Timers soll nun die Pulsweitenmodulation realisiert werden.

Da die Realisierung des Programms nicht ganz trivial ist, ist die Planung des Programms zu empfehlen.
Für diese Planung gibt es verschiedene Möglichkeiten. Neben Struktogrammen hat sich in der Programmierung der sogenannte Programmablaufplan als zweckmäßig erwiesen.

In einem Programmablaufplan plant man das Programm zunächst einmal unabhängig von der Sprachsyntax und schreibt den Ablauf der Programms mit all seinen Verzweigungen zunächst einmal z.B. auf einem Blatt Papier auf.

Hierdurch bekommt man eine gute Vorstellung vom Ablauf des Programms. Ein Programmablaufplan ist hierbei einfacher zu lesen und zu erstellen als das benötigte C-Programm.

In einem zweiten Schritt schreibt man dann mit Hilfe des Programmablaufplans sein C-Programm. Diese Umsetzung geht einem dann in den meisten Fällen sehr leicht von der Hand.

Wie man einen Programmablaufplan erstellen kann, zeige ich im folgenden Video.

Deine Aufgabe

Wenn ich Du wäre , würde ich mir jetzt, nachdem Du das Video gesehen hast, ein Blatt Papier nehmen und versuchen, den Programmablaufplan einmal selbständig zu erstellen – ohne noch einmal in das Video zu spicken.

Anschließend kannst Du µVision aufrufen und die Interrupt Service Routine erstellen.

Der Beitrag Ein Programmablaufplan für die Pulsweitenmodulation erschien zuerst auf ET-Tutorials.de.

Und zwar nutzen wir den Mechanismus der Pulsweitenmodulation, abgekürzt PWM, um die Wassertemperatur in der Anlage über eine Heizung gewünscht einzustellen.

Mit Hilfe der PWM können elektrische Verbraucher, die relativ langsam auf Änderungen reagieren, wie beispielsweise Heizwiderstände, aber auch beispielsweise elektrische Motoren, mit Hilfe von digitalen Signalen gesteuert werden.

Der „Trick“ dabei ist, dass man die Stromstärke durch den Verbraucher nicht analog auf den gewünschten Wert einstellt. Mit Hilfe der PWM wird der Verbraucher sehr schnell ein- und wieder ausgeschaltet.

Über das Verhältnis zwischen Einschalt- und Ausschaltzeit kann so die zugeführte Leistung eingestellt werden.

Ein Beispiel

Wenn die Leistung des Heizwiderstandes auf die „halbe Leistung“ eingestellt werden soll, schaltet man die Heizung abwechselnd zu jeweils gleichen Zeiten ein- und wieder aus.

Soll die Leistung auf 80% der Maximalleitung eingestellt werden, schaltet man die Heizung 4 Zeiteinheiten ein und dann 1 Zeiteinheit aus. So wird die Heizung zu 80% der Zeit mit voller Leistung betrieben, 20% der Zeit ist sie ausgeschaltet. Im Mittel setzt die Heizung so 80% der größtmöglichen Leistung um.

Das Video zur PWM-Pulsweitenmodulation

Deine Aufgabe zur nächsten Woche

Für die Wasserzubereitung soll über eine PWM-gesteuerte Heizung das Wasser auf die gewünschte Temperatur gebracht werden.

Die gewünschte Leistung kann über den Port P0 eingestellt werden.
P1=0x00 bedeutet also: die Heizung ist ausgeschaltet.

P1=0xFF bedeutet: die Heizung ist eingeschaltet und setzt die maximal mögliche Leistung um

Da der Port P0 8 Bit hat, kann die Leistung der Heizung also in 255 Stufen eingestellt werden.

Ein möglicher Ansatz zur Lösung die PWM

Möglich wäre beispielsweise einen Timer zu programmieren, der jede 1ms einen Interrupt auslöst.
Das gesamte Zeitintervall könnte man dann auf 255 ms setzen. Der Wert in P0 bestimmt dann, in wie vielen Zeitschlitzen von jeweils 1 ms der Portpin 1.0 auf 1 gesetzt werden müsste. In den übrigen Zeitschlitzen müsste der Portpin P1.0 dann auf 0 gesetzt werden.

Viel Spaß bei der Umsetzung und bis zum nächsten Mal.
Dieser Artikel ist Teil des Mikrocontrollerkurs auf ET-Tutorials.de.
Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .

Der Beitrag PWM – Pulsweitenmodulation erschien zuerst auf ET-Tutorials.de.

Im Gegensatz zum Mode 1, der ja die Register TH0 und TL0 als 16-Bit Zähler verwendet, wird im auto-reload Mode nur das Register TL0 als Zähler verwendet.

Im nun freigewordene Register TH0 wird der gewünschte Startpunkt des Zählers festgelegt.
So muss nur einmal das Register initialisiert werden. Nach jedem Überlauf des Registers TL0 startet also nicht nur die Interrupt Service Routine des Timers.
Die Mikrocontroller-Hardware kopiert zudem automatisch den Wert des Registers TH0 in das Register TL0. Der Zähler wird also automatisch wieder initialisiert und kann sofort ohne Zeitverzögerung weiterlaufen.

Wie das Ganze im System funktioniert, zeige ich im heutigen Video.

Viel Spaß und bis zur nächsten Folge, in der es wieder eine Aufgabe zum Thema Interrupts gibt.

Dieser Artikel ist Teil des Mikrocontrollerkurs auf ET-Tutorials.de.
Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .

Der Beitrag Timer Interrupts 8 bit auto reload erschien zuerst auf ET-Tutorials.de.

Die Aufgabe sollte so gelöst werden, dass die Interrupt Service Routine des Timers 0 alle 10 ms aufgerufen wird.

Bei jedem 1.000 Durchlauf der Interrupt Service Routine sollte dann der Port inkrementiert werden.

1000 x 10ms = 10s

Zunächst müssen also die SFR-Register TH0 und TL0 bestimmt werden, um eine Zeit von 10ms zu realisieren. Im Video rechne ich die Prozedur einmal vor.

Die Berechnung der Timer-Werte für TH0 und TL0

Damit Du die Werte besser mit Deinen Werten vergleichen kannst, gebe ich die Rechnung hier noch einmal kurz an.

Der Mikrocontroller wird mit 12 MHz getaktet. Durch den Teiler von 12 wird TL0 also jede µs inkrementiert.

10 ms entsprechen 10.000 Inkrementierungen, denn 10.000 x 1µs = 10 ms

Da die beiden Bytes bei 0xFF, dezimal also 65536 überlaufen, muss der Timerstand dezimal auf

65536-10000 =55536

gesetzt werden.

55536 dezimal entspricht D8F0 hexadezimal

Damit ergeben sich folgende Werte:

TH0 = 0xD8;
TL0 = 0xF0

Soweit zur Theorie

Video zur Programmierung des Timers

Im Video zeige ich die Programmierung der Interrupt Service Routine. Wichtig hierbei ist, die Werte für TH0 und TL0 in der Interrupt Service Routine noch einmal zu setzen, weil die Zähler ansonsten beim aktuellen Stand, also TH0 = 0x00 und TL0=0x00 loslaufen würden, statt bei TH0 = 0xD8 und TL0 = 0xF0.
Zudem darf natürlich nicht vergessen werden mit

• EAL = 1; Interrupts generell freizugeben
• ET0 = 1; den Interrupt für den Timer 0 freizugeben
• TR0 = 1; den Timer zu starten

Viel Spaß beim Video und bis zum nächsten Mal. Dann geht es um das auto-reload, bei dem der Timerstartwert „automatisch“ gesetzt wird.

Dieser Artikel ist Teil des Mikrocontrollerkurs auf ET-Tutorials.de.
Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .

Der Beitrag Timer Interrupt Lösung der Aufgabe erschien zuerst auf ET-Tutorials.de.

Um diese Fragen geht es heute.

Die Zeit, bis ein Timer ausgelaufen ist, ist zunächst einmal abhängig von der Taktfrequenz, mit der der Mikrocontroller betrieben wird. Von dieser Taktfrequenz ist abhängig, wie lange ein Maschinenzyklus dauert und die Dauer eines Maschinenzyklus bestimmt, wie schnell die Register TH0 und TL0 inkrementiert werden.
Ein Machinenzyklus dauert 12 Taktzyklen und nach jedem Maschinenzyklus wird der Zähler um 1 inkrementiert.

Ein Beispiel:

Wir der Mikrocontroller mit 12 MHz getaktet, beträgt die Frequenz für die Maschinenzyklen
12 Mhz : 12 = 1 MHz. Es gibt dann also 1 Million Maschinenzyklen pro Sekunde.
Ein Maschinenzyklus dauert also 1 µs. Jede µs wird das Registerpaar TH0/TL0 also inkrementiert.

Im Video lasse ich den Initialwert von TH0 und TL0 auf 0. Wir benötigen also 2 hoch 16 = 65536 Inkrementierungen bis zum Überlauf.
Die Interrupt Service Routine des Timers wird also jede 65536 x 1µs = 0,065536s aufgerufen.

Die Programmierung dieses Timers im Video

Deine Aufgabe

Durch die Wahl der Werte von TH0 und TL0 kann man bestimmen, wie lange es vom Start des Timers bis zum Aufruf der Interrupt Service Routine dauert.
Es soll nun ein Timer programmiert werden , der alle 10 ms aufgerufen wird und dann bei jedem 1000. Mal den Port P1 inkrementiert. Der Port P1 wird dann also genau alle 10s inkrementiert.

Hinweis

Berechne also zunächst einmal die Werte für TH0 und TL0, um einen Überlauf nach 10ms zu erreichen. Diese Werte musst Du in die Register TH0 und TL0 schreiben, bevor Du den Timer startest.
Zudem musst Du die Werte in der Interrupt Service Routine wieder in die Register TH0 und TL0 schreiben, weil Du ja möchtest, dass der Zähler genau bei diesen Werten weiterzählt,um nach 10 ms den nächsten Überlauf zu erhalten.

Viel Spaß!

Dieser Artikel ist Teil des Mikrocontrollerkurs auf ET-Tutorials.de.
Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .

Der Beitrag Programmieren des Timer Interrupts erschien zuerst auf ET-Tutorials.de.

Sehr häufig müssen in diesen Aufgabenstellungen Zeiten sehr genau eingehalten werden, um zeitkritische Abläufe zu messen und zu steuern .

Aus diesem Grund sind Mikrocontroller häufig mit mehreren Timern ausgestattet, die unabhängig voneinander programmiert werden können.

Bei Ablauf eines Timers wird dann beispielsweise eine Interrupt Service Routine aufgerufen, die so also genau zu dem gewünschten Zeitpunkt zuschlägt.

Heute geht es darum, wie die Timer eines 8051 Mikrocontrollers programmiert werden und welche Register man zur Programmierung benötigt.

Konfiguration eines Timers

Die Konfiguration eines Timer Interrupts ist etwas aufwändiger als beim externen Interrupt.
Im ersten Video zeige ich also zunächst einmal die wichtigsten Register zur Konfiguration eines Timers.

Im zweiten Video zeige ich dann die Konfiguration des Timers und die Programmierung der Interrupt Service Routine am Emulator.

Deine Aufgabe

Heute gibt es keine spezielle Programmieraufgabe, in der Du eine bestimmte Aufgabe lösen sollst.

Du solltest Dich aber bis zur nächsten Folge mit dem Timer beschäftigen. So könntest Du beispielsweise das Beispiel nachprogrammieren, oder dieses Beispiel auf den Timer 1 übertragen.

Wichtig ist hierbei, dass Du die zu verwendenden Register kennenlernst. Also: Mit welchem Register gibt man den Timer frei, wie startet man einen Timer, wie schreibt man eine Interrupt Service Routine, usw.

Man muss die Befehle einmal selbst eingetippt haben, die Register einmal selbst gesetzt und gelöscht haben, um ein Gefühl dafür zu bekommen.

Also: Programmiere das Beispiel einmal nach und setze es anschließend für den Timer 1 um.

Die Priority Order für den Timer 1 ist übrigens 3.

Also: void ISR_Timer1(void) interrupt 3

{}

Dieser Artikel ist Teil des Mikrocontrollerkurs auf ET-Tutorials.de.
Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .

Der Beitrag Timer Interrupt des 8051 Mikrocontrollers erschien zuerst auf ET-Tutorials.de.

Dies nennt man Software Interrupt, Trap oder Exception.

Ein solcher Software Interrupt sollte in der Aufgabe aus der letzten Folge genutzt werden, um bei dem Eintreffen eines Signals für den Interrupt INT1 auch die Interrupt Service Routine für den Interrupt INT0 auszuführen.

Um Software Interrupts auszuführen nutzt man das Interrupt Pending Flag.

Es muss also lediglich das Interrupt Pending Flag IE0 in der Interrupt Service Routine für den Interrupt INT1 gesetzt werden.

Voilá

Dieser Artikel ist Teil des Mikrocontrollerkurs auf ET-Tutorials.de.
Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .

Der Beitrag Software Interrupts, Traps erschien zuerst auf ET-Tutorials.de.

Zur Erinnerung. Die Aufgabe lautete:

Bei der Kaffeemaschine können zwei Störungen auftreten, die jeweils einen Interrupt am Mikrocontroller auslösen.

Diese beiden Fehlermeldungen sollen ausgewertet werden.

1. Die Maschine muss (bei Gelegenheit) entkalkt werden.
   Der Sensor, der eine zu hohe Verkalkung anzeigt, ist an INT0 angeschlossen und gibt als Meldung eine „0“ aus. Wenn der Sensor eine Verkalkung feststellt, soll an Portpin P0.0 eine „1“ ausgegeben werden. Hierdurch wird ein Warnsummer eingeschaltet. Da diese Meldung nicht so kritisch ist, kann der Summer ausgeschaltet werden. Er soll nicht automatisch wieder eingeschaltet werden, auch wenn die Kaffeemaschine noch nicht entkalkt worden ist.
2. Der Druck der Maschine ist zu hoch. Der Sensor hierfür ist an INT1 angeschlossen und gibt als Meldung eine „0“ aus. Dieser Zustand ist kritisch. In der zugehörigen Interrupt Service Routine soll an Port P0.1 eine „1“ ausgegeben werden. Hierdurch wird ein Alarm ausgelöst und die Kaffeemaschine heruntergefahren. Sollte jemand den Alam löschen, der Druck aber immer noch zu hoch sein, soll automatisch die ISR wieder aufgerufen werden.

Flankengesteuerter Interrupt

Für den ersten Fall sollte die Programmierung also so aussehen, dass die Fehlermeldung „weggedrückt“ werden kann. Obwohl der Fehler vom Sensor weiter gemeldet wird, sollten keine neuen Interrupts generiert werden. Die Lösung dafür ist, den Interrupt INT0 flankengesteuert zu konfigurieren, so dass die Interrupt Service Routine nur einmal, beim Auftreten des Fehlers, ausgelöst wird. Nur dann sehen wir die negative Flanke.

Pegelgesteuerter Interrupt

Im zweiten Fall soll der Alarm nicht abgeschaltet werden können. So lange der Druck zu groß ist, soll der Alarm wieder erneut eingeschaltet werden.

Das kann dadurch erreicht werden, indem der Interrupt pegelgesteuert realisiert wird. Das heißt, so lange die Fehlerbedingung anlegt, wird laufend die Interrupt Service Routine ausgeführt.

Das Video

Auch in dieser Woche gibt es wieder eine kleine Aufgabe. Du erinnerst Dich vielleicht noch an den Begriff der Interrupt Pending Flags aus der Folge externe Interrupts.

Dieser Mechanismus, das Auslösen von Interrupts per Software, soll nun genutzt werden.

Aufgabe

Wenn der Druck zu hoch ist, soll so viel Radau wie möglich gemacht werden. Es soll neben dem eigentlichen Alarm „Druck zu hoch“ auch der Summer für die Kalkmeldung eingeschaltet werden.

Da nicht an der Hardware geschraubt werden soll, muss dies durch Software gelöst werden. Hierzu soll auch der Interrupt INT0 ausgelöst werden, wenn der Druck zu hoch ist.

Dieser Artikel ist Teil des Mikrocontrollerkurs auf ET-Tutorials.de.
Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .

Der Beitrag Lösung der Aufgabe zu den externen Interrupts erschien zuerst auf ET-Tutorials.de.

Lediglich einige wichtige Register, die über die Special Function Register des 8051 erreicht werden können, müssen gesetzt werden. Dann muss noch die gewünschte Interrupt Service Routine erstellt werden und schon kann auf externe Signale reagiert werden.

Der heutige Artikel besteht aus 2 Videos. Im ersten Video erläutere ich die wichtigsten Register, die ich hier noch einmal aufführe.

Register für den Interrupt INT0

/INT0 am Portpin 3.2:
An diesen Anschluss muss das Signal für den externen Interrupt 0 angeschlossen werden.

EAL, Enable All Interrupts:
EAL muss gleich 1 gesetzt werden, damit eine Anforderung eines Interrupts überhaupt durchgelassen werden können. Dieses Bit ist nach dem Start des Controllers auf 0 gesetzt. Interrupts werden also zunächst nicht zugelassen. So kann das Gesamtsystem zunächst einmal initialisiert werden, ohne von Interrupts gestört zu werden.

EX0, Enable eXternal Interrupt 0:
schaltet den externen Interrupt 0 frei

IT0:
0 bedeutet pegelgesteuerter Interrupt
1 bedeutet flankengesteuerter Interrupt

IE0: ist das zugehörige Interrupt Pendig Flag,
das auch per Software gesetzt werden kann. So könnte man eine Interrupt Service Routine auch per Software auslösen, ein sogenannter Software Trap.

Externer Interrupt 0

Jetzt aber zum Video

Der externe Interrupt 0 umgesetzt

Im folgenden Video zeige ich eine Umsetzung des externen Interrupts 0, bei der ich auch den Unterschied zwischen flankengesteuertem Interrupt und pegelgesteuerten Interrupt erläutere.

Deine Aufgabe

Heute lohnt es sich wieder eine Funktion für den Kaffeeautomaten zu schreiben. Und zwar fehlen noch einige Sicherheitsfunktionen.

In so einer professionellen Kaffeemaschine muss die Funktionstüchtigkeit der Gesamtanlage dauernd überwacht werden.

Deine Aufgabe ist es zwei mögliche Fehler auszuwerten und anzuzeigen.

1. Die Maschine muss (bei Gelegenheit) entkalkt werden
   Der Sensor, der eine zu hohe Verkalkung anzeigt, ist an INT0 angeschlossen und gibt als Meldung eine „0“ aus. Wenn der Sensor eine Verkalkung feststellt, soll an Portpin P0.0 eine 1 ausgegeben werden. Hierdurch wird ein Warnsummer eingeschaltet. Da diese Meldung nicht so kritisch ist, kann der Summer ausgeschaltet werden. Er soll nicht automatisch wieder eingeschaltet werden, auch wenn die Kaffeemaschinen noch nicht entkalkt worden ist.
2. Der Druck der Maschine ist zu hoch. Der Sensor hierfür ist an INT1 angeschlossen und gibt als Meldung eine „0“ aus. Dieser Zustand ist kritisch. In der zugehörigen Interrupt Service Routine soll an Port P0.1 eine 1 ausgegeben werden. Hierdurch wird ein Alarm ausgelöst und die Kaffeemaschine heruntergefahren. Sollte jemand den Alarm löschen, der Druck aber immer noch zu hoch sein, soll automatisch die ISR wieder aufgerufen werden.

Es geht also in der Aufgabe sowohl um den Interrupt 0 und den Interrupt 1 und um pegelgesteuerte wie auch um flankengesteuerte Interrupts.

Hinweis zur Programmierung der Interrupt Service Routine.

Im Video habe ich gezeigt, dass für den Interrupt 0 die Priority Order 0 gilt. Für den Interrupt 1 gilt die Priority Order 2.

Die Interrupt Service Routinen sehen also beispielsweise wie folgt aus:

void ISR_INT0 (void) interrupt 0
{}

void ISR_INT1 (void) interrupt 2
{}

Dieser Artikel ist Teil des Mikrocontrollerkurs auf ET-Tutorials.de.
Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .

Der Beitrag Externe Interrupts beim 8051 erschien zuerst auf ET-Tutorials.de.

• Was sind Interrupts?
• Wozu benötigt man Interrupts?
• Was ist der Unterschied zum Polling-Verfahren?

Interrupts versus Polling

Beim Polling fragt man Signale regelmäßig innerhalb der while-Schleife ab und wertet diese Signale aus.
Ein großer Nachteil beim Polling ist allerdings, dass auf Signale nicht sofort reagiert werden kann, sondern erst mit einer Verzögerung.
So kann es im schlechtesten Fall passieren, dass man ein Signal gerade abgefragt hat und kurz nach dieser Abfrage das externe Signal am entprechenden Port anliegt.

In dieser Situation kann es relativ lange dauern, bis der Port wieder abgefragt wird, je nach dem wie lange die Verarbeitung der Befehle in der while-Schleife dauert.

Bei kritischen Signalen, beispielsweise einer kritischen Fehlersituation, bei der sofort reagiert werden muss, kann das untragbar sein.

In solchen Fällen nimmt man besser Interrupts.

Bei Interrupts wird sofort reagiert. Wenn ein Interrupts-Signal auftritt, wird der aktuelle Befehl des Hauptprogramms beendet, die nötigen Register auf den Stack gerettet und dann anschließend sofort die ISR aufgerufen.
Man hat in diesem Fall also kaum Zeitverzug zwischen der Ausführung der ISR und dem Auftreten des Signals.

Den Unterschied zwischen dem Polling-Verfahren und Interrupts zeige ich im folgenden Video.

In der heutigen Folge sollte es lediglich um den Unterschied zwischen Polling und Interrupts gehen. Die Feinheiten von Interrupts werden wir in den folgenden Folgen behandeln.
Der Vollständigkeit halber kopiere ich hier noch die beiden Quellcodes hinein.

Polling

#include<REG515.H>

sbit Fehler=P2^0;
sbit Alarm=P2^1;

void alarmauswertung(void)
{
Alarm = Fehler;
}

void main(void)
{
unsigned long int i=0;
P1 = 0;
P2 = 0;

Fehler = 1;
Alarm = Fehler;

while(1)
{
for (i=0; i<100000;i++)
{
P1=i;
}
alarmauswertung();

}

}

Interrupt

#include<REG515.H>

sbit Alarm=P2^1;

void ISR_alarmauswertung(void) interrupt 0
{
Alarm = 1;
}

void main(void)
{
unsigned long int i=0;
P1 = 0;
P2 = 0;

EAL    = 1;
EX0 = 1;

while(1)
{
for (i=0; i<100000;i++)
{
P1=i;
}

}

;

}

Bis zum nächsten Mal!

Dieser Artikel ist Teil des Mikrocontrollerkurs auf ET-Tutorials.de.
Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .

Der Beitrag Interrupts und Polling erschien zuerst auf ET-Tutorials.de.

Es ging wieder um den Kaffeeautomaten. Über LEDs sollte angezeigt werden, welches Getränk ausgewählt wurde.

Die Eingabe sollte nun über Schalter erfolgen, die den jeweiligen Portpin entweder mit  High, also logisch „1“, oder mit Low, logisch “0“, verbindet.

Im Gegensatz zu den vorherigen Aufgaben sollte nun also nicht in einen Port geschrieben, sondern aus den Ports gelesen werden.

Wie wir in der vorherigen Folge bereits gesehen haben, muss man eine 1 in das Port-Latch schreiben, wenn aus dem zugehörigen Portpin gelesen werden soll.

Das Video

Im Video zeige ich eine mögliche Lösung.

Letztendlich geht es nur darum, die jeweiligen Portpins P1.5, P1.6 und  P1.7 auf „1“ zu setzen und schon kann es losgehen.

#include<REG515.H>

sbit EingabeKaffee = P1^0;

sbit EingabeEspresso = P1^1;

sbit EingabeCapuccino = P1^2;

 

 

sbit AusgabeKaffee = P1^3;

sbit AusgabeEspresso = P1^4;

sbit AusgabeCapuccino = P1^5;

 

void main(void)

{

P1 = 0x07;

while(1)

{

AusgabeKaffee=EingabeKaffee;

AusgabeEspresso=EingabeEspresso;

AusgabeCapuccino=EingabeCapuccino;

}

 

}

In der nächsten Folge geht es um Interrupts.

Bis dann!

Dieser Artikel ist Teil des Mikrocontrollerkurs auf ET-Tutorials.de.
Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .
 

Der Beitrag Lösung zur Aufgabe: Lesen aus Ports erschien zuerst auf ET-Tutorials.de.

Diese Treiberschaltung benötigt man für das Schreiben und für das Lesen aus Ports. In der letzten Folge haben wir ja bereits bemerkt, dass ein Portpin, der zum Lesen externer Signale genutzt werden soll, entsprechend vorbereitet werden muss.
Und zwar müssen wir eine 1 in das entsprechende Portbit schreiben. Diese 1 wird in ein Latch, ein D-Flipflop, gespeichert.

Um Informationen an ein Portpin auszugeben, ist eine einfache Transistorschaltung auf dem Mikrocontroller integriert, mit dessen Hilfe über eine Pullup-Schaltung (manchmal ist auch ein externer Pullup-Widerstand nötig) die Information nach außen geschaltet werden kann. Das ist noch relativ unspektakulär

Das Lesen aus einem Portpin ist etwas kniffeliger.

Wäre der Ausgangstransistor durchgeschaltet, so wäre der Portpin dauernd auf Masse gezogen, unabhängig davon, welcher Pegel physikalisch am Portpin angelegt werden würde. Die gelesene Information wäre immer 0.
Aus diesem Grund muss, wenn man aus einem Portpin gelesen werden soll, das D-Flipflop immer gesetzt werden. Dies erreicht man, indem man eine 1 in den Portpin schreibt.
Die Regel lautet also:

Wenn man aus einem Portpin lesen möchte, muss das Portbit auf 1 gesetzt werden

Jetzt, wo das nun klar ist, gibt es noch eine gute Nachricht

Unsere Portbits sind nämlich bitadressierbar. Das heißt, man muss sich nicht bei der Arbeit mit einzelnen Portpins , wie in der Folge zur Bitweisen Manipulation gezeigt, mit Masken herumschlagen, sondernman kann die Portbits einzeln ansprechen.
Was man tun muss, um die Portbits einzeln anzusprechen, zeige ich ebenfalls im heutigen Video.

Jetzt bist Du wieder an der Reihe

Die Wahl des Getränks für den bereits im ersten Teil des Mikrocontrollerkurses verwendeten Kaffeeautomaten, soll nun über Schalter erfolgen, die an die Portpins P0_0 bis P0_2 angeschlossen sind.

Dem Kunden, der ein Getränk ausgewählt hat, soll die Getränkewahl über Leuchtdioden angezeigt werden, die an den Ports P0_3 bis P0_5 angeschlossen sind.

Das heißt, wenn der Schalter P0_0 geschlossen ist, soll die LED an P0_5 leuchten, usw.

Versuche bitte einmal, diese Funktionalität zu programmieren.

Dieser Artikel ist Teil des Mikrocontrollerkurs auf ET-Tutorials.de.
Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .

Der Beitrag Lesen aus Portpins erschien zuerst auf ET-Tutorials.de.

Wir setzen auf das von uns neu erstellte Projekt auf. Wenn Du dieses Projekt noch nicht erstellt hast, dann guck Dir am besten noch einmal die vorherige Folge an. Dort zeige ich, wie man von Beginn an ein neues Projekt in uVision 4 aufsetzt.

Um in unserem neuen, leeren Projekt mit Ports zu arbeiten, muss dem Compiler zunächst einmal mitgeteilt werden, unter welcher Adresse er die Ports des Mikrocontrollers findet.

Dies macht man beispielsweise durch die  Zuordnung:

sfr P0     = 0x80;

In diesem Beispiel wird definiert, dass ein Zugriff auf P0 (das ist der Port 0) über die Adresse 0x80 erfolgt.

Sfr steht für Special Function Register. Das Special Function Register ist ein für den 8051 sehr wichtiger Speicherbereich, über den die CPU mit der zusätzlichen Hardware, wie beispielsweise den Ports, den Timern und weiteren Schnittstellen kommunizieren kann.

Mit den Special Function Registern werden wir hier noch sehr häufig zu tun haben.

Aber zurück zu den Ports.

Die einzelnen Adresszuordnungen, also welcher Port über welche Adresse angesprochen werden kann, muss man glücklicherweise nicht mühsam aus den Datenblättern heraussuchen.

Diese Zuweisungen sind in einer .h-Datei bereits vorbereitet worden.

In unserem Fall ist das die Datei reg515.h. Diese Datei enthält die gesamten Definitionen der Special Function Register unseres Mikrocontrollers.

Um diese Informationen nutzen zu können, bindet man einfach die Datei reg515.h oben in den Quelllcode ein, mit

#include<REG515.H>

Im Video führe ich das gesamte Prozedere einmal durch.

Dieser Artikel ist Teil des Mikrocontrollerkurs auf ET-Tutorials.de.
Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .

Der Beitrag Definition der Portadresse durch die Special Function Register erschien zuerst auf ET-Tutorials.de.

Im Gegensatz zu den Projekten aus dem ersten Teil des Mikrocontroller-Kurses soll es also nicht darum gehen, ein bestehendes Projekt mit einem Grundgerüst weiter zu entwickeln, sodern darum, ein komplett neues Projekt aufzubauen.

Dies ist zwar in wenigen Schritten erledigt. An einigen Stellen ist die Einrichtung jedoch nicht komplett intuitiv.

Zudem wird man aufgefordert, schon bei dem Anlegen des Projektes vorzugeben, für welchen Mikrocontroller man die Software erstellen möchte. Hier hat man die Wahl zwischen sehr vielen Herstellern mit den unterschiedlichsten Typen.

Wir wählen für unseren Kurs einen einfachen Mikrocontroller aus. Und zwar einen Mikrocontroller der Firma Infineon, den 80C51.

Unter folgendem Link findest Du das Datenblatt zum Controller.

Aber keine Angst: Für den Kurs musst Du das Datenblatt nicht komplett verstehen. Die Teile, die wir aus dem Datenblatt benötigen, werde ich ausführlich in diesem Kurs erklären.
Und auch wenn das Datenblatt in englischer Sprache geschrieben ist, die Information, die wir benötigen sind international. Man muss also nicht unbedingt eine „Englisch-Leuchte sein.

Der Mikrocontroller Infineon 80C51 ist einfach aufgebaut und hat wenig mehr als der „Ur-8051“, so dass man die Struktur eines 8051 sehr leicht verstehen kann, ohne sich von den zusätzlichen Features eines modernen 8051 verwirren zu lassen.
Wie ich bereits in der einführenden Folge zum 8051-Kurs geschrieben habe, kann man später, wenn man die Grundlagen verstanden hat, leicht auf das gewünschte 8051-Derivat umsteigen.

Aber der Reihe nach …

Im folgenden Video zeige ich zunächst, wie Du Schritt für Schritt ein neues Projekt anlegst.

Jetzt solltest Du in Deiner µVision-Software ein neues Projekt anlegen, damit Du für die nächste Folge gerüstet bist

Dieser Artikel ist Teil des Mikrocontrollerkurs auf ET-Tutorials.de.
Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .

Der Beitrag Ein neues Projekt in uVision 4 erschien zuerst auf ET-Tutorials.de.

Und zwar um die Programmierung eines Mikrocontrollers aus der 8051-Familie. Bereits Anfang der 80er Jahre hat die Firma Intel die 8051-Familie vorgestellt.

Zu dieser 8051-Familie gehören verschiedene Mikrocontroller unterschiedlicher Hersteller, die alle auf Basis der 8051 Mikrocontroller basieren.

Im Laufe der Jahre wurden so von den verschiedenen Herstellern immer neue Mikrocontroller auf 8051-Basis entwickelt.

Wir haben also eine Mikrocontrollerfamilie vor uns, die einerseits schon sehr lange existiert, andererseits nicht „alt“ im Sinne von „überholt“ ist.

Durch die ständige Weiterentwicklung sind sehr leistungsfähige Mikrocontroller entstanden, die mit den alten 8051-Derivaten nicht mehr zu vergleichen sind und zu den leistungsfähigsten Mikrocontrollern gehören, die am Markt erhältlich sind.

Zudem ergibt sich so der Vorteil, dass man beim Erlernen der Feinheiten der 8051-Mikrocntroller, mit einfach aufgebauten Modellen beginnen und dann je nach Anforderung in der Praxis einen komplizierten 8051 auswählen kann.

Merkmale eines 8051 Mikrocontrollers

Die wichtigsten Merkmale sind

• Der 8-Bit Prozessorkern mit einheitlichem Befehlssatz

• ein mindestens 128 Bytes großes internes RAM

• ein einheitliches Adressierungsmodell für so genannte Special Function Register (SFR)

• Full-Duplex-UART

• Externe Interrupts

• diverse Timer

Diese Merkmale und die Programmierung des ADC (Analog/Digital-Converter), also des Analgog/Digital-Wandlers werden wir uns in diesem Teil des Kurses anschauen und natürlich programmieren.

Eine Übersicht zum 2. Teil (8051)

Im folgenden Video stelle ich eine Übersicht zu den Inhalten des Kurses vor.

Im nächsten Teil werden wir dann ein neues Projekt von Anfang an in Keil anlegen und den gewünschten 8051 auswählen.

 
Dieser Artikel ist Teil des Mikrocontrollerkurs auf ET-Tutorials.de.
Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .
 

Der Beitrag Übersicht zum 8051 Mikrocontroller Kurs erschien zuerst auf ET-Tutorials.de.

Natürlich ist auch dieser Kurs wieder kostenlos.

Es handelt sich genau genommen auch nicht um einen neuen Kurs, sondern eher um eine andere Organissation der Durchführung.

Bisher war es so, dass jeder, der sich neu für den bereits bestehenden Kurs angemeldet hatte, einen „Quereinstieg“ gemacht hat. Das macht nun da wir schon 40 Folgen hinter uns gebracht haben, keinen Sinn.

Der Mikrocontroller-Kurs als Email-Kurs

Wer sich ab jetzt neu für den Mikrocontroller-Kurs anmeldet, bekommt nun die Kursinhalte von Anfang an per Email.

Also beginnend ab Folge 1.

Zudem wird es zusätzliche Inhalte, wie beipielsweise der Quellcode für die Lösungen der Übungsaufgaben per Email geben.

Wenn Du bereits alle Folgen gesehen hast, brauchst Du nichts weiter zu unternehmen. Du erhälst dann weiterhin wie gehabt alle neuen Folgen per Email zugeschickt. Es ändert sich dann für Dich nichts.

Wenn Du den Kurs von Anfang an mitmachen möchtest, dann trage Deine Emailadresse in das folgende Feld ein. Du erhälst dann von mir eine Email mit einem Bestätigungs-Link.
Durch einen Klick auf diesen Link , bestätigst Du, dass Deine Email-Adresse tatsächlich von Dir und niemand anderem eingetragen wurde. So wird verhindert, dass irgendein Witzbold andere Emailadressen einträgt.
Trage hier nun Deine Email-Adresse ein, um Dich für den Kurs anzumelden.

	Wir halten uns an den Datenschutz.

Wichtig:
Deine EMail-Adresse behandle ich natürlich vertraulich und gebe diese an niemanden weiter. Zudem kannst Du Dich jederzeit durch einen Klick auf den Abmeldelink in einer der Emails einfach wieder abmelden.

Der Beitrag Mikrocontroller Emailkurs erschien zuerst auf ET-Tutorials.de.

Glücklicherweise gehen die Abitur- und Fachabiturprüfungen nun in die letzte Runde. Ja, Nordrhein-Westfalen ist in diesem Jahr ziemlich spät dran.

Wie dem auch sei: In dieser Woche halte ich noch eine schriftliche Fachabitur-Prüfung, in der nächsten Woche noch eine mündliche Prüfung und dann ist wieder Land in Sicht.

Zwei Dinge sind für den Mikrocntroller-Kurs geplant.

Der zweite Teil: Programmierung des 8051 Mikrocontrollers

Im zweiten Teil wird es wie geplant um die Programmierung der 8051-Familie gehen.
Interrupts, Timer, Analog/Digital-Wandlung, serielle Schnittstelle werden die Themen sein.
Die Vorbereitungen sind gemacht, die Videos muss ich aber noch produzieren.

Der Mikrocontroller-Kurs als Email-Kurs

Seitdem der Kurs online ist haben sich mittlerweile über 500 Teilnehmer angemeldet, einige davon auch erst in der Pause von Weihnachten bis jetzt.

Viele haben also den Aufbau des Kurses nicht „live“ verfolgt, sondern sind erst später eingestiegen.

Das ergibt folgendes Problem.

Wer sich heute anmeldet, erhält nur die aktuelle Folge, also Folge 41, als Email.

Sinnvoller wäre es aber bei der ersten Folge zu beginnen.

Ich werde daher, den Kurs noch einmal als Email-Kurs aufsetzen, so dass diejenigen, die sich anmelden, von Anfang an, Folge für Folge per Email durch den gesamten Kurs begleitet werden.

Die Softwarelösung hierfür habe ich bereits ausgesucht und bestellt.

Ich hoffe, in der nächsten Woche den Kurs aufsetzen zu können. Du bekommst dann Bescheid und kannst Dich dann entscheiden, ob es für Dich mehr Sinn macht in diesem Email-Verteiler zu bleiben, Dich in den Email-Kurs von Anfang anzumelden oder beides zu tun.

Wie gesagt, in der nächsten Woche gibt es (hoffentlich) dazu mehr.

Der Beitrag Mikrocontroller-Kurs – Wie geht’s weiter? erschien zuerst auf ET-Tutorials.de.

Ich hoffe, Du konntest mit der Aufgabe etwas anfangen.  Auch wenn die Funktionsweise des Bubblesort Algorithmus sehr einsichtig und leicht zu verstehen ist, die Implementierung von Bubblesort hat schon hier und da seine Tücken.

Zunächst einmal muss man auf die Funktionsweise der Pointer achten und aufpassen, dass man nicht irgendwann einmal ins Nirwarna pointert.

Zusätzlich hat man das Problem, dass man mit mehreren ineinander geschachtelten Schleifen hantieren muss.

Es gilt also: Die Übersicht bewahren.

Im Video zeige ich eine mögliche Lösung zur Implementierung des Bubblesort Algorithmus.

Es gibt noch viele andere Lösungen Bubblesort zu implementieren, sicher auch noch schönere.

Wenn Du Lust hast, dann poste Deine Lösung einfach unter dem Artikel.

Der Beitrag Implementierung von Bubblesort erschien zuerst auf ET-Tutorials.de.

Aber der Reihe nach.

In den vergangenen Folgen haben wir uns ja schon ausgiebig mit Pointern und Arrays beschäftigt.

Die Theorie sitzt soweit, denke ich. Falls Du noch ein bisschen Übung beim Programmieren benötigst, ist das Thema Pointer eine wunderbare Gelegenheit.
Das Programmieren mit Pointern und das Ausprobieren erklärt viele Dinge.

Nachdem die Grundlagen zu Pointern also abgehakt sind, stellt sich die Frage, was man mit Pointern überhaupt machen kann. Zum Selbstzweck sind Pointer bestimmt nicht erfunden worden.

Ein Kommentar von Christos im letzten Artikel bringt die Problematik schön auf den Punkt.

Leider habe ich bisher in Übungen usw. Pointer nur bis zu diesem Punkt
angewendet.
Wofür sind Pointer eigentlich in der Programmierpraxis gut? In welchen Fällen
hat man in der allgemeinen Programmierpraxis und beim programmieren von Mikrocontrollern Vorteile, wenn man mit Pointern arbeitet? Und welche?
Wozu dienen Sie? Ich hab mal gehört, dass Sie z.B. Speicherplatz sparen sollen?

Das kann doch eigentlich nicht sein. Oder? Sie benötigen doch schließlich auch ein Speicherplatz wie eine „normale“ Variable.

Bubblesort

Deshalb soll es jetzt einmal um eine Anwendung von Pointern gehen. Und zwar am Beispiel einer Sortieraufgabe mit Bubblesort.

Bubble kommt aus dem Englischen und bedeutet Blase, im Sinne von Luftblase. Und genau wie die Luftblasen in einer Flüssigkeit nach oben steigen und sich schwere Elemente unten und leichtere Elemente oben anlagern, treiben durch Bubblesort Elemente aufgrund ihres Wertes an die richtige Stelle.

Video zu Pointern und Bubblesort

Wie das genau funktioniert zeige ich im folgenden Video.

Falls Du Dich noch tiefer mit Bubblesort beschäftigen möchtest /musst poste ich hier noch einem mal den Link zum Wikipedia Bubblesort-Artikel.

Bubblesort ist keine sehr elegante Art zu sortieren. Es gibt bessere Algorithmen zur Sortierung. Hier geht es darum, den Umgang mit Pointern zu üben. Und dafür benötigen wir einen Algorithmus, der leicht zu implementieren ist.

Deine Bubblesort Funktion

Die heute Aufgabe hat es schon in sich. Programmiere die Funktion sort, die die Elemente mit Bubblesort ordnet.

Beim nächsten Mal gibt es dann eine mögliche Lösung zur Implementierung von Bubblesort.

Dieser Artikel ist Teil des Mikrocontroller-Kurses auf ET-Tutorials.de.
[ >> Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .]

Der Beitrag Anwendung von Pointern – Bubblesort erschien zuerst auf ET-Tutorials.de.

Du bist sicher schnell auf die Lösung gekommen, auch ohne die Zeilen einfach in die Entwicklungsumgebung einzugeben.

Falls Du die Aufgabe noch nicht gemacht habe, lies Dir die vergangene Folge noch einmal durch, schau Dir das Video an und versuche die kleine Aufgabe zu lösen.
Gesucht war ja, herauszufinden, was die folgenden Befehle machen.

i_ptr=Array;
for ( i=0;  i<10; i++)
{
printf(„%d\n“,*i_ptr++);

}

Auch wenn der Term *i_ptr++ zunächst ein wenig kompliziert aussieht, ist die Lösung der Aufgabe eigentlich ganz einfach.

Man muss sich nur Schritt für Schritt der Lösng nähern.

Der Inhalt des Pointers i_ptr wird ausgeben und anschließend wird der Pointer inkrementiert.

Danach zeigt der Pointer auf das nächste Feld des Arrays. Hierbei ist es wichtig den Unterschied zwischen i++ und ++i zu kennen. Im zweiten Fall würde die Variable zuerst inkrementiert. Das erste Feld würde dann also nicht ausgegeben. Dafür aber die Speicherstelle hinter dem Array. Was dort auch immer stehen mag.

Im folgenden Video zeige ich noch einmal die Lösung in der Entwicklungsumgebung.

Am Ende des Videos zeige ich noch eine kleine Spielerei mit Pointern. Mit Pointern kann man allerlei Unfug treiben.

Daher Vorsicht: Um Dinge auszuprobieren und um zu testen, ob man das Thema Pointer wirklich verstanden hat, kann man solche harten Zugriffe auf den Speicher durchaus einmal machen.

Mit seriöser Mikrocontrollerprogrammierung hat das natürlich nichts zu tun. In der Praxis also unbedingt Finger weg von solchen Tricks.

Man kann nie sicher sein, wie der Compiler und der Linker die Variablen verwalten. Wenn man dann mit einem Pointer eine falsche Speicherstelle beschreibt kann das böse Auswirkungen haben.

Bei einer ernsthaften Programmierung bitte nie in hart-codierte Adressen schreiben.

Bis zum nächsten Mal!

Dieser Artikel ist Teil des Mikrocontroller-Kurses auf ET-Tutorials.de.
[ >> Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .]

Der Beitrag Pointer in C – Lösung und Spielereien erschien zuerst auf ET-Tutorials.de.

Arrays sind nichts anderes als ein Feld mit Variablen gleichen Typs.

So erzeugt beispielsweise die Anweisung

int arr [10];

ein Feld mit 10 Integerwerten, die ich mit arr[0] bis arr[9] ansprechen kann.

Der Name des Arrays ist dabei ein Zeiger auf dieses Feld und zeigt auf das erste Feld des Arrays.

Man kann also den Namen des Arrays einem Pointer des gleichen Typs zuordnen und dann anschließend den Pointer dereferenzieren um den Inhalt zu erhalten.

Desweiteren ist es möglich, den Pointer zu inkrementieren, um so auf den nächsten Eintrag des Arrays zu verweisen.

Im folgenden Video zeige ich den Zusammenhang zwischen Array und Pointer an einem Beispiel.

Deine Aufgabe

Und hier nun wie im Video versprochen die 5 Zeilen Code.

i_ptr=Array;
for ( i=0;  i<10; i++)
{
printf(„%d\n“,*i_ptr++);

}

Anmerkung: i ist eine Variable vom Typ integer, die selbstverständlich noch vorher definiert werden muss.

• Versuche einmal herauszufinden, was dieser Code genau macht und warum.

• Überlege zunächst, bevor Du den Code compilierst und ausprobierst.

Im nächsten Artikel gibt es ein paar Anmerkungen zu diesen Zeilen.

Dieser Artikel ist Teil des Mikrocontroller-Kurses auf ET-Tutorials.de.
[ >> Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .]

Der Beitrag Pointer und Arrays erschien zuerst auf ET-Tutorials.de.

Heute werde ich einem kurzen Artikel auf die Aufgabe aus der letzten Folge eingehen.

Die Aufgabe sah folgendermaßen aus:

1. Definiere zwei Integer-Variablen i und j und weise den Variablen Werte zu.
2. Definiere zwei Pointer auf Integervariable und lasse diese Pointer auf die Variablen zeigen.
3. Addiere die Werte der Variablen, indem Du NICHT die Variablen verwendest, sondern über die Pointer gehst und gebe die Summe mit printf aus.

Im folgenden Video zeige ich eine mögliche Lösung.

Dieser Artikel ist Teil des Mikrocontroller-Kurses auf ET-Tutorials.de.
[ >> Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .]

Der Beitrag Pointer in C – Lösung der Aufgabe erschien zuerst auf ET-Tutorials.de.

Es geht um Pointer.

Ich weiß nicht, warum viele Programmierer solche Angst vor Pointern haben und deshalb zu viel Respekt vor der Programmiersprache C haben. Und aus diesem Grund erst gar nicht in C programmieren wollen.

Denn

1. Ist das Programmieren mit Pointer gar nicht so schwer, wenn man ohne Vorbehalt an das Thema rangeht und
2. kann man mit Pointern viele Dinge tun, die man mit anderen Programmiersprachen erst gar nicht machen kann. Statt auf eine weniger  mächtige Programmiersprache zu wechseln, könnte man dann auch einfach in C programmieren ohne Pointer zu verwenden

Wie ich unter 1. aber schon geschrieben habe, braucht man aber keine Angst vor Pointer zu haben.

Was sind Pointer

In diesem Artikel beginnen wir erst einmal damit, zu klären, was Pointer eigentlich sind.

Pointer sind nichts anderes als Variablen, in denen man keine Zahlenwerte, sondern Speicheradressen abspeichert. Man kann also beispielsweise eine Speicheradresse einer Integervariablen in einem Pointer abspeichern.

Der Name Pointer (engl. Zeiger) ist passend gewählt, weil ein Pointer auf eine Adresse zeigt.

Ein Pointer zeigt auf eine Adresse und wird daher häufig auch als Referenz bezeichnet

Man nennt dieses „Zeigen auf eine Adresse“ daher auch Referenzieren.

Wenn man einen Pointer gegeben hat und den Inhalt der Speicheradresse, auf die der Pointer zeigt nennt man das Dereferenzieren.

Das Video zum Pointer

Im folgenden Video zeige ich zunächst an einem konkreten Beispiel, wie man sich das Zeigen eines Pointers auf eine Speicherstelle vorstellen kann. Wie also das Referenzieren und Dereferenzieren im Speicher aussieht.

Anschließend zeige ich, wie die Syntax zu Pointern aussieht.

Man kann sich diese Syntax eigentlich sehr leicht merken.

& bedeutet Adresse von

* Bedeutet Inhalt von

Abschließend zeige ich die einfache Verwendung von Pointern in der Entwicklungsumgebung.

Deine Aufgabe

Du solltest jetzt die Verwendung von Pointer selbst üben.

Programmier dazu zunächst einmal selbst das Beispiel aus dem Video

Stell Dir eigene Aufgaben, z.B.

1. Definiere zwei Integer-Variablen i und j und weise den Variablen Werte zu.
2. Definiere zwei Pointer auf Integerervariable und lasse diese Pointer auf die Variablen zeige.
3. Addiere die Werte der Variablen, indem Du NICHT die Variablen verwendest, sondern über die Pointer gehst und gebe die Summe mit printf aus.

Im nächsten Video zeige ich dann eine mögliche Lösung.

Dieser Artikel ist Teil des Mikrocontroller-Kurses auf ET-Tutorials.de.
[ >> Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .]

Der Beitrag Pointer in C erschien zuerst auf ET-Tutorials.de.

Die Aufgabe für heute bestand darin, die Anzeige für den Kaffeeautomaten so zu programmieren, dass zunächst ein „x“, dann „xx“, … auf der Anzeige erscheint.

Als Befehl sollte printf(“x“); verwendet werden.

Die Lösung sollte als NICHT so aussehen:

printf(„x\n)“;

printf(„xx\n)“;

printf(„xxxx\n)“;

printf(„xxxxx\n)“;

…

sondern mit for-Schleifen programmiert werden.

Spätestens bei 1.000 Ausgaben erkennt man den Vorteil ;-).

Eine mögliche Lösung dazu findest Du im heutigen Video.

Dieser Artikel ist Teil des Mikrocontroller-Kurses auf ET-Tutorials.de.
[ >> Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .]

Der Beitrag Geschachtelte for-Schleife erschien zuerst auf ET-Tutorials.de.

Neben der while-Schleife und der im letzten Artikel beschriebenen do while Schleife gibt es noch eine weitere Möglichkeit, Schleifen zu programmieren.

Hierbei handelt es sich um die for- Schleife.

Die for-Schleife wird sehr häufig verwendet.

Die Syntax für die for-Schleife sieht folgendermaßen aus:

for (Initialisierung;Bedingung;Schrittweite)

{

// Schleifenkörper

}

Wie die for-Schleife funktioniert sieht man am besten an einem Beispiel. Eine Erklärung findet Du im heutigen kurzen Video.

Deine Aufgabe

Wie in der letzten Folge versprochen, gibt es endlich auch mal wieder eine Aufgabe zum üben.

Es geht natürlich wieder um eine Erweiterung für unseren Kaffeeautomaten.

Mit Hilfe von for-Schleifen soll die Fortschrittsanzeige während des Brühvorgangs ergänzt werden.

Statt wie in den vergangenen Artikeln eine Anzeige mit Hilfe von LEDs zu realisieren, soll die Fortschrittsanzeige nun über die serielle Schnittstelle ausgegeben werden.

Zunächst soll ein „x“ ausgegeben werden. Nach einer Wartezeit soll in der nächsten Zeile „xx“ ausgegeben werden, usw.

Dies soll weitergeführt werden bis 12 Zeilen ausgegeben worden sind.

In jeder Zeile soll ein „x“ mehr ausgegeben werden als in der vorherigen, so dass die Ausgabe folgendermaßen aus sieht.

x
xx
xxx
xxxx
xxxxx
xxxxxx
xxxxxxx
xxxxxxxx
xxxxxxxxx
xxxxxxxxxx
xxxxxxxxxxx
xxxxxxxxxxxx

Natürlich soll dies nicht einfach mit 12 printf()s gemacht werden, sondern mit der Verwendung von for-Schleifen.  Als Ausgabebefehl soll jeweils nur ein Zeichen mit

printf(„x“);

ausgegeben werden.

Die Aufgabe läßt sich gut mit zwei geschachteln for-Schleifen lösen.

Dir fällt schon etwas ein ;-).

Eine mögliche Lösung gibt es dann in der nächsten Woche …

Dieser Artikel ist Teil des Mikrocontroller-Kurses auf ET-Tutorials.de.
[ >> Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .]

Der Beitrag Schleifen mit for erschien zuerst auf ET-Tutorials.de.

Hierzu wurde ein Schleifenkörper einfach 50.000 Mal durchlaufen und so die erwünschte Verzögerungszeit einfach durch Warten verbracht.

Es gibt noch weitere Möglichkeiten Schleifen zu programmieren.

Eine Möglichkeit ist die sogenannte do-while Schleife. Diese Möglichkeit möchte ich im heutigen Artikel vorstellen.

Der Aufbau der Schleifentypen ist sehr ähnlich. Eine Gegenüberstellung von while und do while macht den Unterschied deutlich.

while (Bedingung)
{
Schleifenkörper
}

do
{
Schleifenkörper
}
while (Bedingung);

Bei der while Schleife wird zuerst die Bedingung überprüft. Nur wenn die  Bedingung erfüllt ist, wird der Schleifenkörper durchlaufen und anschließend die Bedingung erneut überprüft.

Der Schleifenkörper wird also durchlaufen solange die Bedingung erfüllt ist.

Bei der do while Schleife wird zuerst der Schleifenkörper durchlaufen. Anschließend wird erst die Bedingung überprüft und entschieden, ob der Schleifenkörper noch einmal durchlaufen werden soll.

Bei do while wird der Schleifenkörper also mindestens ein Mal durchlaufen und erst NACH dem ersten Durchlauf die Bedingung überprüft!

Wichtig bei do while ist das ; am Ende der Zeile „while (Bedingung)“.

Das Video zu do while

Im Video baue ich abwechselnd while und do while in das Programm ein und erläutere die Gemeinsamkeiten und den Unterschied der beiden Konstrukte.

Wie geht's weiter

Beim nächsten Mal geht es um eine sehr beliebte und sehr häufig verwendete Möglichkeit, Schleifen zu programmieren.

Es geht dann um die for-Schleife, die vom Aufbau etwas komplizierter ist, aber dafür viele Möglichkeiten bietet. Anschließend wird es dann auch wieder Aufgaben zur Schleifenprogrammierung geben, damit Du auch wieder an's Programmieren kommst.

Dieser Artikel ist Teil des Mikrocontroller-Kurses auf ET-Tutorials.de.
[ >> Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .]

Der Beitrag Schleifen mit do while erschien zuerst auf ET-Tutorials.de.

Apropos Warten. Im heutigen Artikel geht es genau darum, um’s Warten.

Die Programmierung des Kaffeeautomaten soll erweitert werden. Und zwar soll während des Brühvorgangs ein Lauflicht angezeigt werden, das neben den Brühgeräuschen auch visuell den Brühvorgang anzeigt. Das Auge isst mit

Programmierung des Lauflichts

Hierzu soll ein Lauflicht programmiert werden. An einem Port werden hierzu LEDs angeracht, die nun nacheinander zugeschaltet werden sollen.

Zunächst soll also die erste LED leuchten, dann die ersten beiden, die ersten drei usw.

Wenn alle acht LEDs leuchten, beginnt der Vorgang wieder von vorn.

Warten mit der while-Schleife

Nach der Programmierung des Lauflichts fällt auf, dass das Lauflicht viel zu schnell läuft.

Wenn man die Hardware aufbauen würde, sähe man nur 8 leuchtende LEDs, deren Helligkeit von der ersten bis zur achten LED zunimmt. Ein Lauflicht wäre das aber nicht.

Also: Die Laufgeschwindigkeit muss verringert werden.

Hierfür wird im Video eine Funktion wait() erstellt, die nichts anderes macht als zu warten.
Wir werden später noch bessere Möglichkeiten kennenlernen, so etwas zu realisieren (Timer), zur Zeit bietet sich diese Aufgabenstellung aber gut an, um Schleifen in allen möglichen Formen und Farben kennenzulernen.

Ich beginne in dieser Folge mit der while() – Schleife, die Du ja als Endlosschleife in main() schon kennst.

Hier soll es aber nicht um eine Endlosschleife gehen, sondern eine Schleife mit einer definierten Abbruchbedingung. Nach einer bestimmten Zeit soll die Funktion ja wieder verlassen werden.

Das Video zur while-Schleife

Das heutige Video ist wieder etwas länger geworden. Glücklicherweise hat Youtube die 10-Minutenbegrenzung aufgehoben, so dass ich das Video nicht aufteilen musste.

In den nächsten Folgen werde ich noch weitere Möglichkeiten der Schleifenprogrammierung zeigen.

Bis dahin

Dieser Artikel ist Teil des Mikrocontroller-Kurses auf ET-Tutorials.de.
[ >> Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .]

Der Beitrag Schleifen mit while() erschien zuerst auf ET-Tutorials.de.

Dies möchte ich in dieser Folge nun nachholen.

In der Funktion Eingabe() steht uns lediglich die Schachtnummer, in der eine Münze eingeworfen wurde, zu Verfügung. Mit Hilfe dieser Schachtnummer muss nun das entsprechende Portbit – und zwar nur dieses Portbit ! – zurückgesetzt werden.

Bitweises Löschen des Portbits

In der Folge über die Bitweise Manipulation also das Bitweise Setzen und Löschen des Ports habe ich ja bereits den Mechanismus vorgestellt, wie man mit dem Operator & einzelne Bits zurücksetzen kann.

Die Maske hierfür müssen wir uns mit der Information über die Schachtnummer nun selbst zusammenbauen.

Der SHIFT-Operator

Wie bereits in der letzten Folge vorbereitet, kann man dies mit dem SHIFT-Operator << prima machen. In dem heutigen Video zeige ich, wie man das gewünschte Bitmuster zusammenstellen kann.

Hierzu kann man einfach eine 1 (binär gedacht als 00000001) soweit wie gewünscht nach links schieben. Man erhält 1 Byte mit 0, bei dem nur an der gewünschten Stelle eine 1 steht. Zieht man diesen Wert anschließend von einer 0xFF (binär gedacht 11111111) ab, erhält man die gewünschte Maske, z.B. 11111101.

Mit Hilfe dieser Maske kann man dann, wie in der Folge zur Bitweise Manipulation,  also das Bitweise Setzen und Löschen des Ports, gezeigt, das gewünschte Portbit zurückzusetzen. Alle anderen Portbits werden nicht verändert.

Noch einfacher durch das Bitweise Invertieren

Am Ende des Videos zeige ich noch, wie man die Maske noch eleganter zusammenstellen kann. Durch das Bitweise Invertieren der „geschifteten 1“ lässt sich die Maske sehr einfach erstellen.

Die Details im folgenden Video:

Dieser Artikel ist Teil des Mikrocontroller-Kurses auf ET-Tutorials.de.
[ >> Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .]

Der Beitrag Array-Lösung mit Löschen des Bits erschien zuerst auf ET-Tutorials.de.

Mit einem Array kann man eine Struktur von Daten gleichen Typs sehr geschickt speichern.

Auf die einzelnen Feld des Arrays kann dann sehr elegant über den geeigneten Index zugegriffen werden.

Deine Aufgabe aus der letzten Woche war es, ein Array zu nutzen, um nur einen Parameter an die Funktion Eingabe zu übergeben.

In dem Array

int Schacht[8]

sind die 8 möglichen Zahlenwerte einer europäischen Münze gespeichert. Da sich diese Information nicht ändert, muss sie nicht bei jedem Funktionsaufruf übergeben zu werden.

Das heutige Video ist in 2 Teile unterteilt.

Im ersten Teil zeige ich eine mögliche Lösung für das Auslesen des Münzwertes aus dem Array.

Im zweiten Teil des Videos geht es dann um das zurücksetzen des Portbits. Anhand der Information, in welchem Schacht eine Münze erkannt worden ist, kann ein Bitmuster errechnet werden, mit dessen Hilfe das entsprechende Portbit zurückgesetzt werden kann.

Die Lösung der Aufgabe

Im heutigen Video geht es also zunächst um eine mögliche Lösung der Aufgabe von letzter Woche.

Aus der Information, an welcher Stelle eine Münze erkannt worden ist, wird der Münzwert aus dem Array gelesen und dann zum aktuellen Betrag addiert. Damit es nicht ganz so einfach ist, habe ich alles in einer Zeile programmiert.

Der SHIFT-Operator

Nach der Addition des Münzwertes zum Gesamtbetrag muss noch das jeweilige Port-Bit zurückgesetzt werden. Wie im Video gezeigt, kann mit dem SHIFT-Operator ein Bit nach links oder rechts verschoben werden.

Deine Aufgabe für die nächste Woche ist es, den SHIFT Operator zu nutzen, um das korrekte Bit wieder auf 0 zu setzen. Wenn Du Dich nicht mehr so genau daran erinnerst, wie man einzelne Bits löscht, kann Dir der Artikel über das Setzen und Löschen von Bits innerhalb eines Bytes sicher helfen.

Dieser Artikel ist Teil des Mikrocontroller-Kurses auf ET-Tutorials.de.
[ >> Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .]

Der Beitrag Lösung der Aufgabe und SHIFT Operator erschien zuerst auf ET-Tutorials.de.

Bei der Aufgabenstellung zur Auslagerung von Code in Funktionen habe ich ja schon angedeutet, dass man nicht unbedingt die Münzschachtnummer UND den Wert der Münze bei jedem Funktionsaufruf übergeben muss.

Wenn man weiß in welchen Münzschacht eine Münze liegt, kennt man ja auch den Wert der Münze.

Bei der ersten Lösung haben wir der Einfachheit beide Informationen an die Funktion Eingabe() übergeben und dort ausgewertet.

Im folgenden soll es darum gehen, nur die Nummer des Münzschachts zu übergeben und dann aus dieser Information, den Wert der Münze zu ermitteln.

Array

Dies lässt sich einfach über sogenannte Arrays realisieren.

In einem Array lassen sich Daten gleichen Typs in einem Feld anordnen.

Die einzelnen Daten lassen sich dann über einen fortlaufenden Index ansprechen.

Also genau das, was wir brauchen.

Beim Kaffeeautomaten lassen sich die einzelnen Münzschächte durchnummerieren. Die Zuordnung Schacht-Nummer und Münzwert lässt sich dann über ein Array realisieren.

Im Video zeige ich die

• Definition des Arrays
• die Möglichkeiten der Initialisierung
• und das Auslesen des Arrays

Nun bist Du wieder an der Reihe

Das Array soll nun verwendet werden, um die Parameterübergabe an die Funktion Eingabe zu erleichtern. Es soll in folgenden nur noch der Index des Schachtes [0 … 7] übergeben werden.

In der Funktion Eingabe() soll dann der korrekte Münzwert über das Array ermittelt werden und der Gesamtbetrag entsprechend erhöht werden.

Das Zurücksetzen des Ports ist nun etwas schwieriger, weil wir die Schachtnummer als Index von 0 bis 7 und nicht mehr als binärcodiertes Portbit zur Verfügung haben.

Kümmere Dich also noch nicht um das Zurücksetzen des Ports. Dies wird Inhalt des nächsten Artikels sein.

Dieser Artikel ist Teil des Mikrocontroller-Kurses auf ET-Tutorials.de.
[ >> Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .]

Der Beitrag Arrays erschien zuerst auf ET-Tutorials.de.

Mein Vorschlag ist daher nur eine mögliche Lösung. Es gibt sicher elegantere Lösung. Vor allem der Umgang mit der Variablen Betrag lässt sich sicher noch optimieren :-). Nähere Information gibt es dazu Video.

Die Anforderungen an die Funktion Eingabe()

In der Funktion Eingabe sollen zwei Dinge umgesetzt werden.

1. Die Erhöhung des Gesamtbetrages um den Wert der eingeworfenen Münze und die Ausgabe des Gesamtbetrages.
2. Das Zurücksetzen des entsprechenden Portbits, damit die Münze beim nächsten Durchlauf nicht noch einmal gezählt wird.

Um die Funktion Eingabe() zu realiseren, musst Du verschiedene Dinge, die Du in den vergangenen Folgen gelernt hast umsetzen.

Zur Verwendung von Funktionen kannst Du Dir evtl, noch einmal die Videos ab Artikel 22 Funktionen in C angucken.

Auch die Videos zur Variablenzuweisung, zur if-Abfrage und zur Bitweisen Manipulation können vielleicht helfen.

Während der erste Teil, Die Erhöhung des Gesamtbetrages um den Wert der eingeworfenen Münze und die Ausgabe des Gesamtbetrages, noch verhältnismäßig einfach ist, geht es bei dem 2. Teil der Aufgabe schon ziemlich zur Sache.

Wie häufig bei Funktionen, bei denen die Ausführung abhängig von Parametern ist, ist es auch in diesem Beispiel so, dass Du bei der Programmierung der Funktion noch nicht weißt, welche Parameter übergeben werden. Du musst also die Funktion so flexibel gestalten, dass aus den übergebenen Parametern die durchzuführenden Befehle errechnet werden können.

Eine mögliche Lösung findest Du im Video.

Bis zum nächsten Mal.

Dieser Artikel ist Teil des Mikrocontroller-Kurses auf ET-Tutorials.de.
[ >> Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .]

Der Beitrag Lösung für eine Funktion zur Münzeingabe erschien zuerst auf ET-Tutorials.de.

Zur Erinnerung:

Der Kaffeeautomat hatte eine Münzeingabe, die alle europäischen Geldstücke vom 1 Ct Stück bis zum 2 € annimmt.

Dass dies zufällig 8 verschiedene Münzen sind, freut uns natürlich. So können wir die einzelnen Münzschächte über die Bits genau eines Bytes abfragen.

Eine mögliche Programmierung der Münzeingabe haben wir ja bereits besprochen und haben anschließend noch das Programm optimiert, so dass auch mehrere Münzen gleichzeitig bzw. schnell hintereinander eingeworfen werden können.

Das war durch das Bitweise Auslesen der Information möglich.

Schlanker Code

Das Programm funktionierte bis dahin so weit auch ganz gut. Es fällt jedoch auf, dass der Code zur Identifikation der einzelnen Münzen fast gleich ist.

Das Programm besteht daher aus sehr ähnlichen Programmteilen.

Eine ideale Voraussetzung, um diese Programmteile in eine Funktion zu integrieren und dann jeweils nur diese Funktion aufzurufen.

Im folgenden Video zeige am C-Programm, was ich damit meine.

Jetzt geht’s zur Sache

Und hier kommt Deine Aufgabe zur nächsten Woche.

Versuche die Funktion Eingabe() zu realisieren, so dass sie so flexibel ist, um mit den unterschiedlichen Münzen zurecht zu kommen. Es soll also in der Funktion Eingabe der korrekte Wert zum Betrag addiert und anschließend das zughörige Bit des Ports P1 zurückgesetzt werden.

Guck Dir zur Lösung der Aufgabe am besten noch einmal die älteren Videos zum Kaffeeautomaten und die Videos zur Verwendung von Funktionen (ab Video 22 Funktionen in C an.

Auch die Videos zur Variablenzuweisung, zur if-Abfrage und zur Bitweisen Manipulation können vielleicht helfen.

In der nächsten Folge werde ich eine mögliche Lösung vorstellen. Ich empfehle aber nicht bis dahin zu warten, sondern auf jeden Fall selbst eine Lösung zu versuchen. Durch diese Aufgabe wird vieles aus den vergangenen Artikeln wiederholt und zusammengefasst. Das ist für Dich eine ideale Möglichkeit um zu überprüfen, ob Du bis hierhin wirklich alles verstanden hast.

Dieser Artikel ist Teil des Mikrocontroller-Kurses auf ET-Tutorials.de.
[ >> Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .]

Der Beitrag Kaffeeautomat-Funktion für die Münzauswertung erschien zuerst auf ET-Tutorials.de.

Zum Abschluss gab es dann im Artikel der letzten Woche eine Aufgabe. Und zwar ging es darum, mit Hilfe von Funktionen den Umfang und die Fläche eines Kreises zu berechnen.

Als drittes sollte dann anschließend noch das Volumen eines Zylinders berechnet werden, wobei bei der zu programmierenden Funktion volumen() auf die Funktion flaeche() zurückgegriffen werden sollte.

Die Berechnung der Grundfläche des Zylinders sollte also nicht in der Funktion volumen() selbst, sondern sozusagen an die Funktion flaeche delegiert werden. Also ein Aufruf einer Funktion innerhalb einer Funktion.

Um weiterhin mit Integer-Werten rechnen zu können, hatte ich für PI=3 vorgegeben – was ja zu 95% auch so stimmt

Im ersten Video zeige ich Dir heute eine mögliche Lösung der Aufgabe.

Da das Video zu lang geworden wäre, habe ich das Video heute wieder geteilt. Im zweiten Teil werde ich das Programm zunächst einmal testen und dann den Quell-Code noch etwas nachbessern.

Auf viele Variablendefinitionen des ersten Videos kann man nämlich verzichten und somit das Programm kürzen und die Nutzung des Speicherplatzes optimieren. Gerade wenn man mit dem Programmieren beginnt, ist es häufig einfach den Code ein bisschen ausführlicher als nötig zu schreiben und dann im zweiten Schritt das Programm zu kürzen.

Später, wenn man etwas mehr Erfahrung in der C-Programmierung hat, fasst man automatisch an bestimmten Stellen mehrere Befehle zusammen. Aber auch dann sollte es m.E. nicht übertreiben. Man möchte ein C-Programm ja auch ein Jahr später noch verstehen können. Zu sehr komprimierter C-Code ist aber häufig schwer zu lesen.

So, dass war zunächst einmal eine Einführung in den Bereich Funktionen. In der nächsten Folge werde ich mich wieder unserem Kaffeeautomaten zuwenden und überprüfen, an welchen Stellen wir durch den Gebrauch von Funktionen unser Programm für den Kaffeeautomaten verbessern können.

Dieser Artikel ist Teil des Mikrocontroller-Kurses auf ET-Tutorials.de.

[ >> Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .]

Der Beitrag Lösung der Übungsaufgabe zu Funktionen erschien zuerst auf ET-Tutorials.de.

Dieses Wissen hilft nun, beim Aufruf von Funktionen. Vor allem wenn es darum geht, den aufzurufenden Funktionen Parameter zu übergeben.

Da das heutige Video etwas lang geworden wäre, habe ich es in 2 Teile aufgeteilt.

Im ersten Video zeige ich den prinzipiellen Funktionsaufruf und die Parameterübergabe sozusagen als Trockenübung.

Im zweiten Video werde ich dann wieder die Entwicklungsumgebung an und zeige den Funktionsaufruf am System.

Alles geht über den Stack

Wenn es sich vermeiden lässt, globale Variablen für die Kommunikation zwischen unterschiedlichen Funktionen zu nehmen, nutzt man lokale Variablen. Da lokale Variablen eine begrenzte Sichtbarkeit und eine begrenzte Gültigkeitsdauer haben, können Programme so besser strukturiert werden.

Die Variablen für die Parameterübergabe von Funktion zu Funktion werden also über den Stack übergeben.

Im zweiten Video zeige ich die Implementierung des Funktionsaufrufes in der Entwicklungsumgebung und, am Ende des Videos, die Deklarationen von Funktionen, wenn Parameter mit übergeben werden sollen.

Nun bist Du wieder an der Reihe …

Heute gibt es wieder – endlich – eine Hausaufgabe.

Die heutige Hausaufgabe besteht aus drei Funktionen. Und zwar sollen zum einen für einen Kreis der Umfang und der Flächeninhalt berechnet werden. Zudem soll für einen Zylinder das Volumen berechnet werden.

Radius und Höhe sollen über den PORT 1 (Radius) und PORT 2(Höhe) eingegeben werden können. Der Einfachheit halber soll alles in der Grundeinheit m angegeben werden.

Die Besonderheit bei der Berechnung des Volumens für den Zylinder besteht darin, dass zur Berechnung der Grundfläche des Zylinders die vorher definierte Funktion genutzt werden soll.

Also:

Programmiere die Funktionen

• int umfang (int radius)

• int flaeche (int radius)

• int volumen(int radius, int hoehe)

wobei in der Funktion volumen() die Funktion flaeche() genutzt werden soll.

Zu Beginn von main() sollen radius und hoehe über die Ports P1 und P2 eingelesen werden.

Am Ende von main sollen Umfang, Fläche und Volumen ausgegeben werden.

Hinweis:
Für unsere Übung reichen grobe Werte. Wir nehmen für PI = 3

Und zur Erinnerung ein paar Formeln:

• U=2*PI*radius

• A=Pi*radius²

• V=A*hoehe

Bis zum nächsten Mal!

Dieser Artikel ist Teil des Mikrocontroller-Kurses auf ET-Tutorials.de.
[ >> Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .]

Der Beitrag Funktionen in C, Parameterübergabe erschien zuerst auf ET-Tutorials.de.

In einem der vergangenen Artikel habe ich ja schon gezeigt, welche Variablen es in der Programmiersprache C gibt.

Beim Umgang mit Variablen und Funktionen stellt sich häufig die Frage, auf welche Variablen kann eine Funktion zugreifen, mit welchen Variablen kann eine Funktion arbeiten.

Wozu Gültigkeitsbereiche

Häufig möchte man gar nicht, dass jede Variable von jeder Funktion änderbar ist. Stell Dir vor mehrere Programmierer arbeiten an einem Projekt und müssten sich einigen, wer denn seine Inter-Variable „i“ nennen darf.

Oder noch schlimmer: Man nutzt Funktionen aus einem anderen Projekt und müsste bevor man selbst programmiert, alle Programme durchforsten ob die Variable „Wert“ schon einmal genutzt worden ist.

Um dies zu verhindern unterscheidet man zwischen globalen Variablen, die global, also im gesamten Programm gelten und lokalen Variablen, die einen beschränkten Gültigkeitsbereich haben.

Speicherorte von Variablen

Welche Variablen global sind und welche lokal sind, versteht man am besten, wenn man sich einmal anguckt, in welche Speicherbereiche die Variablen vom Compiler/Linker bzw. vom Mikrocontroller abgelegt werden.

Globale Variablen kann der Compiler bei der Erstellung des Programms in den Datenbereich ablegen. Bei lokalen Variablen ist bei der Übersetzung des Programms nicht bekannt, wie häufig (oder ob überhaupt) diese Variablen benötigt werden.

Im folgenden Video zeige ich daher zunächst, wie der Compiler bzw. während der Ausführung der Mikrocontroller Variablen behandelt.

Nachdem Du nun gesehen hast, wo Compiler und Mikrocontroller die Variablen verwalten, möchte ich im nächsten Video einige Beispiele zeigen.

Am besten ist nun, Du rufst auf Deinem PC die Entwicklungsumgebung auf und testet selbst einmal die Gültigkeitsbereiche von Variablen.

Dieser Artikel ist Teil des Mikrocontroller-Kurses auf ET-Tutorials.de.
[ >> Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .]

Der Beitrag Funktionen in C, Globale und lokale Variablen erschien zuerst auf ET-Tutorials.de.

Nachdem ich also in der letzten Folge schon einmal kurz die prinzipielle Verwendung von Funktion angesprochen habe, möchte ich mit der heutigen Folge beginnen, etwas tiefer in das Thema Funktionen in C einzusteigen.

Definition und Deklaration

Konkret soll es heute um das Thema Definition und Deklarationen von Funktionen in C gehen. Um die Verwendung von Funktionen zu verstehen ist es hilfreich ein wenig über die Arbeitsweise eines Compilers zu verstehen.

Das prinzipielle Vorgehen beim Übersetzen eines Programms hatte ich zu Beginn des Kurs schon vorgestellt. Wenn Du Dich nicht mehr genau erinnerst, könnte diese Folge interessant sein, ich der ich die Zusammenarbeit von Compiler und Linker kurz zeige.

Im heutigen Video zeige ich zunächst noch einmal, wie Funktionen sich gegenseitig aufrufen können und demonstriere dann mit dem Emulator, die Probleme bei der Definition von Funktionen und die Lösung mit Hilfe der Deklaration von Funktionen.

Hier zunächst das heutige Video.

Die Ursprungsquelldatei:

/*——————————————————————————
 HELLO.C

 Copyright 1995-2005 Keil Software, Inc.
 ——————————————————————————*/

 #include <REG52.H>               
  #include <stdio.h>               
 /*————————————————
 The main C function.  Program execution starts
 here after stack initialization.
 ————————————————*/

void funk1(void); // Deklaration von funk1
void funk2(void); // Deklaration von funk2

void main (void) {

 /*————————————————
 Setup the serial port for 1200 baud at 16MHz.
 ————————————————*/
 #ifndef MONITOR51
 SCON  = 0x50;              
 TMOD |= 0x20;              
 TH1   = 221;               
 TR1   = 1;                                           
 TI    = 1;                 
 #endif

 /*————————————————
 Note that an embedded program never exits (because
 there is no operating system to return to).  It
 must loop and execute forever.
 ————————————————*/

printf("In main()\n");

while(1)
{

}

}    //end main

Zusammengefasst

In der Definition einer Funktion wird genau festgelegt, wie eine Funktion aufgebaut ist, welche Parameter sie übergeben bekommt und welchen Wert sie an die aufrufende Funktion zurückgibt.

Eine Deklaration gibt dem Compiler Informationen darüber, dass eine bestimmte Funktion existiert und welche Parameter sie erwartet und welchen Wert sie zurückgibt. Die Deklaration einer Funktion hilft dem Compiler beim weiteren Übersetzen des Programms.

Häufig werden Deklarationen von Funktionen in sogenannten Header-Dateien ausgelagert und dann im Quellcode über den #include-Befehl eingebettet. Dies erhöht bei größeren Programmen die Übersichtlichkeit.

Dieser Artikel ist Teil des Mikrocontroller-Kurses auf ET-Tutorials.de.
[ >> Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .]

Der Beitrag Funktionen in C, Definition und Deklaration erschien zuerst auf ET-Tutorials.de.

Für unseren Kaffeeautomaten wird beispielsweise bei der Auswertung des Geldeinwurfs jedes Mal zunächst überprüft, ob der Restbetrag noch ausreicht, eine passende Meldung ausgegeben, ggf. das Getränk ausgegeben und der Betrag entsprechend belastet.

Den Code für diese Befehlfolge muss man, wenn man eine Funktion hierfür schreibt, nur einmal programmieren (und im Speicher des Mikrocontrollers ablegen) und diese Funktion dann bei der Wahl eines Getränks aufrufen.

Wir habe in unserem Beispiel zwar nur 3 Getränke zur Auswahl um die Anwendung übersichtlich zu halten.

Welche Einsparung man bei 20 Getränken erhielte kann man sich aber leicht vorstellen.

2 Vorteile von Funktionen

1. Das Programm wird durch Funktionen strukturierter.
   Wenn zur Verwendung einer Befehlsfolge eine Funktion genutzt wird und die Befehlfolge dann anschließend doch noch geändert werden soll, dann muss man diese Änderung nur einmal vornehmen – eben in dieser Funktion.
2. Das Programm wird kleiner.
   Mikrocontroller-Steuerungen sind häufig mit relativ wenig Speicher ausgestattet. Diesen Speicher muss man effektiv nutzen. Auch unser Emulator hat eine Beschränkung des Speichers, und zwar auf 2K Programmspeicher. Mit unseren derzeitigen Programmen stoßen wir schon knapp an diese Grenze.

Was sind Funktionen

Eine Funktionen, die wir schon kennen, ist die Funktion main(), die direkt zu Beginn vom Mikrocontroller aufgerufen wird.

Weiter Funktionen können definiert und dann innerhalb von main() aufgerufen werden.

In dem Video zeige ich, wie man Funktionen definiert, sie dann aufruft und wie man Parameter übergibt und Rückgabewerte zurückgibt und auswertet.

Das Video

Schau Dir zunächst einmal das Video an. Hier geht es zunächst einmal um eine grobe Einordnung des Themas Funktionen.

Jetzt bist Du wieder an der Reihe.

Die „Hausaufgabe“ ist dieses Mal etwas lose definiert.

Versuche einmal mit diesen Funktionen etwas herum zu experimentieren. Bau also zunächst einmal das Beispiel nach.

Vielleicht fallen Dir ähnliche Aufgabenstellungen ein, die Du mit Funktionen realisieren kannst. An der einen oder anderen Stelle wirst Du wahrscheinlich auf Probleme stoßen, die wir hier noch nicht behandelt haben.

Das stört jedoch nicht – im Gegenteil. Das könnte Dir helfen beim Verständnis helfen, wenn es in den nächsten Folgen um die Feinheiten beim Gebrauch von Funktionen geht.

Dieser Artikel ist Teil des Mikrocontroller-Kurses auf ET-Tutorials.de.
[ >> Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .]

Der Beitrag Funktionen in C erschien zuerst auf ET-Tutorials.de.

Deine Aufgabe zu heute war es nun, das Programm so zu erweitern, dass nun alle Münzen erkannt werden.

Die Aufgabe mag für Dich vielleicht trivial erscheinen, wenn Du das Beispiel in der letzen Folge verstanden hast.

Das bitweise Setzen und Löschen eines Bits ist später für das Konfigurieren des Mikrocontrollers, beim Setzen und Löschen der sogenannten Special Function Register (SFR), so wichtig, dass das Prinzip wirklich sitzen sollte.

Hier zunächst einmal das Video.

In der nächsten Woche geht es darum, das Programm besser zu strukturieren, und zwar mit Funktionen. Dazu werde ich in der nächsten Folge in einer Einführung zeigen, was Funktionen eigentlich sind und wozu wir sie benötigen.

Dieser Artikel ist Teil des Mikrocontroller-Kurses auf ET-Tutorials.de.
[ >> Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .]

Der Beitrag Programmierung der Münzeingabe erschien zuerst auf ET-Tutorials.de.

Durch dieses einzelne Auswertung ist es möglich, auch quasi gleichzeitig eingeworfene Geldstücke zu erkennen.

Wichtig bei der einzelnen Auswertung der Geldstücke ist es, nach dem Auslesen eines Bits nur dieses eine Bit wieder zurückzusetzen, da sonst die Informationen über die anderen eingeworfenen Geldstücke verloren gehen.

Hier zunächst das Video:

In diesem Video habe ich eine mögliche Lösung zum Auslesen der ersten Bits gezeigt.

Deine Hausaufgabe zur nächsten Folge ist es, falls Du es nicht sowieso schon geschafft hast, das Programm für die restlichen Bits so zu erweitern, dass auch die anderen möglichen Geldstücke biweise ausgelesen werden können.

Dieser Artikel ist Teil des Mikrocontroller-Kurses auf ET-Tutorials.de.
[ >> Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .]

Der Beitrag Bitweises Auslesen eines PORTs erschien zuerst auf ET-Tutorials.de.

Daher möchte ich heute auf eine Problemstellung eingehen, die Tim in seinem Kommentar angesprochen hat:

• Was passiert eigentlich, wenn jemand 2 oder mehr Münzen gleichzeitig einwirft?

• Wie können wir unsere Software dahingehend verbessern, damit die Software auch damit umgehen kann?

Tim hat recht: Wenn jemand zwei Geldmünzen gleichzeitig einwirft, oder so schnell hintereinander, dass der Mikrocontroller aus welchem Grund auch immer, noch beschäftigt ist und die Eingabe einzelnen Münzen nicht schnell genug abarbeiten kann, gibt es ein Problem. Nur die erste Münze wird gewertet, der Werte der anderen eingeworfenen Münzen geht verloren.

Eine Lösung dieses Problems besteht darin, die Bits des Ports einzeln abzufragen.

So kann bestimmt werden, ob eine Münze eingeworfen wurde, unabhängig davon, ob zusätzlich auch noch weitere Münzen eingeworfen wurden.

In dem Video wird mit hexadezimalen Zahlen gerechnet. Wenn Du Dir den Umgang mit Hex-Zahlen und die teilweise kryptische Art der Variablenzuweisung noch einmal vergegenwärtigen möchtest, dann empfehle ich Dir vorab noch diese 4 Artikel

Binäre, dezimale und hexadezimale Zahlen

Bits, Bytes und Nibbles

Variablenzuweisung und modulo-Funktion

Variablenzuweisung (Teil2)

Nun aber zum Video über die bitweise Manipulation.

Nun bist Du wieder an der Reihe.

Deine Aufgabe ist es nun, ein Programm zu schreiben, das auch erkennt, wenn mehrere Münzen eingeworfen wurden.

Es ist hier wahrscheinlich einfacher, if-Abfragen statt switch-case-Abfragen zu nutzen.

Wichtig ist auch, dass Du, wenn Du ein Bit ausgewertet hast, nicht den gesamten Port zurückzusetzen, sondern nur das in Deinem Programm ausgewertete Bit.

Viel Spaß beim Programmieren!

In der nächsten Woche werde ich dann wieder eine mögliche Lösung zeigen.

Dieser Artikel ist Teil des Mikrocontroller-Kurses auf ET-Tutorials.de.
[ >> Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .]

Der Beitrag Bitweise Manipulation erschien zuerst auf ET-Tutorials.de.

Heute soll es nun um die Getränkeausgabe gehen.

Je nach Getränk muss ein anderer Preis berechnet. Dieser Preis wird dann vom Guthaben abgezogen.

Unser Kaffeeautomat bietet 3 Getränke

• Kaffee 30 Ct

• Espresso 40 Ct

• Cappuchino 50 Ct

Die Wahl des Getränks soll über die Buchstaben „k“ für Kaffee, „e“ für Espresso und „c“ für Cappuchino über die Tastatur erfolgen.

Nach der Wahl des Getränks wird das Getränk in der Maschine produziert und der Preis vom Guthaben, das vorher eingezahlt wurde, abgezogen.

Eine möglich Lösung, die ich im heutigen Video zeige, realisiert die Anforderung wieder über eine switch-case Anweisung.

Die Lösung ist noch ziemlich rudimentär und nicht sehr benutzerfreundlich. Prinzipiell funktioniert unser kleines Programm aber schon ganz gut. Wenn Du Lust hast, kannst Du das Programm vielleicht noch an einigen Stellen verbessern.

In der nächsten Folge werden wir eine Frage von Tim aufgreifen. Und zwar benötigen wir eine Möglichkeit, einzelne Bits zu setzen und zu löschen, wenn beispielsweise gleichzeitig eine 10 Ct – und eine 50 Ct- Münze eingeworfen wurde.

Ein wichtiger Hinweis:
Durch die printf()-Ausgabe wird der Programmcode schnell sehr groß. Mein Beispielprogramm kratzt schon knapp an das 2K-Limit.
Hier jusst Du also aufpassen. Wenn Dein Programm größer als 2 kByte werden sollte, wird es nicht auf den kostenfreien Simulator ausgeführt.
Dann solltest Du versuchen, an der einen oder anderen Stelle die printf()-Anweisungen zu kürzen.

Hier noch einmal der C-Code aus dem Video.

c=getchar();
 switch (c)
 {
 case 'k':
 if (Betrag<30)
 {
 printf("Kaffee kostet 30 Cent\n");
 printf("Restbetrag: %d Cent\n", Betrag);
 printf("Bitte werfen Sie (mindestens) %d Cent ein\n",30-Betrag);

 break;
 }
 printf("\nSie haben Kaffee gewählt\n");
 printf("Restbetrag: %d Cent\n", Betrag-=30);
 c=0;
 break;
 case 'e':
 if (Betrag<40)
 {
 printf("Espresso kostet 40 Cent\n");
 printf("Restbetrag: %d Cent\n", Betrag);
 printf("Bitte werfen Sie (mindestens) %d Cent ein\n",40-Betrag);
 break;
 }
 printf("\nSie haben Espresso gewählt\n");
 printf("Restbetrag: %d Cent\n", Betrag-=40);
 c=0;
 break;
 case 'c':
 if (Betrag<50)
 {
 printf("Cappuchino kostet 50 Cent\n");
 printf("Restbetrag: %d Cent\n", Betrag);
 printf("Bitte werfen Sie (mindestens) %d Cent ein\n",50-Betrag);

 break;
 }
 printf("\nSie haben Cappuchino gewählt\n");
 printf("Restbetrag: %d Cent\n", Betrag-=50);
 c=0;
 break;
 }

Dieser Artikel ist Teil des Mikrocontroller-Kurses auf ET-Tutorials.de.
[ >> Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .]

Der Beitrag Programmierung der Getränkeausgabe erschien zuerst auf ET-Tutorials.de.

Wie versprochen möchte ich diese Folge mit einer möglichen Lösung der Programmieraufgabe für die Zähleinrichtung beginnen.

Wie so häufig, gibt es viele Wege, die nach Rom führen.

Meine Lösung ist also nicht die einzige und sehr wahrscheinlich auch nicht die beste und schönste Lösung, die man sich vorstellen kann.

Meine Lösung sieht prinzipiell folgendermaßen aus.

In einer Integer-Variablen „Betrag“ wird der bereits in den Kaffeeautomaten eingeworfene Geldbetrag gespeichert.

Mit jeder neuen Münze wird also die Variable Betrag entsprechend hochgezählt.

Um zu entscheiden, welchen Geldbetrag zur Variablen Betrag addiert werden soll, muss der Münzschacht über P1 ausgelesen werden.

Abhängig davon, welchen Bit in P1 gesetzt ist, also welche Münze eingeworfen wurde, wird der zugehörige Geldbetrag addiert.

Am Ende der switch-case Abfrage wird das Programm mit getchar() angehalten, damit eine neue Münze eingeworfen bzw. ein neues Bit in P1 gesetzt werden kann.

Und nun viel Spaß mit dem Video.

Here we are …

Für den Fall dass Du den Code einmal ausprobieren möchtest, aber nicht alles abtippen willst, kopiere ich das C-Programm einmal hierher:

P1=0;
printf(„Los gehts..“);

while(1){

switch (P1)
{
case 1:
printf(„Betrag: %d Cent“, Betrag+=1);
P1=0;
break;

case 2:
printf(„Betrag: %d Cent“, Betrag+=2);
P1=0;
break;

case 4:
printf(„Betrag: %d Cent“, Betrag+=5);
P1=0;
break;

case 8:
printf(„Betrag: %d Cent“, Betrag+=10);
P1=0;
break;

case 16:
printf(„Betrag: %d Cent“, Betrag+=20);
P1=0;
break;

case 32:
printf(„Betrag: %d Cent“, Betrag+=50);
P1=0;
break;

case 64:
printf(„Betrag: %d Cent“, Betrag+=100);
P1=0;
break;

case 128:
printf(„Betrag: %d Cent“, Betrag+=200);
P1=0;
break;

}
printf(„\n“);
getchar();  // damit das Programm hier wartet

Dies soll nur eine mögliche Lösung sein. Es gibt sicher noch elegantere Lösungen, die beispielsweise ohne das getchar() auskommen, damit dieses lästige Wechseln des Eingabefensters wegfällt.

So könnte man z.B. eine Warteschleife

while(P1==0);

einbauen und somit darauf warten, ob überhaupt eine Münze eingeworfen wurde.

Kaffeeausgabe

Im zweiten Teil der Aufgabe soll natürlich auch die Kaffeeausgabe überwacht werden.

Unser Kaffeeautomat bietet 3 Getränke

• Kaffee 30 Ct

• Espresso 40 Ct

• Cappuchino 50 Ct

Die Wahl des Getränks soll über die Buchstaben “k” für Kaffee, “e” für Espresso und “c” für Cappuchino über die Tastatur erfolgen.

Bei Wahl des entsprechenden Getränks muss der Betrag natürlich wieder vom Guthaben abgezogen werden.

Ergänze also Dein Programm um diese Funktionalität.

Bis zum nächsten Mal!

Dieser Artikel ist Teil des Mikrocontroller-Kurses auf ET-Tutorials.de.
[ >> Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .]

Der Beitrag Programmierung eines Kaffeeautomaten – Teil 2 erschien zuerst auf ET-Tutorials.de.

In den vergangenen Folgen haben wir uns um die absoluten Grundlagen der Programmiersprache „C“ gekümmert und uns an das Arbeiten mit Compiler, Linker und Emulator gewöhnt.

Programmieren lernt man aber nur durch Programmieren.

Es ist also höchste Zeit für ein kleines Projekt, um das bisher Erlernte zu üben, die Themen zu vertiefen und auch neue Dinge an einem konkreten Beispiel kennenzulernen.

Die Anwendung der Programmierung an einem konkreten Projekt macht zudem mehr Spaß.

Ich habe mir das so vorgestellt:

Als Beispielprojekt würde ich gern die Zähleinrichtung eines Kaffeeautomaten programmieren.

Der Kaffeeautomat

Der Kaffeeautomat besteht aus einem Münzeinwurf, in dem Euro- und Cent-Münzen eingeworfen werden können. Das eingeworfene Geld wird von einer Hardware erkannt und je nach dem welcher Münzwert erkannt wird, ein Port-Bit gesetzt.

Wir verwenden den Port 1 und nutzen folgende Zuordnung.

Wird also ein 2 Ct-Stück eingeworfen, wird das Bit Nr. 1 (von rechts mit 0 beginnend) auf „1“ gesetzt. Der Einwurf eines 2 Euro-Stücks setzt das höchstwertige Bit, also Bit Nr. 7.

Das Geld muss gezählt werden

Unser Programm für die Zähleinrichtung soll das eingeworfene Geld zählen.
Dies kann man machen, indem man den aktuellen Betrag in einer Variablen speichert und bei Einwurf eines weiteren Geldstücks den Betrag entsprechend erhöht.

Das Geld wird also eingeworfen. Nachdem die ENTER-Taste betätigt worden ist, soll das Geld dem Guthaben gutgeschrieben werden. Hinweis: Bitte vor dem Druck auf die ENTER-Taste in das Fenster für die serielle Schnittstelle wechseln, damit der Simulator die Eingabe interpretieren kann.

Das aktuelle Guthaben soll ausgegeben werden.

Jetzt bist Du an der Reihe

Jetzt geht es für Dich darum, die Zähleinrichtung zu programmieren. Eine mögliche Lösung werde ich in der nächsten Folge vorstellen, bevor es dann weiter um die Getränkeausgabe geht.

Dieser Artikel ist Teil des Mikrocontroller-Kurses auf ET-Tutorials.de.
[ >> Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .]

Der Beitrag Programmierung eines Kaffeeautomaten erschien zuerst auf ET-Tutorials.de.

Diese Aufgabe sollte mit if/else-Statements gelöst werden.

Hierzu wurden zunächst Informationen über die Kesseltemperatur und den Kesseldruck über den Port P1 eingelesen.

Abhängig von diesen Zustandsmeldungen sollten dann Meldungen ausgegeben werden.

Über die serielle Schnittstelle sollte ausgegeben werden, ob

• die Temperatur zu hoch ist,

• der Druck zu hoch ist,

• Temperatur und Druck zu hoch ist, oder

• alles OK ist

Über den Port P1 wird die Information über den Zustand des Kessels zur Verfügung gestellt.

Im folgenden Video zeige ich eine Möglichkeit der Realisierung.

[ >> Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .]

Der Beitrag Anzeigensteuerung für einen Kessel erschien zuerst auf ET-Tutorials.de.

In der vergangenen Folge haben wir uns Bedingungen und Vergleiche angeschaut.

Dies können wir nun für die bedingten Anweisungen gut gebrauchen.

Eine bedingte Anweisung nötigt den Mikrocontroller dazu, wie der Name schon sagt, abhängig von bestimmten Bedingungen gewünschte Anweisungen durchzuführen.

Dies kann man beispielsweise bei Steuerungsaufgaben dazu nutzen, um auf Anforderung ein Transportband zu starten und bei Erreichen einer Endbedingung, wie z.B. einer Lichtschranke wieder zu stoppen.

Solchen Aufgaben, die man mit bedingten Anweisungen lösen kann, begegnet man regelmäßig in der Steuerungstechnik.

Die Struktur der bedingten Anweisung

Die Struktur sieht dabei folgendermaßen aus:

if ( Bedingung )

{ Anweisungen 1 }

else

{ Anweisungen 2 }

Erweiterung der bedingten Anweisung mit else

Mit else if kann die Bedingte Anweisung noch weiter geschachtelt werden:

if ( Bedingung1 )

{ Anweisungen 1}

else if ( Bedingung2 )

{ Anweisungen 2 }

else

{ Anweisungen 3 }

Im Video zeige ich wie man das Beispiel aus der vorletzten Folge umsetzt und erweitert.

Nun bist Du wieder an der Reihe

Es soll eine Anzeigensteuerung für einen chemischen Prozess realisiert werden.

Zentrale Komponente des Prozesses ist ein Kessel, in dem eine Flüssigkeit erhitzt wird. Kritisch bei dem vorliegenden Prozess ist

1. die Temperatur T der Flüssigkeit und
2. der Druck P

Über die serielle Schnittstelle soll ausgegeben werden, ob

1. die Temperatur zu hoch ist,
2. der Druck zu hoch ist,
3. Temperatur und Druck zu hoch ist, oder
4. alles OK ist

Über den Port P1 wird die Information über den Zustand des Kessels zur Verfügung gestellt.

Das niederwertigste Bit wird gesetzt, falls die Temperatur zu hoch ist,
das nächste Bit wird gesetzt, falls der Druck zu hoch ist.

Es gibt also folgende Möglichkeiten

00000001 T zu hoch

00000010 P zu hoch

00000011 P und T zu hoch

00000000 Alles OK.

Die Ausgabe soll also wie im folgenden Video gezeigt aussehen.

Dieser Artikel ist Teil des Mikrocontroller-Kurses auf ET-Tutorials.de.
[ >> Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .]

Der Beitrag Bedingte Anweisungen mit if erschien zuerst auf ET-Tutorials.de.

Neben dem Mikrocontroller-Kurs hier bei ET-Tutorials.de, den ich Dir hiermit ans Herz legen möchte, gibt es selbstverständlich noch weitere sehr interessante Quellen zum Thema Mikrocontrollertechnik.

Heute möchte ich Euch eine Webseite vorstellen, die für Elektrotechniker, vor allem für diejenigen, die sich auch mit dem Thema Mikrocontroller und Elektronik beschäftigen, eine hilfreiche Anlaufstelle sein kann.

Auf www.mikrocontroller.net findet man eine Seite mit einer sehr umfassenden Einführung in die Welt der AVR-Mikrocontroller der Firma Atmel.

In der folgenden Kurzbeschreibung möchte ich auf die wesentlichen Stärken dieser Seite eingehen.

Umfangreiches AVR-Tutorial

Neben einer Übersicht zum Thema AVR-Mikrocontroller gibt es ein Tutorial, in dem die Programmierung von AVR-Mikrocontrollern sehr detailliert erläutert wird.
Informationen zu weiteren Mikrocontrollerfamilien der Firmen ARM und Texas Instruments und Bereiche zu den Themen FPGA und Digitaler Signalverarbeitung ergänzen das Angebot.

Das Forum

Herz von www.mikrocontroller.net und für viele Besucher die wichtigste Anlaufstelle ist das sehr aktive Forum.

Vor allem die Bereiche „µC und Elektronik“ und „Analogtechnik“ sind sehr beliebt.

Anfänger finden hier Hilfestellung zu vielen Fragen. Erfahrene finden in den Foren die Ansprechpartner, um auch kniffeligere Probleme gemeinsam diskutieren und lösen zu können.

Fazit

www.mikrocontroller.net ist eine sehr gelungene Seite, die man vor allem wegen der starken Community regelmäßig besuchen sollte.

Der Beitrag Mikrocontroller.net – das Portal rund um den AVR-Mikrocontroller erschien zuerst auf ET-Tutorials.de.

Im Video wird beispielsweise gezeigt, wie ich die Ausgabe über die serielle Schnittstelle davon abhängig machen kann, ob der Wert von Port 1 größer, gleich oder kleiner als der Wert in Port 2 ist.

Für den Vergleich stehen mehrere Vergleichsoperatoren zur Verfügung

Operator	Funktion
 ==	        Gleich
 !=	        Ungleich
 >	        Größer
 >=	        Größer oder gleich
 <	        Kleiner
 <=	        Kleiner oder gleich
 &&	        Logisches UND
 ||	        Logisches ODER
 !	        Negation

Häufig muss man mehrere Vergleiche schachteln. Damit der Compiler geschachtelte Vergleiche richtig interpretieren kann, ist die Reihenfolge der Vergleiche festgelegt.

Es gilt

<, <=,>,>= hat Vorrang vor ==, != hat Vorrang vor &&, ||

Ich empfehle jedoch, mit Klammern zu definieren, was man genau vergleichen möchte.

So ist man auf der sicheren Seite.

Also statt if ( a < b  &&  b < c ) würde ich if ( (a<b)  &&  (b< c) ) schreiben, obwohl die Klammern hier eigentlich überflüssig sind.

Diese Vergleiche werden häufig in Schleifen (dazu mehr in späteren Folgen) oder in if-Abfragen verwendet.

Ein kleines Beispiel zeige ich im folgenden Video:

[ >> Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .]

Der Beitrag Bedingungen und Vergleiche erschien zuerst auf ET-Tutorials.de.

In der Programmiersprache C hat man viele Möglichkeiten die Befehle abzukürzen. C hat daher leider und vor allem zu unrecht den Ruf etwas kryptisch zu sein.

Denn eins ist wichtig: Man kann die Befehle sehr kurz und damit sicher auch kryptisch darstellen – man muss es aber nicht tun.

Gerade für den Einsteiger macht es häufig mehr Sinn die Befehle etwas ausführlicher zu formulieren und somit die Lesbarkeit für den Anfänger zu erhöhen.

Hat man später etwas Erfahrung und Routine, ist man für die Möglichkeit, Befehle kürzer darzustellen oder mehrere Befehle zu schachteln, dankbar. Für den erfahrenen Programmierer, der weiß was er macht, ist nämlich kürzerer Code oft besser zu lesen.

Einige Schreibweisen machen aber auch schon für den Einsteiger Sinn und darum soll es im folgenden Video gehen.

Das Video

Zu Beginn des Videos zeige ich noch eine mögliche Lösung der Aufgabe aus der letzten Woche.

Kurz zusammengefasst

Die wesentlichen Abkürzungen sind also

• i+=2;
  um i in diesem Beispiel um den Wert 2 zu erhöhen und das Ergebnis wieder in der Variablen i abzulegen. (analog dazu i*=2, i/=2; i-=2)

• i++; bzw. ++1;
  um i zu inkrementieren. Analog geht natürlich auch i–; und –i; (doppeltes Minus-Zeichen) um i zu dekrementieren, also um den Wert 1 zu vermindern.
  Ob man nun i++; oder ++i; verwendet, hängt davon ab, ob man die Variable bei zusammengesetztem Befehl vor oder nach der Ausführung inkrementieren möchte.

Hier nun Deine Aufgabe

In der letzten Folge haben wir mit Hilfe des modulo-Operators zyklisch von 0 bis 4 gezählt. Wir haben also eine Variable inkrementiert und dann mit dem modulo-Operator dafür gesorgt, dass nur zyklisch von 0 bis 4 gezählt wird und anschließend die Variable mit printf() ausgegeben.

C wäre nicht C, wenn man das nicht in einer Zeile erledigen könnte.

Deine Aufgabe ist es also diese Zeile in die while()-Schleife zu schreiben.

Also

while(1)

{

printf( …); //alles in einem Befehl

}

[ >> Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .]

Der Beitrag Variablenzuweisung – Teil 2 erschien zuerst auf ET-Tutorials.de.

Wichtig ist hierbei, dass man die Werte, die entstehen, speichern kann. Heute geht es darum, wie man den Variablen, die wir in der letzten Folge behandelt haben, Werte zuweist.

Variablenzuweisung

Neben der direkten Zuweisung, wie

• i=5;

• i=j;

• i=P1;

bei denen i, j Variablen sind und P1 für einen PORT steht, von dem man Werte von außen einlesen kann, sind auch Berechnungen, wie

• i=3+2;

• i=i+2;

• i=i*j;

möglich.

Das Rechnen mit Variablen wird in dem heutigen Video gezeigt.

Die modulo-Funktion

Im zweiten Teil geht es um die modulo-Funktion.

Mit Hilfe des modulo-Operators %, kann der Rest einer Division ausgegeben werden. Dieser Operator wird sehr häufig für zyklisches Zählen verwendet. Dies ist oft nötig, wenn eine bestimmte Tätigkeit n-mal durchgeführt werden soll.

Beispiel:

5 % 2 ergibt 1 (denn 5/2=2, Rest 1).

Ein Beispiel findet Ihr im Video.

Jetzt bist Du wieder an der Reihe.

Nutze die modulo-Funktion, um in der Endlosschleife while(1) Zahlen von 0 bis 4 auszugeben.

Die Ausgabe soll also folgendermaßen aussehen:

0

1

2

3

4

0

1

2

3

4

…
[ >> Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .]

Der Beitrag Variablenzuweisung und modulo-Funktion erschien zuerst auf ET-Tutorials.de.

Die wichtigsten Datentypen

Dies sind vor allem folgende Datentypen:

• char

• short int

• long int

• (float)

Vor allem char, short int und long int werden häufig verwendet, während auf den Datentyp float für Gleitkommazahlen wegen der aufwändigen und daher langsamen Berechnung gern verzichtet wird.

Was das besondere an den Datentypen ist und wie man sie verwendet, wird im folgenden Video gezeigt.

Da das erste Video nun doch etwas lang geworden ist, habe ich die Anwendung von Variablen und die Ausgabe an die serielle Schnittstelle über printf in ein zweites Video ausgelagert.

Here we are …

Was passiert eigentlich bei einem Überlauf bei anderen Datentypen?

Jetzt bis Du an der Reihe. Versuche die Grenzen der einzelnen Datentypen zu testen.

Das kannst Du am besten am Datentyp signed char erkennen. Schreibe hierzu eine negative Zahl in eine Variable diesen Typs und kopiere dann den Wert in einen Port.

Und was passiert eigentlich bei einem Überlauf eines Integers mit Vorzeichen „signed int“?

[ >> Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .]

Der Beitrag Datentypen und die formatierte Ausgabe mit printf erschien zuerst auf ET-Tutorials.de.

Wie lautet die Syntax für eine Anweisung in C, wie füge ich Kommentare ein, was ist die Funktion main()? Anhand unseres Hello.c-Programms sind die groben Strukturen gut zu erkennen.

Diese ersten Strukturen sollen dann auch erst mal reichen, um loslegen zu können.

In den nächsten Folgen kommt dann nach und nach mehr dazu, so dass Du am Ende des C-Kurses die meisten Syntax-Elemente kennengelernt haben solltest.

Eine Übersicht zur C-Programmierung, auch wenn nicht alles für den Mikrocontroller verwendet werden kann, bietet ein kostenloses Online-Buch von Galilieo-Computing.

Im 2. Teil des Videos programmieren wir eine Eingabe eines Zeichens über die Tastatur und die anschließende Ausgabe auf dem Bildschirm.

Das Video heute ist etwas länger geworden, ca. 15 Minuten. Deshalb kann es beim Laden des Videos etwas länger dauern. Je nach Internet-Zugang bitte bis zu einer Minute einplanen.

Wie im Video gezeigt, werden Zeichen in einem Byte gespeichert und entsprechend einer Vereinbarung codiert.
Die Zuordnung findet man in der sogenanneten ASCII-Tabelle:

Im Video wird ein ‚A‘ eingelesen und über den Port P1 als 0x41 dargestellt. Diese Zuordnung findet man auch in der Tabelle.

[Dieser Artikel ist Teil einer Reihe zum Thema  Mikrocontroller. Hier geht es zur Übersichtsseite zu den anderen Artikeln des Mikrocontroller-Kurses ]

Der Beitrag C-Syntax, getchar() und printf() erschien zuerst auf ET-Tutorials.de.

Um in diesen Wust von Nullen und Einsen eine Struktur zu bringen, werden die binären Zahlen zusammengefasst.

Aus Bits werden Bytes und Nibbles. Die Zahlendarstellung ist binär und hexadezimal.

Ein Byte besteht aus 8 Bits.

Dieses Byte kann durch zwei hexadezimale Ziffern dargestellt werden. (4 Bits ermöglichen 2^4=16 Kombinationen, also eine hexadezimale Ziffer).

Ein halbes Byte, also vier Bits (entspricht einer hexadezimalesn Ziffer) nennt man Nibble.

Wie das ganze funktioniert und warum die Einführung von Nibbles Sinn macht, versuche ich in der heutigen Folge zu zeigen.

Dieser Artikel ist Teil des Mikrocontroller-Kurses hier auf ET-Tutorials.de.

Im Video werden wir uns mit Hilfe des Debuggers die einzelnen Schritte beim Rechnen mit binären und hexadezimalen Zahlen angucken und (hoffentlich) sehen, dass eine Umrechnung in Nibbles die Umrechnung von binären in hexadezimale Zahlen und umgekehrt sehr erleichert.

Hier noch einmal der abgespeckte C-Code aus dem Video.

/*——————————————————————————
 HELLO.C

 Copyright 1995-2005 Keil Software, Inc.
 ——————————————————————————*/

 #include <REG52.H>                /* special function register declarations   */
 /* for the intended 8051 derivative         */

 #include <stdio.h>                /* prototype declarations for I/O functions */

 /*————————————————
 The main C function.  Program execution starts
 here after stack initialization.
 ————————————————*/
 void main (void) {

 /*————————————————
 Setup the serial port for 1200 baud at 16MHz.
 ————————————————*/
 #ifndef MONITOR51
 SCON  = 0x50;                /* SCON: mode 1, 8-bit UART, enable rcvr      */
 TMOD |= 0x20;               /* TMOD: timer 1, mode 2, 8-bit reload        */
 TH1   = 221;                /* TH1:  reload value for 1200 baud @ 16MHz   */
 TR1   = 1;                  /* TR1:  timer 1 run                          */
 TI    = 1;                  /* TI:   set TI to send first char of UART    */
 #endif

 /*————————————————
 Note that an embedded program never exits (because
 there is no operating system to return to).  It
 must loop and execute forever.
 ————————————————*/

 while (1) {

 }
 }

[ >> Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .]

Der Beitrag Bits, Bytes und Nibbles erschien zuerst auf ET-Tutorials.de.

Wie ich bereits in Aussicht gestellt habe, sollen in dieser Folge das binäre und hexadezimale Zahlensystem dargestellt werden.

Wie im uns bekannten Dezimalsystem (10 er) erfolgt auch im binären (2 er) und im hexadezimalen (16 er) Zahlensystem beim Hochzählen nach dem Erreichen der höchsten Ziffer der Übergang zu einer neuen Stelle.

Kurz gesagt:

In dem uns bekannten, dezimalen Zahlensystem, kommt nach der Zahl 9 die Zahl kommt 10.

Es wird also die nächste Stelle genutzt.

Nach 99 folgt die 100, indem die dritte Stelle genutzt wird.

Entsprechend wird, wie im Video gezeigt, im Binär- und Hexadezimalsystem verfahren.

Im binären Zahlensystem kommt nach der Zahl 1 die Zahl 10. Die Ziffer 2 gibt es nämlich nicht im binären Zahlensystem.

Das hexadezimale Zahlensystem besteht aus 16 verschiedenen Ziffern.

Neben den zehn Ziffern 0,1,…,9 werden also weitere Zeichen benötigt. Hier verwendet man für die noch fehlenden sechs Zeichen die Buchstaben A,B,C,D,E und F.

Details dazu, wie gewohnt im Video.

Viel Spaß.

Das Umrechnen der Zahlen in die drei Zahlensysteme ist keine Spielerei. Beim Programmieren des Mikrocontrollers im zweiten Teil des Kurs wird dieses Umrechnen immer wieder benötigt. Nutzt also die Gelegenheit, um fit im Umrechnen zu werden.

Jetzt seid Ihr an der Reihe.

Wandelt folgende Zahlen vom hexadezimalen Zahlensystem in das dezimale Zahlensystem um:

• 2F
• 3C
• AB

und folgende Zahlen vom binären Zahlensystem in das dezimale Zahlensystem:

• 10011101
• 10101010

In der Entwicklungsumgebung uVision könnt Ihr Eure Ergenisse überprüfen.

Entsprechend könnt Ihr Euch überlegen, wie man dezimale Zahlen in hexadezimaler Schreibweise oder binärer Schreibweise ausdrückt.

Wie schreibt man beispielsweise die Zahlen 9, 14, 35, 135 und 209 in binärer und hexadezimaler Schreibweise?

Auch hier könnt Ihr mit Hilfe der Entwicklungsumgebung sehen, ob ihr richtig gerechnet habt.

[Hier geht es zur Übersichtsseite zu den anderen Artikeln des Mikrocontroller-Kurses hier auf ET-Tutorials.de.]

Der Beitrag Binäre, dezimale und hexadezimale Zahlen erschien zuerst auf ET-Tutorials.de.

Heute soll es zunächst einmal darum gehen, uns eine Arbeitsumgebung für die nächsten Folgen einzurichten.

Dazu werden wir eine Kopie des bereits bekannten Hello-Projekts erstellen. Mit diesem neuen Projekt werden wir dann den C-Kurs durchführen.

Im zweiten Teil des Videos werden wir dann mit diesem Projekt arbeiten. Wir bauen zunächst einmal die Funktion getchar() in unser Programm, so dass wir das Programm jederzeit anhalten können.

Die Funktion getchar() stoppt die Ausführung des Programms und wartet auf die Eingabe eines Zeichens über die serielle Schnittstelle. Durch die Eingabe eines Zeichens auf der Tastatur können wir das Programm weiterlaufen lassen.

So können wir das Programm an jeder gewünschten Stelle anhalten. Dies wird später hilfreich sein, um beispielsweise gemachte Berechnungen zu überprüfen und gegebenenfalls Fehler im Programm zu finden.

Im letzten Teil ändern wir die Ausgabe über die Ports.

Am Ende des Videos wurden Daten in den Port 1 geschrieben. Da der Mikrocontroller nur „1“ und „0“ kennt, werden die Zahlen binär angegeben.

In der nächsten Folge wird es ein Video geben, in dem ich auf die einzelnen Zahlendarstellungen „binär“, „dezimal“ und „hexadezimal“ eingehe. Dann wird es auch die ersten Übungen geben.

[Hier geht es zur Übersichtsseite zu den anderen Artikeln des Mikrocontroller-Kurses hier auf ET-Tutorials.de.]

Der Beitrag Einrichten eines Projektes in uVision erschien zuerst auf ET-Tutorials.de.

Im heutigen Artikel geht es um das Übersetzen eines C-Programms.

Ein C-Programm wird zunächst einmal in dem in der Entwicklungsumgebung integrierten  Texteditor geschrieben.

In dieser C-Datei stehen die Anweisungen, die der Mikrocontroller später ausführen soll.

Zudem werden in dieser Datei Anweisungen für die Übersetzungsprogramme – Compiler und Linker – untergebracht.

Themen des heutigen Artikels sind also

• Was ist eine .c-Datei
• Was ist eine .h-Datei
• Was macht der Compiler?
• Was ist eine .obj-Datei?
• Was macht der Linker?

Der Aufbau der Dateien und die Aufgaben der Übersetzungsprogramme werden im heutigen Video beschrieben.

In der nächsten Folge werden wir uns eine Arbeitsumgebung für den kommenden Kurs einrichten und unser Programm hello.c um weitere Funktionen erweitern.

[Hier geht es zur Übersichtsseite zu den anderen Artikeln des Mikrocontroller-Kurses hier auf ET-Tutorials.de.]

Der Beitrag Was machen Compiler und Linker ? erschien zuerst auf ET-Tutorials.de.

Das Standard C-Programm „Hello world“, das in keinem C-Einführungskurs fehlen darf, wird auch hier genutzt.

Hierzu wird der Mikrocontroller sozusagen virtuell über die serielle Schnittstelle mit einem Ausgabeterminal verbunden und dann wird über diese Verbindung die Zeichenkette „Hello world“ ausgegeben.

Zudem wird ein Bit eines Ausgabeports verändert.

Der Start der Entwicklungsumgebung

Um die Einzelheiten des Programms soll es aber jetzt noch nicht gehen. Erst einmal wird überprüft, ob die Installation funktioniert hat und Du eine funktionstüchtige Entwicklungsumgebung vor Dir liegen hast, mit der Du künftig die Programme entwickeln kannst.

Im folgenden Video wird gezeigt, wie Du das erste Programm lädst, kompilierst, linkst und dann auf dem Simulator laufen lässt.

Rufe jetzt uVision auf und vollziehe zunächst einmal die im Video angegebenen Schritte nach. In der nächsten Folge erkläre ich, was der Compiler und der Linker eigentlich genau machen.

[Hier geht es zur Übersichtsseite zu den anderen Artikeln des Mikrocontroller-Kurses hier auf ET-Tutorials.de.]

Der Beitrag Start der Entwicklungsumgebung uVision erschien zuerst auf ET-Tutorials.de.

Heute geht es also los mit dem Download und der Installation der Entwicklungsumgebung µVision 4 (häufig auch uVision geschrieben) von Keil Software.

Doch vorher noch ein paar einleitende Anmerkungen zum Thema Mikrocontroller.

Häufig werden die Begriffe Mikrocontroller und Mikroprozessor durcheinander geworfen. Es gibt zwar durchaus eine Verwandtschaft der Systeme, im Detail unterscheiden sie sich sich aber in wesentlichen Punkten.

Daher soll zunächst einmal geklärt werden, was ein Mikrocontroller eigentlich ist.

Was ist ein Mikrocontroller?

Seit etwas 1975 gibt es integrierte Schaltungen, bei denen ein komplexes Steuer- und Rechenwerk auf einem Chip integriert ist – den Mikroprozessor. In dem PC, Mac o.ä., mit dem Ihr gerade arbeitet, arbeitet ein solcher Mikroprozessor. Dieser Mikroprozessor hat eine Aufgabe, nämlich schnell, sehr schnell zu rechnen. Für andere Aufgaben gibt es, grob gesagt, in einem PC andere Komponenten.

Einen etwas anderen Ansatz hat man bei der Entwicklung von Mikrocontrollern verfolgt. Mikrocontroller rechnen langsamer als die heutigen Mikroprozessoren, haben dafür aber viele Funktionen und Schnittstellen, die man für moderne Steuerungs- und Regelungsaufgaben benötigt, auf einen Chip integriert.

So findet man beispielsweise Ein-/Ausgabeports, Analog-/Digitalwandler, serielle Schnittstellen, … auf dem Mikrocontroller.

Mikrocontroller werden heute vielfältig eingesetzt. Sie steuern und regeln fast alle elektronische Geräte. Man findet sie in Autos, Waschmaschinen, Videorecordern, Fernsehgeräten, …

Oft ist es einfacher und schneller und damit auch preisgünstiger, einen Mikrocontroller für eine Steuerungsaufgabe einzusetzen, als die Steuerung diskret aufzubauen.

Ist die Steuerung fehlerhaft oder soll sie geändert werden, reicht häufig ein einfaches Software-Update. Bei der Realisierung einer Steuerung durch eine Schaltung müsste man im schlechtesten Fall, die gesamte Schaltung neu entwickeln.

Ein typischer Vertreter der heute verwendeten Mikrocontroller ist der 8051 von INTEL. Dieser Mikrocontroller wurde von diversen Herstellern weiterentwickelt und ist von allen großen Halbleiterherstellern in diversen Derivaten erhältlich.

In diesem Kurs werden wir uns mit der Programmierung von Derivaten des 8051 beschäftigen.

Eine geeignete Software für die Programmierung eines 8051-Derivats ist das Programm uVision 4 von Keil.

Der Download und die Installation der Software wird im folgenden Video gezeigt.

Lade nun die Software von der Keil-Homepage und installiere sie auf Deinem PC.

In der nächsten Folge rufen wir dann die Software auf, kompilieren , linken und starten das erste Demoprogramm.

[Hier geht es zur Übersichtsseite zu den anderen Artikeln des Mikrocontroller-Kurses hier auf ET-Tutorials.de.]

Der Beitrag Download und Installation von uVision4/Keil erschien zuerst auf ET-Tutorials.de.

Wie bereits in der Ankündigung zum Kurs gesagt, fangen wir gaaanz am Anfang an. Man benötigt also keine Voraussetzung, um an diesem Kurs teilzunehmen. Ein PC und ein eine ausreichende Internet-Verbindung, um die Videos in angemessener Zeit laden zu können, reicht.

Aufbau des Kurses

Wir beginnen mit einer Einführung in die Programmiersprache „C“ und nutzen dabei auch schon bei der Einführung die Entwicklungsumgebung µVision von Keil, um uns von Anfang an die Programmierumgebung zu gewöhnen.

Nach dieser Einführung geht es dann um die speziellen Anforderungen zum Programmieren eines Mikrocontrollers. Was muss ich bei der Programmierung eines µC beachten, aber auch: Welche Möglichkeiten habe ich der µC-Programmierung, die ich auf anderen Systemen nicht oder nur sehr kompliziert oder teuer erreiche? Themen wie Interrupts, Timer, Analog-Digitalwandlung, Kommunikation über die serielle Schnittstelle seien hier genannt.

Kleinere Projekte

Anschließen soll sich ein dritter Teil, in dem ich mit Euch verschiedene Projekte kleinere Projekte angehen möchte. Hier soll dann das Erlernte aus den ersten beiden Teilen vertieft angewendet werden.

Themen aus der Steuerungstechnik und der Regelungstechnik sollen hier mit Hilfe des Mikrocontrollers umgesetzt werden. Aber auch hier möchte ich mich darauf beschränken, lediglich mit dem Simulator zu arbeiten. Das schränkt zwar die Auswahl geeigneter Projekte stark ein, ermöglicht uns aber ohne Investitionen in Hardware diesen Kurs durchzuführen.

Geplante Artikelfrequenz

Ihr macht diesen Kurs neben Eurer Schule, Eurer Ausbildung bzw. neben Eurer täglichen Arbeit. Ich werde daher versuchen, die einzelnen Artikel nicht zu schnell hintereinander zu schreiben, so dass jeder genügend Zeit hat, dem Kurs zu folgen.

Nicht jeder hat die Möglichkeit, gleich am Tag der Veröffentlichung eines neuen Artikels sich dem Kurs zu widmen. Ich werde also mindestens einen Tag zwischen zwei Artikeln Zeit lassen. Vor allem die Übungsphasen, das eigene Programmieren, erfordern erfahrungsgemäß viel Zeit.

Zudem bleiben  selbstverständlich die einzelnen Videos auch nach der Veröffentlichung online, so dass einzelne Phasen immer wieder nachgearbeitet werden können.

Daher habe ich zunächst folgendes Vorgehen geplant. Zu Beginn möchte ich zwei Artikel pro Woche veröffentlichen. Bei der Installation der Software, dem Kennenlernen des Simulators, dem Starten des ersten Programms geht es in den ersten Artikeln darum, die einzelnen Schritte nachzuvollziehen und sich an die Programmierumgebung zu gewöhnen, so dass bei zwei Artikeln pro Woche sicher genug  Zeit bleibt, um sich nachmittags oder abends mal eine Stunde an den Rechner zu setzen, um die ersten Aufgaben zu erledigen.

Später, wenn selbständige Übungen dazu kommen, plane ich, auch mal nur einen Artikel pro Woche zu veröffentlichen, um Euch genügend Zeit für das eigene Programmieren zu geben.

Programmieren lernt man durch Programmieren und Programmieren braucht Zeit.

Teilnehmer

Seitdem ich das Projekt angekündigt habe, haben sich bis heute ca. 800 Leser in den  Benachrichtungsdienst per E-Mail eingetragen. Dafür, dass ET-Tutorials.de noch recht jung und unbekannt ist, bin ich mit der Zahl der Interessenten sehr zufrieden, zumal sicher auch viele hier lesen werden, die sich nicht für den Benachrichtigungsdienst eingetragen haben.

Für den Benachrichtigungsdienst habe ich einen Emaildienst eingerichtet.
Als neuer Teilnehmer wirst Du Schritt für Schritt durch den Kurs geführt.
In jeder Email hat man selbstverständlich die Möglichkeit den Benachrichtigungsdienst auch wieder abzubestellen.

Um Dich für diesen kostenlosen Kurs einzuschreiben, trage bitte unten Deine Email-Adresse ein. Dann bekommst Du eine Aktivierungs-Mail, in der Du noch einmal auf einen Link klicken musst.

Trage hier nun Deine Email-Adresse ein, um Dich für den Kurs anzumelden.

	Wir halten uns an den Datenschutz.

Kommentare

Wie ich oben schon geschrieben habe, sind wir eine große Gruppe von ca. 600 Teilnehmern. In einem Präsenz-Seminar würde es dann ziemlich eng werden.

Durch das asynchrone Zusammenarbeiten (jeder Teilnehmer kann dann lernen , wann er/sie Lust und Zeit dazu hat und kann sich die Inhalte so oft angucken, wie er/sie es möchte) haben wir hier über eine Internetplattform die Möglichkeit, zusammen zu lernen, ohne uns gegenseitig auf die Füße zu treten.

Es wäre aber schade, wenn hier nur jeder für sich lernt. Man lernt am besten im Austausch mit anderen. Aber auch für mich ist es wichtig, ob die einzelnen Artikel in Form und Inhalt für Euch interessant sind, welche Verbesserungsvorschläge Ihr habt, ob das eine oder andere Thema vielleicht noch zusätzlich mit aufgenommen werden sollte, …

Kurz und knapp: Nutzt bitte die Möglichkeit unter jedem Artikel Kommentare zu hinterlassen, Anmerkungen und Vorschläge zu machen, damit der Kurs zu einem lebendigen Kurs wird.

Vielleicht kostet es zunächst  einige Überwindung zu kommentieren. Wer anonym bleiben möchte, kann das durch die Verwendung seines/ihres Vornamens oder eines Nick-Namens auch bleiben. Das Pflichtfeld  „Email-Adresse“ wird nicht ausgewertet, wer also auch mir gegenüber anonym bleiben möchte, kann hier auch irgendeine Adresse angeben. Beim Benachrichtigungsdienst geht das aber nicht, weil sonst die Email nicht zugestellt werden könnte. Ich versichere aber auch sicherheitshalber hier noch einmal, dass mir Datenschutz wichtig ist und ich die Email-Adressen selbstverständlich nicht weitergeben werde.

An dieser Stelle auch eine Bitte an die Erfahrenen unter Euch. Bei der Durchsicht der Email-Adressen aus der Benachrichtigungsliste sind mir auch einige Teilnehmer aufgefallen, die in der „Szene“ schon bekannt sind, selbst µC-Kurse halten und teilweise auch eigene Schulungsboards entwickelt und gebaut haben – und sich bestimmt nicht angemeldet haben, um die Grundlagen zu wiederholen ;-).

Ihr seid natürlich auch mehr als herzlich eingeladen, Eure Erfahrungen mit einzubringen und eventuelle Fragen mit zu beantworten. Das wäre eine große Hilfe und Unterstützung für mich. Vielleicht hat ja auch der eine oder andere von Euch, mal Interesse einen Gastartikel zu veröffentlichen. Vielleicht im dritten Teil des Kurses, wenn es um die Realisierung von kleineren Projekten geht.

Jeder kann mithelfen

Beim Aufbau der Seite ET-Tutorials.de kann ich Unterstützung gebrauchen. Wenn Du einen Fehler auf der Seite bemerkt, Dir irgendetwas nicht gefällt, würde ich mich über eine kurze Email sehr freuen.  Durch Feedback, positives oder negatives, kann ich die Seite verbessern.

Also, wenn Dir etwas nicht gefällt gib mir bitte Bescheid.

Wenn Dir meine Seite jedoch gefällt kannst Du ET-Tutorials.de und den Mikrocontroller-Kurs auch unterstützen. Und zwar, indem Du Dich aktiv beteiligt. Wie oben beschrieben, kannst Du das einerseits durch Kommentare tun. Auch wenn das auf den ersten Blick nicht so scheint, Kommentare sind wichtig für einen lebendigen Blog, der dieser Blog werden soll.

ET-Tutorials.de weiterempfehlen

Durch eine Weiterempfehlung an Freunde, Bekannte, Mitschüler, Kollegen, Lehrer, … kannst Du mithelfen, ET-Tutorials bekannter zu machen. Am einfachsten geht das über einen Link, der unter jedem Artikel steht.

Wie geht’s weiter

In der nächsten Folge geht es nun los. Wir werden die Software µVision herunterladen und installieren.

Unter folgendem Link findest Du eine Liste aller bereits erschienenen  Folgen des Mikrocontroller-Kurses.

Der Beitrag Start des Mikrocontroller-Kurses erschien zuerst auf ET-Tutorials.de.

Der Mikrocontroller hat nicht nur Einzug in unseren Alltag genommen, beim Zentral-Abitur an den beruflichen Gymnasien in Nordrhein-Westfalen steht er mittlerweile auch oben auf der Liste.

Ab Anfang Dezember werde ich daher hier auf ET-Tutorials.de einen Mikrocontrollerkurs für Einsteiger anbieten. Derzeit laufen die Planungen und Vorbereitungen des Kurses.

Hier schon einmal einige Informationen zum Kurs. Beim Mikrocontroller-Kurs wird es um eine Einführung in die Programmierung eines Mikrocontrollers der 8051-Familie in „C“ gehen.

Ein Kurs für Einsteiger

Für den Kurs benötigten man keinerlei Vorerfahrung. Es werden keine Kenntnisse im Bereich Hardware vorausgesetzt. Man muss auch kein Programmier-Profi sein. Im Gegenteil, das Programmieren soll ja gerade in diesem Kurs erlernt werden.

Der Kurs ist also eindeutig für Einsteiger gedacht. Wer schon Erfahrungen in der „C“-Programmierung hat, steigt vielleicht am besten im 2. Teil des Kurses (mehr über die Struktur des Kurses weiter unten) ein.

Keine Kosten

Die Teilnahme am Mikrocontroller-Kurs ist kostenlos.

Zudem werden keine Investitionen in Hard- oder Software für die Teilnehmer nötig sein.

Möglich ist das durch die Verwendung der kostenfreien Demo-Version der Programmierumgebung µVision 4 der Firma Keil. Keil gehört zu den Marktführern in diesem Marktsegment. Die Vollversion von µVision ist eine Profiversion die von vielen professionellen Entwicklern im 8051-Umfeld eingesetzt wird.

Zum Test dieser Software kann man eine Demo-Version dieser Software beim Hersteller herunterladen. Diese Software besitzt die volle Funktionalität, hat jedoch die Einschränkung, dass nur kleinere Projekte damit realisiert werden können. Für professionelle Projekte ist man daher auf die Vollversion angewiesen, für uns ist die kostenlose Demo-Version jedoch ausreichend.

Das Schöne an der Software ist, dass ein Simulator integriert ist, der per Software den gewünschten Mikrocontroller nachbildet, so dass man die erstellte Software testen kann, fast als wenn man einen Mikrocontroller zur Hand hätte.

Diesen Emulator werden wir nutzen, um die Kosten für Mikrocontroller, Programmiergerät, externe Hardware, … zu sparen. Somit wird der Kurs für alle Beteiligten umsonst kostenlos.

Der Kurs wird aus zwei Teilen bestehen.

1. Teil Grundlagen der Programmiersprache „C“

Mikrocontroller programmiert man meistens entweder in Assembler, einer Programmier-Sprache, die speziell auf den jeweiligen Mikrocontroller ausgerichtet ist, oder in einer der höheren Programmiersprache „C“. Ja, ja ich weiß: Man kann Mikrocontroller auch in Basic-Dialekten programmieren. Der Vorteil einer höheren Programmiersprache, wie „C“ liegt darin, dass der Code zum einen leichter lesbar (und programmierbar) ist, zum anderen, dass Programme leichter portierbar sind.

Die Geschwindigkeitsvorteile, die durch das hardwarenähere Programmieren in Assembler erreichbar sind, werden dank der immer besser werdenden C-Compiler immer geringer. Kurz und knapp: Wir programmieren in „C“.

Inhalte des C-Teils sollen beispielsweise sein:

• Aufbau eines C-Programms
• Das erste C-Programm „Hello World“
• Aufgaben des Compilers, des Linkers
• Variablen
• Ein-/Ausgabe
• Funktionen
• Bedingte Verzweigungen
• Schleifen
• Zeiger
• ….

2. Teil: Programmieren des Mikrocontrollers

Im zweiten Teil soll es dann um die Besonderheiten bei der Programmierung eines 8051-Mikrocontrollers gehen.

Themen sind hier unter anderem:

• Ports
• Externe Interrupts
• Timer/Counter
• Analog/Digital-Wandlung
• Serielle Schnittstelle
• …

Die einzelnen Folgen werde ich mit Übungsaufgaben ausstatten, so dass Ihr während des Kurses zu Hause reichlich programmieren könnt. Programmieren lernt man nämlich am besten nur durch Programmieren.

Ich denke, dass dieser Kurs nicht für diejenigen interessant sein kann, die demnächst in NRW an einem beruflichen Gymnasium ihr Abitur machen und daher den Kurs für die Abiturvorbereitung nutzen können, sondern auch für alle anderen, die das Programmieren eines Mikrocontrollers erlernen möchten.

Pro Woche wird es 1-2 Folgen geben, so dass Ihr zwischen den einzelnen Lektionen genug Zeit habt, das Erlernte zu üben.

Einfach anmelden

Um den Start des Kurses und die einzelnen Folgen nicht zu verpassen, trag‘ bitte hier Deine Email-Adresse ein. Dann bekommst Du eine Aktivierungs-Mail, in der Du nochmal auf einen Link klicken musst.

Um Dich für diesen kostenlosen Kurs einzuschreiben, trage bitte unten Deine Email-Adresse ein. Dann bekommst Du eine Aktivierungs-Mail, in der Du noch einmal auf einen Link klicken musst.

Trage hier nun Deine Email-Adresse ein, um Dich für den Kurs anzumelden.

	Wir halten uns an den Datenschutz.

Wichtig:
Deine EMail-Adresse behandle ich natürlich vertraulich und gebe diese an niemanden weiter. Zudem kannst Du Dich jederzeit durch einen Klick auf den Abmeldelink in einer der Emails einfach wieder abmelden.

[ Hier geht es zurück zur Übersichtsseite des Mikrocontroller-Kurses .]

Der Beitrag Kostenloser Mikrocontroller-Kurs erschien zuerst auf ET-Tutorials.de.