Einleitung
Im folgenden beschreibe ich Hinweise und Tipps zur Entwicklung eigener Programme. Ich gehe dabei davon aus, dass eine gewisse Erfahrung bereits vorliegt – beispielsweise durch Lesen und Durcharbeiten des exzelllenten Tutorials auf mikrocontroller.net. Meine Entwicklungssprache ist C – mit Assembler bin ich schon in den 80er Jahren nicht mehr warm geworden.
Zunächst muss man sich verdeutlichen, dass der zu programmierende Mikrocontroller zwar potenziell viel kann, erst einmal mit diesen Funktionen gar nichts selbst anfangen kann – ebenso wie Transistoren, Spulen, Kondensatoren und Widerstände ein Radio bilden, aber genauso gut herumliegen können. Genau da setzt das Prinzip dieses Mikrocontroller Labs an – eine Bibliothek für die Aus- und Eingabe ist vorhanden, wohingegen die eigentliche Aufgabe (beispielsweise die Sensordatenerfassung) selbst gelöst werden muss. Ich werde dies anhand eines Beispiels verdeutlichen.
Was wird benötigt?
Die erstellte Bibliothek besteht aus mehreren Dateien:
- mclib.h – diese Headerdatei muss von allen Programmen eingebunden werden, die das Eingabe-Ausgabesystem benutzen wollen.
- mclib.c – diese Datei enthält die controllerseitigen Funktionen des Eingabe-Ausgabesystem und muss im Arbeitsverzeichnis oder im Pfad verfügbar sein.
- SendKeys.h – diese Headerdatei enthält die empfangenen Kommandos des Tastatur- und Touchscreen-Controllers
- grafik.h – diese Headerdatei enthält die Kommandos und Unterkommandos, die der Grafikcontroller empfangen kann.
Eine Beispielanwendung
Es soll die Lichtstärke mit einem LDR erfasst werden. Dank recht hochohmiger Eingänge kann ein Spannungsteiler aus LDR und 10kOhm-Widerstand direkt an einen Eingang des AVR angeschlossen werden. Der AVR selbst bietet dazu einen A/D-Wandler, der nach ein bisschen Verständnis für die einzelnen Parameter (= zu setzende Bits), die zum Betrieb nötig sind, reicht einfach anzusteuern ist:
DDRA = 0x00;
// Setzen einiger Register
ADMUX = (0 << REFS1) | (1 << REFS0) ;
ADCSRA = (1 << ADEN) | (1 << ADSC) | (1 << ADATE) | (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0) | (0 << ADIE) ;
ADCSRB = (0 << ADTS2) | (0 << ADTS1) | (0 << ADTS0) | (0 << ACME);
// Los gehts
for (;;)
{
// gemessener Wert wird abgefragt und in eine Spannung umgerechnet
Value = ADCW;
Value = Value / 5.12 + 33;
x = round(Value);
// ein bisschen warten bis zur nächsten Erfassung
_delay_ms(delay);
}
// Zuletzt Abschalten des A/D-Wandlers
ADCSRA = 0x00;
Soweit kommt man auch durch Lesen des Manuals zum Mikrocontroller und ggf. einiger Beispiele im Internet. Jetzt erfasst man also alle paar Zeiteinheiten einen Messwert – und nun? Wie bekommt man die Werte nun angezeigt? Genau da setzt die Bibliothek Mikrocontroller Lab an. Sie erlaubt es, einerseits den Wert für „delay“, also die Wartezeit bis zur nächsten Messung, elegant festzulegen und außerdem die gemessenen Werte auf den Bildschirm zu bringen. Schauen wir uns das ganze Programm mit den Erweiterungen noch einmal an:
void Messwerterfassung(void)
{
// ein paar Variablen vereinbaren
unsigned char c=0;
double Value;
unsigned int x;
signed int delay;
char String_Buffer[10];
// Erstmal den Benutzer informieren, was man vorhat. Er hat nur die Möglichkeit, auf OK zu drücken
MessageBox(MESSAGEBOX_OK, "Messwerterfassung", "Bitte variable Eingangsspannung", "zwischen 0 und 5V an Eingang A0", "anschließen.");
// Jetzt abfragen, welche Pausen zwischen den Messungen gemacht werden sollen
// Es wird eine numerische Tastatur angezeigt, zulässig sind nur Werte zwischen 10 und 500
delay = ShowKeyboard(10,500, NUMERIC_KEYBOARD, "Intervall (10-500ms) : ");
// Die Funktion kehrt mit einem gültigen Wert für value zurück (oder "KEYBOARD_CANCELLED", falls "Abbrechen gedrückt wurde
if (delay != KEYBOARD_CANCELLED)
{
// Jetzt Kommandos an die Grafikeinheit senden
Send_Command(MODE_QUIT); // Aktuellen Modus verlassen, kommt immer als erstes
Send_Command(MODE_MESSWERTE); // Messwerterfassung wird aktiviert
// Es soll erstmal ein Text ausgegeben werden - das ist nettes Beiwerk
Send_Command(MESSWERTE_TEXT);
Send_String("Messwerterfassung, Intervall ");
itoa(delay, String_Buffer,10); // Standardbefehl in C zum Wandeln von Zahlen in Strings
Send_String(String_Buffer);
Send_String(" ms");
// Der resultierende String heißt beispielsweise "Messwerterfassung, Intervall 10 ms"
// Jetzt sollen Anzeigewerte geschickt werden
Send_Command(MESSWERTE_WERTE);
_delay_ms(500);
// Jetzt kommt der schon bekannte Teil von eben
DDRA = 0x00;
ADMUX = (0 << REFS1) | (1 << REFS0) ;
ADCSRA = (1 << ADEN) | (1 << ADSC) | (1 << ADATE) | (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0) | (0 << ADIE) ;
ADCSRB = (0 << ADTS2) | (0 << ADTS1) | (0 << ADTS0) | (0 << ACME);
for (;;)
{
Value = ADCW;
Value = Value / 5.12 + 33;
x = round(Value); // Ein Wert zwischen 34 und 234
// Jetzt senden wir den Wert ganz einfach an die Grafikeinheit
Send_Value(x);
// Pause für den über "delay" vorhin festgelegten Zeitraum
_delay_ms(delay);
// Abfrage des Tastaturcontrollers, ob Taste gedrückt wurde
c = Check_For_Input;
if (c==SENDKEY_OK) // OK-Taste betätigt, dann bitte abbrechen
break;
}
ADCSRA = 0x00;
}
}
Man sieht nun auf dem Bildschirm erst einmal eine Dialogbox, danach eine Abfrage und schließlich eine fortlaufende Messkurve. Die Ausgabe eines Textes und die Abfrage der Tastatur sind letztlich nettes Beiwerk, damit man weiß, was passiert und damit das Programm auch ein definiertes Ende hat. Damit entfallen beim Entwickeln genau die Aufgaben, die ansonsten viel Arbeit machen und fehlerbehaftet sind, nämlich die Ein-Ausgabe-Routinen.
Hinter den Funktionen „Send_Command“, „Send_String, „Send_Value“ und „Check_For_Input“ verbergen sich Makros zur Abfrage und Befüllung der seriellen Schnittstelle. Die gewählte Benennung erleichtert lediglich das Lesen des Codes – ansonsten stünde da „uart_putc“, „uart_puts“ und „uart_getc“. Eine vollständieg Beschreibung aller Kommandos und Funktionen findet sich hier.
Wie das ganze im wirklichen Leben aussieht, kann man sich auf youtube in einem Video anschauen.
