LCD Anzeige wird nicht gelöscht

[Danonino (Gast)]

Guten Abend zusammen,

ich arbeite mich gerade in das Thema µController ein.

Ich nutze einen ATMEGA 8 und das myAVR MK2 Board mit dem LCD Board.

Nun habe ich folgendes Programm geschrieben, welches mir einen Text auf 
dem LCD ausgibt.

Das Schreiben funktioniert.

#define F_CPU 10000000  // µController hat 1 MHZ

#include <avr/io.h>
#include <util/delay.h>


void lcd_cmd(char cmd)
{

PORTD &=(1<<PD2); //RS = 0 um ein Kommando zu senden
lcd_send(cmd); // Aufruf einer Funktion
}

void lcd_clear()
{
lcd_cmd(0x01); // Anzeige auf dem LCD löschen
_delay_ms(2);
}

void lcd_home()
{
lcd_cmd(0x02); // Zeiger auf die Anfangsposition
_delay_ms(2);
}

void lcd_on()
{
lcd_cmd(0x0E); // LCD anschalten
}

void lcd_off()
{
lcd_cmd(0x08); // LCD ausschalten
}

void lcd_send(char data)
{

char rs = PORTD; // Abfrage ob RS 0 oder 1

rs &= 4; // RS auf 1 setzen um Daten senden zu können

char tmp = data;
tmp &= 0xf0; // Erst die obere Bits aufbereiten und schicken
tmp|=rs;
PORTD = tmp; 
PORTD |= (1<<PD3);//0x08; // Enable aktivieren, so dass das Display diesen Befehl vom Bus lesen kann
_delay_ms(50);// Zeit fürs umschalten geben (50ms)
PORTD &= ~(1<<PD3);//PORTD = 0x00;  // Enable wieder auf NULL setzen
_delay_ms(5); // Zeit fürs umschalten geben


tmp = data;
tmp &=0x0f; // Anschließend die unteren Bits aufbereiten und schicken
tmp*=16;
tmp|=rs;
PORTD = tmp;
PORTD |= (1<<PD3);//0x08; // Enable aktivieren, so dass das Display diesen Befehl vom Bus lesen kann
_delay_ms(50);// Zeit fürs umschalten geben (50ms)
PORTD &= ~(1<<PD3);//PORTD = 0x00;  // Enable wieder auf NULL setzen
_delay_ms(5); // Zeit fürs umschalten geben

}

void lcd_write(char text)
{

PORTD|= (1<<PD2); //RS auf 1 setzen, um  Daten zu schicken
lcd_send(text);
}

void lcd_string(const char *data)
{
while(*data != '\0')
{
  lcd_send(*data++);
}
}

void lcd_init() // Initialisierung des LCD-Displays
{

DDRD = 0xFF; // PORTD wird für die Ansteuerung genutzt. PORTD = Ausgang
PORTD = 0; // PORTD  auf NULL setzen

_delay_ms(50); // Start Vorgang des Diplays abwarten 50ms

PORTD =0x20; // 4 Bit Modus nutzen
PORTD |= (1<<PD3);//0x08; // Enable aktivieren, so dass das Display diesen Befehl vom Bus lesen kann
_delay_ms(50);// Zeit fürs umschalten geben (50ms)
PORTD &= ~(1<<PD3);// Enable wieder auf NULL setzen
_delay_ms(5); // Zeit fürs umschalten geben

lcd_cmd(0x28); //Function Set schicken, 4 Bit Modus, 2 Zeilen Display, 5x7 Pixel
lcd_off(); // LCD ausschalten
lcd_clear(); // LCD Anzeige löschen
lcd_cmd(0x06); //Entry Mode Display on und Curser on
lcd_on(); // LCD einschalten
}


int main(void)
{

lcd_init();

/*
lcd_write('H');
lcd_write('a');
lcd_write('l');
lcd_write('l');
lcd_write('o');
*/
//lcd_string("Hallo Welt");
while(1)
{

lcd_write('H');
lcd_write('a');
lcd_write('l');
lcd_write('l');
lcd_write('o');

_delay_ms(5000);
lcd_clear();
_delay_ms(5000);

}

return 0;

}

Nun habe ich folgende Fragen,

1) Warum wird die Anzeige nicht gelöscht. Der Text "Hallo" bleibt stehen 
und nach ein paar Sekunden werden || angezeigt und dann erfolgt wieder 
"Hallo". Aber ich rufe doch die funktion lcd_clear() auf.
Wieso wird das nicht übernommen?


2) Wie kann ich verhindern, das der Text auch in der 2 Zeile angezeigt 
wird?

Möchte nun gerne verstehen, wie ich einzelne Zeichen(char) oder ganze 
Strings ans LCD übergeben kann und wie ich diese auch ändern kann.

Möchte danach gerne den Umgang mit dem ADC erlernen und mir die 
notwendigen Werte auf dem LCD anzeigen lassen.

Hoffe ihr könnt helfen. Schaue da gerade nicht mehr durch.

Danke

[holger (Gast)]

>void lcd_cmd(char cmd)
>{
>
>PORTD &=(1<<PD2); //RS = 0 um ein Kommando zu senden
>lcd_send(cmd); // Aufruf einer Funktion
>}

void lcd_cmd(char cmd)
{
  PORTD &= ~(1<<PD2); //RS = 0 um ein Kommando zu senden
  lcd_send(cmd); // Aufruf einer Funktion
}

Ein Wunder das das überhaupt funktioniert hat.

[Mike (Gast)]

Danonino schrieb:
> Möchte nun gerne verstehen, wie ich einzelne Zeichen(char) oder ganze
> Strings ans LCD übergeben kann und wie ich diese auch ändern kann.

Guck mal in deinen Code. Einzelne Zeichen gibtst du aus mit der von dir 
dauern verwendeten Funktion

void lcd_write(char text)

Einen String mit der Funktion

void lcd_string(const char *data)

[Danonino (Gast)]

Hallo Holger,

darüber hatte ich schon nachgedacht. Aber wenn ich ~ nutze funktioniert 
das Schreiben nicht mehr.

void lcd_cmd(char cmd)
{
  PORTD &= ~(1<<PD2); //RS = 0 um ein Kommando zu senden
  lcd_send(cmd); // Aufruf einer Funktion
}

Ist mein Aufruf denn falsch?

[Mike (Gast)]

Danonino schrieb:
> Hoffe ihr könnt helfen. Schaue da gerade nicht mehr durch.

Wenn du es dir ganz einfach machen willst, suchst du hier im Forum 
einfach mal nach Quellcode, mit dem das LCD Display benutzt wird.

Glaub mit - du bist nicht der erste, der das Ding benutzt. Es gibt 
direkt einen Artikel, der direkt deine Frage beantwortet (Beispiel 1) in
AVR-GCC-Tutorial/LCD-Ansteuerung

[holger (Gast)]

>void lcd_send(char data)
>{
>
>char rs = PORTD; // Abfrage ob RS 0 oder 1
>
>rs &= 4; // RS auf 1 setzen um Daten senden zu können

rs &= 4; // setzt RS nicht

rs |= (1<<PD2); // setzt RS

[Karl H. (kbuchegg)]

holger schrieb:
>>void lcd_send(char data)
>>{
>>
>>char rs = PORTD; // Abfrage ob RS 0 oder 1
>>
>>rs &= 4; // RS auf 1 setzen um Daten senden zu können
>
> rs &= 4; // setzt RS nicht
>
> rs |= (1<<PD2); // setzt RS

Das Original war schon richtig.
In lcd_send ist die Absicht nicht, RS zu setzen oder nicht zu setzen, 
sondern an dieser Stelle soll festgestellt werden, ob RS gesetzt ist 
oder nicht, damit der jeweilige Zustand dann in das auszugebende Byte 
wieder einkopiert werden kann, welches er mit

tmp|=rs;
PORTD = tmp;

dann ausgibt.


>  funktioniert das Schreiben nicht mehr.

welches Schreiben?
Das von Einzelzeichen oder das von Strings.
Das von Einzelzeichen muss nach wie vor funktioniern. Das Schreiben von 
Strings kann nicht funktionieren, weil hier (wie Mike bereits angemerkt 
hatte)

void lcd_string(const char *data)
{
while(*data != '\0')
{
  lcd_send(*data++);
}
}

die falsche Funktion benutzt wird. Die Ausgabe von auszugebenden Zeichen 
geht über die Funktion lcd_write und nicht über lcd_send. Also muss es

void lcd_string(const char *data)
{
  while(*data != '\0')
  {
    lcd_write(*data++);
  }
}

heißen.

Und formatier deinen Code besser!
Einrückungen sind nicht Selbstzweck.
Die Verwendung der 4 hier

rs &= 4;

ist inakzeptabel. Überall anders hast du (1<<PD2) benutzt. Warum nicht 
hier? Dann würde man auch aus 5 Schritten Entfernung erkennen können, 
was hier wirklich passiert - nämlich den aktuell eingestellten Zustand 
der RS Leitung auf PD2 abzufragen. Was dann auch bei notwendigen 
Änderungen, wie zb das Leitungen auf andere Pins gelegt werden müssen, 
sofort ins Auge springen würde.