Microsoft Word - Gen.. - von Gunthard Kraus

Microcontroller-Projekt:
Sinus-Rechteck-Generator mit Drucktastensteuerung und LCD-Display-Anzeige
Autor: Gunthard Kraus OSTR, Elektronikschule Tettnang
1. Aufgabenstellung und Entwicklungsschritte
Mit diesem Projekt sollen nacheinander folgende Lernziele erreicht werden:
a) Prinzip der Erzeugung von Analogsignalen mit dem Mikrocontroller verstehen
b) Wertetabellen zur Ausgabe unterschiedlicher Kurvenformen erstellen und benutzen können
c) Drucktastensteuerungen unter Verwendung von Flags (= „Merkern“) programmieren können
d) Menüführung über LCD-Display programmieren können
e) Den Code-Umfang durch Einsatz von Funktionen mit Parameter-Übergabe reduzieren können.
Dabei wird die D-A-Wandler-Platine über ein Flachbandkabel an Port P1 angeschlossen und mit dem Oszilloskop
das erzeugte Analogsignal an ihrem Analogausgang beobachtet.
Folgende Entwicklungsschritte sind dabei vorgesehen:
Step 1:
Step 2:
Step 3:
Step 4:
Step 5:
Erzeugung einer Sinusspannung mit f = 50 Hz
Erweiterung der Sinuserzeugung um 2 Drucktasten (AUS / EIN)
Zusätzlicher Einbau eines Displays (Anzeigen: „Generator AUS“ bzw. „Sinus f = 50Hz“)
Umschaltmöglichkeit zwischen drei Sinus-Signalen ( 50 Hz / 100 Hz / 200 Hz) mit
entsprechender Displayanzeige und Vereinfachung des Programmcodes durch Funktionen mit
Parameter-Übergabe
Steuerung über 7 Drucktasten: Sinus 50 Hz / 100 Hz / 200 Hz
Rechteck 50 Hz / 100 Hz / 200 Hz
mit Display-Anzeige
--------------------------------------------------------------------------------------------------------------------------
Step 1: Erzeugung einer Sinusspannung mit der Frequenz f = 50 Hz
Dazu wird eine Periode einer Sinusspannung durch eine Folge von 72 Werten dargestellt ( das ergibt 5 Grad –
Schritte). Diese Sinustabelle wird in das EPROM des Controllers eingebrannt und schrittweise ausgelesen. Über
unterschiedliche Wartezeiten nach jedem Ausleseschritt kann die Frequenz verändert werden.

Zur Erstellung der Wertetabelle ist folgende Überlegung nötig:
Dieser Spannungsverlauf entspricht der Summe aus einer Gleichspannung und einer sinusförmigen
Wechselspannung. Also kann man schreiben:
Wert = 127 + 127*sinus(α) = 127 *[1+ sinus(α)]
Die Tabelle berechnet man entweder mit dem Taschenrechner nach der rechten Formel (mit 5 Grad-Schritten
beim Winkel) oder man erledigt die Sache mit Excel. Kommastellen werden nicht benötigt -- Bitte also auf- oder
abrunden.
Zur Kontrolle:
Winkel in Grad | 0 | 5 | 10 | 15 | 20 | 25 | 30 | 35 | 40 | 45 | 50 | 55 | 60 | 65 | 70 | 75 | 80
-------------------------------------------------------------------------------------------------------------------------------------------------------
Wert | 127 | 138 | 149 | 160 | 170 | 181 | 191 | 200 | 209 | 217 | 224 | 231 | 237 | 242 | 246 | 250 | 252
Winkel in Grad | 85 | 90 | 95 | 100 | 105 | 110| 115 | 120 | 125 | 130 | 135 | 140 | 145 | 150 | 155 | 160 | 165
-------------------------------------------------------------------------------------------------------------------------------------------------------
Wert | 254 | 254 | 254 | 252 | 250 | 246 | 242 | 237 | 231 | 224 | 217 | 209 | 200 | 191 | 181 | 170 | 160
Winkel in Grad | 170 | 175 | 180 | 185 | 190 | 195 | 200 | 205 | 210 | 215 | 220 | 225 | 230 | 235 | 240 | 245 | 250
-------------------------------------------------------------------------------------------------------------------------------------------------------
Wert | 149 | 138 | 127 | 116 | 105 | 95 | 84 | 73 | 64 | 54 | 45 | 37 | 30 | 23 | 17 | 12 | 7
Winkel in Grad | 255 | 260 | 265 | 270 | 275 | 280 | 285 | 290 | 295 | 300 | 305 | 310 | 315 | 320 | 325 | 330 | 335
-------------------------------------------------------------------------------------------------------------------------------------------------------
Wert | 4 | 2 | 0 | 0 | 0 | 2 | 4 | 7 | 12 | 17 | 23 | 30 | 37 | 45 | 54 | 64 | 73
Winkel in Grad | 340 | 345 | 350 | 355 |
---------------------------------------------------------
Wert | 84 | 95 | 105 | 116 |
Diese Tabelle wird nun als Array in das EPROM des Controllers gebrannt und Schritt für Schritt ausgelesen.
Nach jedem Auslesen eines Schrittes wird die für eine Frequenz von f = 50 Hz erforderliche Wartezeit aufgerufen.
Sie beträgt
T Warte = ( 20 Millisekunden ) / 72 = 278 Mikrosekunden.
Sind alle Werte ausgelesen, dann beginnt der Vorgang neu.
Achtung: Die Wartezeit ist nur geschätzt. Bitte mit dem Oszilloskop oder dem
Frequenzzähler das Signal nachprüfen und ggf. den Wert korrigieren!
Musterlösung: Siehe nächstes Blatt

Musterlösung:
Erzeugung einer 50 Hz – Sinusschwingung (Ausgabe des Datenbytes an Port 1)
//Sinus_01.c
//Erstellt am 10.02.2006 durch G. Kraus
#include
#include
sfr ausgang=0x90;
void warten(void);
// Port P1 wird der Digital-Ausgang
// Prototyp
code unsigned char Sinus[72]=
{ 127,138,149,160,170,181,191,200,209,217,224,231,237,242,246,250,252,
253,254,253,252,250,246,242,237,231,224,217,209,200,191,181,170,160,
149,138,127,116,105,95,84,73,64,54,45,37,30,23,17,12,7,
4,2,1,0,1,2,4,7,12,17,23,30,37,45,54,64,73,84,95,105,116
};
void main(void)
{ while(1)
{
unsigned char x;
for(x=0;x

Step 2: Erweiterung der Sinuserzeugung um 2 Drucktasten (AUS / EIN)
Dazu wird das Programm um eine „Tasten-Abfragefunktion“ erweitert. Sie wird in der Ruhestellung des
Generators dauernd, bei der Sinuserzeugung dagegen nach jeder vollen erzeugten Sinusschwingung aufgerufen,
fragt die beiden Drucktasten ab und speichert das Abfrage-Ergebnis in zwei „Merkern“ (= Bits = Flags).
Die gewählte Betriebsart ( = AUS oder SINUS 50 Hz) wird dann solange ausgeführt, wie das entsprechende Flag
gesetzt ist.
// Sinus_02.c, erstellt am 10.02.2006 durch G. Kraus
#include
#include
sfr ausgang=0x90;
sbit Taste_AUS=P4^0;
sbit Taste_Sin50Hz=P4^1;
bit AUS;
bit Sin50Hz;
void warten(void);
void Tastenabfrage(void);
// Port P1 wird der Digital-Ausgang
// Tastendeklaration
// Merker-Deklaration
// Prototyp
code unsigned char Sinus[72]=
{ 127,138,149,160,170,181,191,200,209,217,224,231,237,242,246,250,252,
253,254,253,252,250,246,242,237,231,224,217,209,200,191,181,170,160,
149,138,127,116,105,95,84,73,64,54,45,37,30,23,17,12,7,
4,2,1,0,1,2,4,7,12,17,23,30,37,45,54,64,73,84,95,105,116
};
void main(void)
{ unsigned char x; // Adressierung des Arrayplatzes
AUS=1;
// Generator ausschalten
while(1)
{
while(AUS==1)
// Generator ausgeschaltet
{ Tastenabfrage();
}
}
}
while(Sin50Hz==1)
// Sinus 50 Hz wird erzeugt
{ for(x=0;x

Step 3: Zusätzlicher Einbau eines Displays (Anzeigen: „Generator AUS“ bzw.
„Sinus f = 50Hz“) unter Beibehaltung der Drucktastensteuerung
Hierfür ist die zusätzliche Einbindung der Datei „LCD_CTRL_new.c“ in das Projekt erforderlich, da diese alle für
den korrekten Betrieb des Displays nötigen Steuerfunktionen enthält (Listing dieser Datei: Siehe Anhang).
Außerdem werden alle Prototypen der dort entwickelten Anzeigefunktionen übernommen.
Zusätzlich müssen noch zwei Texte als Arrays im EPROM des Controllerboards angelegt werden, nämlich die
Anzeigen für „Generator AUS“ und „Sinus f = 50 Hz“.
Bitte beachten: bei den LCD-Displays sind normalerweise 4 Zeilen zu je 20 Zeichen vorgesehen. Wird der Text
pro Zeile zu lang gewählt, dann gilt folgende „Überlauf-Regel“:
Nach Zeile 1 kommt Zeile 3 und nach Zeile 2 geht es in Zeile 4 weiter!
Man sollte es sich auch zum Prinzip machen, „unveränderliche“ Texte IMMER im EPROM des Controllerboards
anzulegen, um kostbaren RAM-Speicherplatz zu sparen. Außerdem muss man bei solchen Character-Texten
immer etwas aufpassen und mitzählen:
21 Arrayplätze müssen vorgesehen werden, aber beim auszugebenden Text dürfen nur 20 Zeichen
zwischen den Anführungszeichen im Array stehen!
(Grund: an solche Zeichenketten-Arrays wird immer automatisch vom C-Compiler das zusätzliche Zeichen „0x00“
angehängt. Es markiert das Ende des Arrays und die Display-Anzeigefunktion „show_text(….);“ sucht immer nach
diesem Zeichen um herauszufinden, wo der Text endet!).
Das Beschreiben der Anzeige mit dem gewünschten Text erfolgt in der Tastenabfrage. Wird eine gedrückte Taste
erkannt, dann wird der zugehörige Merker erkannt UND der passende Text auf dem Display ausgegeben.
Achtung: Die Wartezeit ist nur geschätzt. Bitte mit dem Oszilloskop oder dem
Frequenzzähler das Signal nachprüfen und ggf. den Wert korrigieren!
// Sinus_03.c
// Erstellt am 10.02.2006 durch G. Kraus
#include
#include
sfr ausgang=0x90;
sbit Taste_AUS=P4^0;
sbit Taste_Sin50Hz=P4^1;
bit AUS;
bit Sin50Hz;
void warten(void);
void Tastenabfrage(void);
// Port P1 wird der Digital-Ausgang
// Tastendeklaration
// Merker-Deklaration
// Prototypen
void zeit_s(void);
void zeit_l(void);
void lcd_com(void);
void lcd_ein(void);
void lcd_ini1(void);
void switch_z1(void);
void switch_z2(void);
void switch_z3(void);
void switch_z4(void);
void show_text(char *ptr);
void show_char(char *zeichen);

code unsigned char Sinus[72]=
{ 127,138,149,160,170,181,191,200,209,217,224,231,237,242,246,250,252,
253,254,253,252,250,246,242,237,231,224,217,209,200,191,181,170,160,
149,138,127,116,105,95,84,73,64,54,45,37,30,23,17,12,7,
4,2,1,0,1,2,4,7,12,17,23,30,37,45,54,64,73,84,95,105,116
};
code unsigned char Text_Aus[21]={"Generator AUS "};
code unsigned char Text_Sinus_50Hz[21]={"Sinus f = 50 Hz "};
void main(void)
{ unsigned char x; // Adressierung des Arrayplatzes
lcd_ein();
lcd_ini1();
switch_z1();
show_text(Text_Aus);
AUS=1;
// Generator ausschalten
while(1)
{
while(AUS==1)
{ Tastenabfrage();
}
// Generator ausgeschaltet
}
}
while(Sin50Hz==1)
// Sinus 50 Hz wird erzeugt
{ for(x=0;x

Step 4: Umschaltmöglichkeit zwischen drei Sinus-Signalen ( 50 Hz / 100 Hz /
200 Hz) mit Displayanzeige und Vereinfachung des Programmcodes durch
Funktionen mit Parameter-Übergabe
Sobald mehrfach dieselbe Funktion mit unterschiedlichen Werten ausgeführt werden soll (hier: Erzeugung von
Sinuskurven mit unterschiedlichen Frequenzen), schreibt man nur eine „Grundfunktion“. Ihr übergibt man die
Informationen über den gerade gewünschten Wert als Parameter. So spart man Programmcode und Rechenzeit.
Lösung:
z. B. für die Sinus-Erzeugung schreibt man im Hauptprogramm
Sinusper(82); // das ergibt eine Schwingung mit f = 50 Hz
----------------------------------------------------------------------------
Dazu ist folgende Prototypen-Anmeldung nötig:
void Sinusper(unsigned char Wert);
----------------------------------------------------------------------------
Die Funktion selbst sieht so aus:
void Sinusper(unsigned char Wert)
{ unsigned char x,y;
for(x=0;x

void switch_z2(void);
void switch_z3(void);
void switch_z4(void);
void show_text(char *ptr);
void show_char(char *zeichen);
code unsigned char Sinus[72]=
{ 127,138,149,160,170,181,191,200,209,217,224,231,237,242,246,250,252,
253,254,253,252,250,246,242,237,231,224,217,209,200,191,181,170,160,
149,138,127,116,105,95,84,73,64,54,45,37,30,23,17,12,7,
4,2,1,0,1,2,4,7,12,17,23,30,37,45,54,64,73,84,95,105,116
};
code unsigned char Text_Aus[21]={"Generator AUS "};
code unsigned char Text_Sinus_50Hz[21]={"Sinus f = 50 Hz "};
code unsigned char Text_Sinus_100Hz[21]={"Sinus f = 100 Hz "};
code unsigned char Text_Sinus_200Hz[21]={"Sinus f = 200 Hz "};
void main(void)
{ lcd_ein();
lcd_ini1();
switch_z1();
show_text(Text_Aus);
AUS=1;
while(1)
{
while(AUS==1)
{ Tastenabfrage();
}
while(Sin50Hz==1)
{ Sinusper(82);
Tastenabfrage();
}
while(Sin100Hz==1)
{ Sinusper(36);
Tastenabfrage();
}
while(Sin200Hz==1)
{ Sinusper(13);
Tastenabfrage();
}
// Generator ausschalten
// Generator ausgeschaltet
// Sinus 50 Hz wird erzeugt
// Sinus 100 Hz wird erzeugt
// Sinus 200 Hz wird erzeugt
}
}
void Sinusper(unsigned char Wert)
// Wartezeit
{ unsigned char x,y;
for(x=0;x

if(Taste_Sin50Hz==0) // Taste Sinus-50Hz gedrückt?
{ AUS=0;
Sin50Hz=1;
Sin100Hz=0;
Sin200Hz=0;
switch_z1();
// Auf den Anfang von Zeile 1 schalten
show_text(Text_Sinus_50Hz); // Text anzeigen
}
if(Taste_Sin100Hz==0)
{ AUS=0;
Sin50Hz=0;
Sin100Hz=1;
Sin200Hz=0;
switch_z1();
show_text(Text_Sinus_100Hz);
}
if(Taste_Sin200Hz==0)
{ AUS=0;
Sin50Hz=0;
Sin100Hz=0;
Sin200Hz=1;
switch_z1();
show_text(Text_Sinus_200Hz);
}
// Taste Sinus-100Hz gedrückt?
// Auf den Anfang von Zeile 1 schalten
// Text anzeigen
// Taste Sinus-200Hz gedrückt?
// Auf den Anfang von Zeile 1 schalten
// Text anzeigen
}
Bitte beim Zusammenstellen des Projektes die „Startup.A51 – Datei“ sowie die „LCD_CTRL_new.c“ – Datei nicht
vergessen!

Step 5:
Steuerung mit Display-Anzeige über 7 Drucktasten:
Sinus
Rechteck
AUS
50 Hz / 100 Hz / 200 Hz
50 Hz / 100 Hz / 200 Hz
Für die Rechteck-Erzeugung muss (da wir ja ein komplettes Byte von Port 1 an den D-A-Wandler übergeben)
folgendes Programm geschrieben werden:
Man gibt an Port P1 abwechselnd für die halbe Periodendauer den Wert Null (= 0x00) bzw. 255 (= 0xFF)
aus.
Da jedoch bei f = 50 Hz bereits eine Wartezeit von 10 Millisekunden erforderlich ist, muss man den Zahlentyp
beim Übergabeparameter auf „ unsigned int“ ändern (und kann damit Verzögerungszeiten bis 65 Millisekunden
erzielen).
Zu schreibende Funktion:
void Rechteckper (unsigned int Wert)
{ unsigned int y;
}
ausgang=0x00;
for(y=0;y

void Rechteckper(int Wert);
void Sinusper(char Wert);
void Tastenabfrage(void);
void zeit_s(void);
void zeit_l(void);
void lcd_com(void);
void lcd_ein(void);
void lcd_ini1(void);
void switch_z1(void);
void switch_z2(void);
void switch_z3(void);
void switch_z4(void);
void show_text(char *ptr);
void show_char(char *zeichen);
code unsigned char Sinus[72]=
{ 127,138,149,160,170,181,191,200,209,217,224,231,237,242,246,250,252,
253,254,253,252,250,246,242,237,231,224,217,209,200,191,181,170,160,
149,138,127,116,105,95,84,73,64,54,45,37,30,23,17,12,7,
4,2,1,0,1,2,4,7,12,17,23,30,37,45,54,64,73,84,95,105,116
};
code unsigned char Text_Aus[21]={"Generator AUS "};
code unsigned char Text_Sinus_50Hz[21]={"Sinus f = 50 Hz "};
code unsigned char Text_Sinus_100Hz[21]={"Sinus f = 100 Hz "};
code unsigned char Text_Sinus_200Hz[21]={"Sinus f = 200 Hz "};
code unsigned char Text_Rechteck_50Hz[21]={"Rechteck f = 50 Hz "};
code unsigned char Text_Rechteck_100Hz[21]={"Rechteck f = 100 Hz "};
code unsigned char Text_Rechteck_200Hz[21]={"Rechteck f = 200 Hz "};
void main(void)
{ lcd_ein();
lcd_ini1();
switch_z1();
show_text(Text_Aus);
AUS=1;
while(1)
{
while(AUS==1)
{ Tastenabfrage();
}
while(Sin50Hz==1)
{ Sinusper(82);
Tastenabfrage();
}
while(Sin100Hz==1)
{ Sinusper(36);
Tastenabfrage();
}
while(Sin200Hz==1)
{ Sinusper(13);
Tastenabfrage();
}
while(Rechteck50Hz==1)
{ Rechteckper(750);
Tastenabfrage();
}
while(Rechteck100Hz==1)
{ Rechteckper(375);
Tastenabfrage();
// Generator ausschalten
// Generator ausgeschaltet
// Sinus 50 Hz wird erzeugt
// Sinus 100 Hz wird erzeugt
// Sinus 200 Hz wird erzeugt
// Rechteck 50 Hz wird erzeugt
// Rechteck 50 Hz wird erzeugt

}
while(Rechteck200Hz==1)
{ Rechteckper(185);
Tastenabfrage();
}
// Rechteck 50 Hz wird erzeugt
}
}
void Sinusper(unsigned char Wert)
{ unsigned char x,y;
for(x=0;x

}
Rechteck50Hz=0;
Rechteck100Hz=0;
Rechteck200Hz=0;
switch_z1();
show_text(Text_Sinus_200Hz);
// Auf den Anfang von Zeile 1 schalten
// Text anzeigen
}
if(Taste_Rechteck_50Hz==0)
{ AUS=0;
Sin50Hz=0;
Sin100Hz=0;
Sin200Hz=0;
Rechteck50Hz=1;
Rechteck100Hz=0;
Rechteck200Hz=0;
switch_z1();
show_text(Text_Rechteck_50Hz);
}
if(Taste_Rechteck_100Hz==0)
{ AUS=0;
Sin50Hz=0;
Sin100Hz=0;
Sin200Hz=0;
Rechteck50Hz=0;
Rechteck100Hz=1;
Rechteck200Hz=0;
switch_z1();
show_text(Text_Rechteck_100Hz);
}
if(Taste_Rechteck_200Hz==0)
{ AUS=0;
Sin50Hz=0;
Sin100Hz=0;
Sin200Hz=0;
Rechteck50Hz=0;
Rechteck100Hz=0;
Rechteck200Hz=1;
switch_z1();
show_text(Text_Rechteck_200Hz);
}
// Rechteck 50Hz-Taste gedrückt?
// Auf den Anfang von Zeile 1 schalten
// Text anzeigen
// Rechteck 100Hz-Taste gedrückt?
// Auf den Anfang von Zeile 1 schalten
// Text anzeigen
// Rechteck 200Hz-Taste gedrückt?
// Auf den Anfang von Zeile 1 schalten
// Text anzeigen

Anhang: Listing des LCD-Steuerprogramms „LCD_CTRL_new.c“
/*----------------------------------------------------------------
LCD_CTRL_new.c
C-Programm-Modul zur Ausgabe von Texten auf dem LCD-Display
12.02.2006 / G. Kraus
-----------------------------------------------------------------*/
#include
#include
void zeit_s(void);
void zeit_l(void);
void lcd_com(void);
void lcd_ein(void);
void lcd_ini1(void);
void switch_z1(void);
void switch_z2(void);
void switch_z3(void);
void switch_z4(void);
void show_text(char *ptr);
void show_char(char *zeichen);
sfr ausg_lcd=0xF8;
sbit enable=ausg_lcd^4;
sbit RW_LCD=ausg_lcd^5;
sbit RS_LCD=ausg_lcd^6;
// Port 5 als Display-Ausgang
// Portpin P5.4 ist "enable"
// Portpin P5.5 ist "READ - WRITE"
// Portpin P5.6 ist "Register - Select"
/*-----------------------------------------------------------------------
Zusatzfunktionen
-------------------------------------------------------------------------*/
void zeit_s(void)
{
unsigned char x;
for(x=0;x

lcd_com();
ausg_lcd=0x08;
lcd_com();
ausg_lcd=0x00;
lcd_com();
ausg_lcd=0x08;
lcd_com();
ausg_lcd=0x00;
lcd_com();
ausg_lcd=0x01;
lcd_com();
zeit_l();
ausg_lcd=0x00;
lcd_com();
ausg_lcd=0x06;
lcd_com();
ausg_lcd=0x00;
lcd_com();
ausg_lcd=0x0c;
// losschicken
// Unteres Nibble für "4 Bit / 2 Zeilen / 5x7 dots"
// losschicken
// Oberes Nibble von "Display OFF"
// losschicken
// Unteres Nibble von "Display OFF"
// losschicken
// Oberes Nibble von "Clear all"
// losschicken
// Unteres Nibble von "Clear all"
// losschicken
// Beim Löschen ist hier eine lange Wartezeit nötig
/* Oberes Nibble von "Entry mode" (Cursor steht, Display
wandert nach rechts */
// losschicken
/* Unteres Nibble von "Entry mode" (Cursor steht, Display wandert
nach rechts */
// losschicken
// Oberes Nibble von "Display ON, Cursor OFF, Kein Blinken"
// losschicken
// Unteres Nibble von "Display ON, Cursor OFF, Kein Blinken"
}
lcd_com();
// losschicken
void lcd_com(void)
{ unsigned char x;
enable=1;
for(x=0;x

void switch_z3(void)
// Schalte auf Zeile 3 um und stelle den Cursor an den Anfang der Zeile
{ ausg_lcd=0x09; // Erforderliches Codewort hat als oberes Nibble "1001B" = 0x09
lcd_com();
// losschicken
ausg_lcd=0x04; // Erforderliches Codewort hat als unteres Nibble "0100B = 0x04
lcd_com();
// losschicken
}
void switch_z4(void)
// Schalte auf Zeile 4 um und stelle den Cursor an den Anfang der Zeile
{ ausg_lcd=0x0D; // Erforderliches Codewort hat als oberes Nibble "1101B" = 0x0D
lcd_com();
// losschicken
ausg_lcd=0x04; // Erforderliches Codewort hat als oberes Nibble "0100" = 0x04
lcd_com();
// losschicken
}
void show_text(char *ptr)
{
while(*ptr)
{
ausg_lcd=(*ptr/0x10)|0x40;
// Anzeige eines Textes, als Array vorgegeben
/* Startadresse des Arrays wird übergeben. Schleife wird solange
wiederholt, bis Code "0x00" (entspricht dem Zeichen "\0") gefunden
wird. */
/* Oberes Nibble des Zeichen-Bytes wird um 4 Stellen
nach rechts geschoben und anschließend um die
erforderlichen Steuersignale ergänzt. */
lcd_com(); // Oberes Nibble losschicken
ausg_lcd=(*ptr&0x0f)|0x40;
/* Unteres Nibble des Zeichen-Bytes wird durch
Löschen des oberen Nibbles gewonnen und
anschließend um die erforderlichen Steuersignale
ergänzt. */
lcd_com(); // Unteres Nibble losschicken
}
}
ptr++;
// Nächstes Zeichen des Arrays adressieren
void show_char(char *ptr)
{
ausg_lcd=(*ptr/0x10)|0x40;
lcd_com();
ausg_lcd=(*ptr&0x0f)|0x40;
// Anzeige eines einzigen ASCII-Zeichens. Adresse wird übergeben.
/* Oberes Nibble des Zeichen-Bytes wird um 4 Stellen nach
rechts geschoben und anschließend um die erforderlichen
Steuersignale (für Datenübertragung) ergänzt. */
// Oberes Nibble losschicken
/* Unteres Nibble des Zeichen-Bytes wird durch Löschen des
oberen Nibbles gewonnen und anschließend um die
erforderlichen Steuersignale (für Datenübertragung) ergänzt. */
}
lcd_com();
// Unteres Nibble losschicken