Fehler beim Schreiben einer LCD Library auf ATmega16

[Sven S. (nutellamann)]

Hallo,

für ein Projekt in der Schule muss ich ein LCD zum laufen bringen. Die 
Software soll keine fertigen Librarys verwenden, die nicht zum AVR-GCC 
gehören.

Ich habe hier das Tutorial zum LCD gelesen und auch das Datenblatt von 
Hitachi 
http://www.alldatasheet.com/datasheet-pdf/pdf/63673/HITACHI/HD44780.html, 
weil das LCD HD44780 kompatibel ist. Aufrgund der Aufschrift hinten 
drauf (1602A) schließe ich darauf, dass der im Datenblatt auf Seite 18 
gemeinte Zeichensatz verwendet wird.

Das LCD funktioniert, ich habe es mit einer Hex Datei aus dem Internet 
getestet, am Kontrast oder der Verbindung wird es also nicht liegen.


Mein Programm sieht so aus:

#include <avr/io.h>
#include <util/delay.h>
/* Connections:
 *
 *  D4->PORTD0
 *  D5->PORTD1
 *  D6->PORTD2
 *  D7->PORTD3
 *  E-> PORTD4
 *  RW->PORTD5
 *  RS->PORTD6
 */
#define LCD_DATA_PORT PORTD
#define E   PD4
#define RW  PD5
#define RS  PD6

void e_state(void)
{
  _delay_us(20);
  LCD_DATA_PORT|=(1<<E);
  _delay_us(20);
  LCD_DATA_PORT&=~(1<<E);
}

void write_data(int input)
{
  int high_bit,low_bit;
  LCD_DATA_PORT|=(1<<RS); //signal to write chars on display
  high_bit=(input&0xF0);   //get the higher 4 bit
  low_bit=(input&0x0F);    //get the lower 4 bit
  LCD_DATA_PORT=high_bit;  //send the higher 4 bit
  e_state();
  LCD_DATA_PORT=low_bit;   //send the lower 4 bit
  e_state();
}

void write_command(int input)
{
  int high_bit,low_bit;
  LCD_DATA_PORT&=~(1<<RS);  //signal to write command
  high_bit=(input&0xF0);   //get the higher 4 bit
  low_bit=(input&0x0F);    //get the lower 4 bit
  LCD_DATA_PORT=high_bit;  //send the higher 4 bit
  e_state();
  LCD_DATA_PORT=low_bit;   //send the lower 4 bit
  e_state();
}

void send_string(char input)
{
  int output;
  output=(int)input;
  write_data(output);
}

void split_string(char *input)
{
  while(*input!='\0')
  {
    send_string(*input++);
  }
}

void init_LCD(void)
{
  _delay_us(100);         //startup time
  write_command(0b00110000);//8-Bit mode
  _delay_us(45);
  write_command(0b00110000);//8-Bit mode
  _delay_us(45);
  write_command(0b00110000);//8-Bit mode
  _delay_us(45);
  write_command(0b00101000);//4-Bit mode 2 line display 5x7 ont type
  _delay_us(45);
  write_command(0b00001111);//Display on, curser on, curser blink
  _delay_us(45);
  write_command(0b00000001);//curser auto increment
  _delay_us(45);
}

void clear_lcd(void)
{
     write_command(0b00000001);//clear
  _delay_us(45);
}

void home_lcd(void)
{
     write_command(0b00000010);//home position
  _delay_us(45);
}

void goto_xy(int x,int y)
{
  if(y==1)
  {
    write_command(0b10000000+0b00000000+x);
  }
  if(y==2)
  {
    write_command(0b10000000+0b01000000+x);
  }
}

int main(void)
{
  DDRD=0xFF;
  init_LCD();
  while(1)
  {
    //split_string("TEST");
    //_delay_ms(2000);
    //split_string("LCD123");
    //_delay_ms(2000);
    write_data(0b01001000);//write H
    _delay_us(50);
  }
}

Das Display zeigt nichts an.

Kann mir jemand sagen, wo da der Fehler im Programm liegt?

Hier noch der Link zum LCD:
http://www.ebay.de/itm/HD44780-1602-LCD-Module-Display-Anzeigen-2X16-Zeichen-/250803268440

[Jim M. (turboj)]

Hier fehlt was entscheidendes:

void write_data(int input)
{
  int high_bit,low_bit;
  LCD_DATA_PORT|=(1<<RS); //signal to write chars on display
  high_bit=(input&0xF0);   //get the higher 4 bit
  low_bit=(input&0x0F);    //get the lower 4 bit
  LCD_DATA_PORT=high_bit;  //send the higher 4 bit
  e_state();
  LCD_DATA_PORT=low_bit;   //send the lower 4 bit
  e_state();
}

void write_command(int input)
{
  int high_bit,low_bit;
  LCD_DATA_PORT&=~(1<<RS);  //signal to write command
  high_bit=(input&0xF0);   //get the higher 4 bit
  low_bit=(input&0x0F);    //get the lower 4 bit
  LCD_DATA_PORT=high_bit;  //send the higher 4 bit
  e_state();
  LCD_DATA_PORT=low_bit;   //send the lower 4 bit
  e_state();
}

Hint:
In welchem Nibble möchtest Du die Daten haben, in welchem sendest Du sie 
aus?

[Peter D. (peda)]

Sven S. schrieb:
> Kann mir jemand sagen, wo da der Fehler im Programm liegt?

Beim Init kannst Du noch kein Write_Command nehmen, sondern nur 
Write_Nibble.

Write_Command setzt voraus, daß Du bereits im 4-Bit Mode bist, aber das 
ist ja noch unbestimmt. Und spätestens nach der Schaltung in 8-Bit bist 
Du es definitiv nicht mehr.

[Sven S. (nutellamann)]

Vielen Dank schon mal für die Antworten.

>Beim Init kannst Du noch kein Write_Command nehmen, sondern nur
>Write_Nibble.

>Write_Command setzt voraus, daß Du bereits im 4-Bit Mode bist, aber das
>ist ja noch unbestimmt. Und spätestens nach der Schaltung in 8-Bit bist
>Du es definitiv nicht mehr.

Ok ich habe es mal so versucht:

void init_LCD(void)
{
  _delay_us(100);         //startup time
  LCD_DATA_PORT=0b0010;//4-Bit mode
  _delay_us(45);
  LCD_DATA_PORT=0b0010;//4-Bit mode
  _delay_us(45);
  LCD_DATA_PORT=0b1000;//two line display with 5x8 font size
  _delay_us(45);
  LCD_DATA_PORT=0b0000;
  _delay_us(45);
  LCD_DATA_PORT=0b1111;//Display on, curser on, curser blink
  _delay_us(45);
  LCD_DATA_PORT=0b0000;
  _delay_us(45);
  LCD_DATA_PORT=0b0001;//clear display, cursor on line 1
  _delay_us(45);
  LCD_DATA_PORT=0b0000;
  _delay_us(45);
  LCD_DATA_PORT=0b0110;//curser auto increment
  _delay_us(45);
}

>Hint:
>In welchem Nibble möchtest Du die Daten haben, in welchem sendest Du sie
>aus?

Nach der Hardware sende ich die Daten im unteren Nibble, Softwaremäßig 
bin ich mir da nicht so sicher, aber wenn Du so fragst ist es sicher 
anders herum ;)

Wegen der Unsicherheit, welches Nibble nun angesprochen wird, habe ich 
auch folgendes versucht:

void init_LCD(void)
{
  _delay_us(100);         //startup time
  LCD_DATA_PORT=0b00000010;//4-Bit mode
  _delay_us(45);
  LCD_DATA_PORT=0b00000010;//4-Bit mode
  _delay_us(45);
  LCD_DATA_PORT=0b00001000;//two line display with 5x8 font size
  _delay_us(45);
  LCD_DATA_PORT=0b00000000;
  _delay_us(45);
  LCD_DATA_PORT=0b00001111;//Display on, curser on, curser blink
  _delay_us(45);
  LCD_DATA_PORT=0b00000000;
  _delay_us(45);
  LCD_DATA_PORT=0b00000001;//clear display, curser on line 1
  _delay_us(45);
  LCD_DATA_PORT=0b00000000;
  _delay_us(45);
  LCD_DATA_PORT=0b00000110;//curser auto increment
  _delay_us(45);
}

Bringt mich aber auch nicht weiter, könnte es sein, dass ich in 
write_data() und write_command irgendwo eine 4-Bit Verschiebung einbauen 
muss?

[Lötlackl *. (pappnase)]

Sven S. schrieb:
> könnte es sein, dass ich in
> write_data() und write_command irgendwo eine 4-Bit Verschiebung einbauen
> muss?

Oh ja, sehe ich gerade. Mal angenommen PD0...3 seien die Datenleitungen 
dann sollte es so aussehen.

high_bit=(input&0xF0)>>4;   //get the higher 4 bit

mfg

[Sven S. (nutellamann)]

** Lötlackl schrieb:
> Oh ja, sehe ich gerade. Mal angenommen PD0...3 seien die Datenleitungen
> dann sollte es so aussehen.high_bit=(input&0xF0)>>4;   //get the higher 4 bit
> mfg

Ok jetzt werden die Daten auf die Bits 0...3 geschoben wie es sein soll, 
weil ich diese Ausgänge ja an die Datenleitungen des LCDs angeschlossen 
habe.

Meine Initialisierung habe ich mit dem LCD Simulator 
http://www.geocities.com/dinceraydin/djlcdsim/djlcdsim.html verifiziert, 
die funktioniert soweit.

Jetzt sieht das Programm so aus:

#include <avr/io.h>
#include <util/delay.h>
/* Connections:
 *
 *   D4->PORTD0
 *  D5->PORTD1
 *  D6->PORTD2
 *  D7->PORTD3
 *  E-> PORTD4
 *  RW->PORTD6
 *  RS->PORTD6
 */
#define LCD_DATA_PORT PORTD
#define E   PD4
#define RW  PD5
#define RS  PD6

void e_state(void)
{
  _delay_us(20);
  LCD_DATA_PORT|=(1<<E);
  _delay_us(20);
  LCD_DATA_PORT&=~(1<<E);
}

void write_data(int input)
{
  int high_bit,low_bit;
  LCD_DATA_PORT|=(1<<RS); //signal to write chars on display
  high_bit=((input&0xF0)>>4);   //get the higher 4 bit
  low_bit=((input&0x0F)>>4);    //get the lower 4 bit
  LCD_DATA_PORT=high_bit;  //send the higher 4 bit
  e_state();
  LCD_DATA_PORT=low_bit;   //send the lower 4 bit
  e_state();
}

void write_command(int input)
{
  int high_bit,low_bit;
  LCD_DATA_PORT&=~(1<<RS);  //signal to write command
  high_bit=((input&0xF0)>>4);   //get the higher 4 bit
  low_bit=((input&0x0F)>>4);    //get the lower 4 bit
  LCD_DATA_PORT=high_bit;  //send the higher 4 bit
  e_state();
  LCD_DATA_PORT=low_bit;   //send the lower 4 bit
  e_state();
}

void send_string(char input)
{
  int output;
  output=(int)input;
  write_data(output);
}

void split_string(char *input)
{
  while(*input!='\0')
  {
    send_string(*input++);
  }
}

void init_LCD(void)
{
  _delay_us(100);         //startup time
  LCD_DATA_PORT=0b00000010;//4-Bit mode
  _delay_us(45);
  LCD_DATA_PORT=0b00000000;//two line display with 5x8 font size
  _delay_us(45);
  LCD_DATA_PORT=0b00001000;
  _delay_us(45);
  LCD_DATA_PORT=0b00000000;//Display on, curser on, curser blink
  _delay_us(45);
  LCD_DATA_PORT=0b00001111;
  _delay_us(45);
  LCD_DATA_PORT=0b00000000;//curser auto increment
  _delay_us(45);
  LCD_DATA_PORT=0b00000110;
  _delay_us(45);
}

void clear_lcd(void)
{
     write_command(0b00000001);//clear
  _delay_us(45);
}

void home_lcd(void)
{
     write_command(0b00000010);//home position
  _delay_us(45);
}

void goto_xy(int x,int y)
{
  if(y==1)
  {
    write_command(0b10000000+0b00000000+x);
  }
  if(y==2)
  {
    write_command(0b10000000+0b01000000+x);
  }
}

int main(void)
{
  DDRD=0xFF;
  init_LCD();
  while(1)
  {
    //split_string("TEST");
    //_delay_ms(2000);
    //split_string("LCD123");
    LCD_DATA_PORT=0b01001000;//write H
    _delay_us(50);
  }
}

Ist es jetzt nicht so, dass in write_data, wenn die 4 Bit des oberen- 
bzw. unteren Nibbles auf den PORTD gegeben werden, das RS Bit mit 0 
gesetzt wird statt 1 zu bleiben, damit die Ausgabe als Zeichen erkannt 
wird?


Aus der Überlegung folgere ich, dass ich normalerweise das RS Bit OR 
Verknüpft hinzufügen muss wie hier:

void write_data(int input)
{
  int high_bit,low_bit;
  LCD_DATA_PORT|=(1<<RS); //signal to write chars on display
  high_bit=((input&0xF0)>>4);   //get the higher 4 bit
  low_bit=((input&0x0F)>>4);    //get the lower 4 bit
  LCD_DATA_PORT=high_bit|(1<<RS);  //send the higher 4 bit
  e_state();
  LCD_DATA_PORT=low_bit|(1<<RS);   //send the lower 4 bit
  e_state();
}

Danach kann ich aber immer noch keine Ausgabe sehen :(

[Karl H. (kbuchegg)]

>  low_bit=((input&0x0F)>>4);    //get the lower 4 bit

Und was soll da jetzt noch übrig bleiben, wenn du dir die 4 Bits, die du 
dir frei maskiert hast, jetzt nach rechts rausschiebst?

Irgendwie scheint dir noch wirklich klar zu sein, was du da eigentlich 
erreichen musst. Oder du probierst einfach irgendwas ohne darüber 
nachzudenken, was du da eigentlich tust.
WObei: die Sache mit dem RS hast du gut erkannt.

[Sven S. (nutellamann)]

Karl Heinz Buchegger schrieb:
> Und was soll da jetzt noch übrig bleiben, wenn du dir die 4 Bits, die du
> dir frei maskiert hast, jetzt nach rechts rausschiebst?

Ich versuche schon, das zu verstehen ;)

Also liege ich richtig, dass nach der Maskierung mit 0x0F das Ergebnis 
immer 0b0000xxxx ist und dann mit der Verschiebung nach rechts somit 
0b00000000 = 0x00 ergibt? Damit wäre es tatsächlich sinnfrei dies zu 
machen :)

[Karl H. (kbuchegg)]

Sven S. schrieb:
> Karl Heinz Buchegger schrieb:
>> Und was soll da jetzt noch übrig bleiben, wenn du dir die 4 Bits, die du
>> dir frei maskiert hast, jetzt nach rechts rausschiebst?
>
> Ich versuche schon, das zu verstehen ;)
>
> Also liege ich richtig, dass nach der Maskierung mit 0x0F das Ergebnis
> immer 0b0000xxxx ist

Genau.

Wenn du µC programmieren willst, dann muss dir die Wirkung von Und und 
Oder Operationen in Fleisch und Blut übergehen.

Eine binäre Und-Operation ist wie ein Sieb. Dort wo ein 1 Bit sitzt, 
dort ist das Sieb offen und die 'Bits' können durch. Dort wo ein 0-Bit 
sitzt kommt nichts durch und im Ergebnis taucht an dieser Stelle ein 0 
Bit auf


       abcdefgh
       11110000         binäres Und
      ----------

       abcd0000

da du die 4 Bits an der niederwertigen Position brauchst, musst du sie 
um 4 stellen nach rechts verschieben.

       abcd0000        >> 4

       0000abcd

und du hast sie an den Positionen um sie auszugeben.


Die niederwertigen Bits

       abcdefgh
       00001111         binäres Und
     -----------

       0000efgh

diese 4 Bits sind aber schon an der richtigen Position. Da braucht nix 
verschoben werden.

[Karl H. (kbuchegg)]

Und lern über Datentypen.
int willst du nicht für Bytes benutzen.

Auf Byteebene ist der Datentyp der Wahl ein uint8_t und kein int. Wozu 
den AVR in 16 Bit Arithmetik reinjagen, wenn du nur an 8 Bit 
interessiert bist, und dir ein eventuelles 'Vorzeichen' nicht in die 
Quere kommen soll. Ein uint8_t hat als unsigned Wert per Definition kein 
Vorzeichen. Alle Bits sind einfach nur Bits.

[Sven S. (nutellamann)]

Ok nochmals Danke. Ich mache morgen mal dran weiter in der Hoffnung, 
damit endlich fertig werden zu können.

[Karl H. (kbuchegg)]

Da du Code hast, der funktioniert:

Es schadet auch nicht, diesen Code zu studieren und sich anzusehen, wie 
andere die Sache machen. Niemand sagt, dass du diesen Code übernehmen 
musst. Aber man kann viel daraus lernen, indem man anderer Leute Code 
studiert und sich überlegt, warum sie manche Dinge genau so machen, wie 
sie sie machen.

[Sven S. (nutellamann)]

So ich habe es endlich geschafft zum laufen zu bringen :) In der 
Initialisierung waren die Pausen zwischen den Befehlen zu kurz und ein 
paar Kleinigkeiten habe ich noch geändert. Allerdings habe ich auch 
feststellen müssen, dass im Displaycontroller trotz der Aufschrift 1602A 
nur der kleinere Zeichensatz enthalten ist, in dem auch Japanisch o.ä zu 
finden ist.

Vielen Dank nochmals an alle, die mir geholfen haben.

#include <avr/io.h>
#include <util/delay.h>
/* Connections:
 *
 *  D4->PORTD0
 *  D5->PORTD1
 *  D6->PORTD2
 *  D7->PORTD3
 *  E-> PORTD4
 *  RW->PORTD6
 *  RS->PORTD6
 */
#define LCD_DATA_PORT PORTD
#define E   PD4
#define RW  PD5
#define RS  PD6

void e_state(void)
{
  _delay_us(50);
  LCD_DATA_PORT|=(1<<E);
  _delay_us(20);
  LCD_DATA_PORT&=~(1<<E);
  _delay_us(50);
}
void write_data(uint8_t input)
{
  uint8_t high_bit,low_bit;
  high_bit=((input&0xF0)>>4);     //get the higher 4 bit
  low_bit=(input&0x0F);        //get the lower 4 bit
  LCD_DATA_PORT=high_bit|(1<<RS);  //send the higher 4 bit and signal to write chars on display
  e_state();
  LCD_DATA_PORT=low_bit|(1<<RS);   //send the lower 4 bit  and signal to write chars on display
  e_state();
}

void write_command(uint8_t input)
{
  uint8_t high_bit,low_bit;
  LCD_DATA_PORT&=~(1<<RS);  //signal to write command
  high_bit=((input&0xF0)>>4);   //get the higher 4 bit
  low_bit=(input&0x0F);    //get the lower 4 bit
  LCD_DATA_PORT=high_bit;  //send the higher 4 bit
  e_state();
  LCD_DATA_PORT=low_bit;   //send the lower 4 bit
  e_state();
}

void send_string(char input)
{
  uint8_t output;
  output=(uint8_t)input;
  write_data(output);
}

void split_string(char *input)
{
  while(*input!='\0')
  {
    send_string(*input++);
  }
}

void init_LCD(void)
{
  LCD_DATA_PORT &=~0xFF;  //set all outputs to 0
  _delay_ms(30);         //startup time
  LCD_DATA_PORT=0b00000010;//4-Bit mode
  e_state();
  LCD_DATA_PORT=0b00000010;//two line display with 5x8 font size
  e_state();
  LCD_DATA_PORT=0b00001000;
  e_state();
  LCD_DATA_PORT=0b00000000;//Display on, curser on, curser blink
  e_state();
  LCD_DATA_PORT=0b00001111;
  e_state();
  LCD_DATA_PORT=0b00000000;//clear display and return to home position
  e_state();
  LCD_DATA_PORT=0b00000001;
  e_state();
  LCD_DATA_PORT=0b00000000;//curser auto increment scrolling on
  e_state();
  LCD_DATA_PORT=0b00000111;
  e_state();
}

void clear_lcd(void)
{
  write_command(0b00000001);//clear
  _delay_ms(10);
}

void home_lcd(void)
{
  write_command(0b00000010);//home position
  _delay_ms(10);
}

void goto_xy(uint8_t x,uint8_t y)
{
  if(y==1)
  {
    write_command(0b10000000+0b00000000+x);
    _delay_us(50);
  }
  if(y==2)
  {
    write_command(0b10000000+0b01000000+x);
    _delay_us(50);
  }
}


int main(void)
{
  DDRD=0xFF;
  init_LCD();
  while(1)
  {
    home_lcd();
    clear_lcd();
    split_string("Raupe");
    _delay_ms(500);
    goto_xy(0,2);
    split_string("haha");
    _delay_ms(500);
    goto_xy(7,2);
    split_string("Auto");
    _delay_ms(5000);
    clear_lcd();
    _delay_ms(5000);
  }
}

[m.n. (Gast)]

Bevor Du die Routinen Deinem Lehrer zeigst, ändere bitte noch die 
Strings in main() auf:
"Mama"
"Papa"
"Auto"
 :-)

[Karl H. (kbuchegg)]

Ist ja interessant.

Da gibt es eine Funktion namens 'send_string'

void send_string(char input)
{
  uint8_t output;
  output=(uint8_t)input;
  write_data(output);
}

die einen einzelnen Character am LCD anzeigt aber sicher keinen String. 
Klarer Fall von 'Verwirre deinen Benutzer mit nicht passenden 
Funktionsnamen'.


Dafür gibt es eine Funktion namens 'split_string', die dem Namen nach 
einen String in Einzelteile zerlegt (splittet), aber dem Code nach den 
String auf dem LCD ausgibt

void split_string(char *input)
{
  while(*input!='\0')
  {
    send_string(*input++);
  }
}

Weiter so! Du hast das Prinzip der Arbeitsplatzsicherung durch 
unverständlichen und falsch benannten Code komplett richtig verstanden!
Genau so macht man sich in einer Firma unentbehrlich! Dein Pech nur, 
dass LCD Funktionen jetzt nicht Raketentechnik sind und in ein paar 
Minuten richtig gestellt werden können. Aber die Grundidee ist 
ausbaufähig! Ein Funktionsname soll auf keinen Fall einen intuitiven 
Rückschluss darauf zulassen, was die Funktion macht.

[Karl H. (kbuchegg)]

Und PS:

Die Zusammenfassung von 4 Bits, so wie sie in deinem Fall gemacht wird, 
nennt man in der EDV ein 'Nibble'.
Ein Byte besteht also aus 8 Bit. Es besteht aber auch aus 2 Nibbles - 
einem höherwertigem Nibble und einem niederwertigem Nibble.

die 8 Bit eines Bytes     abcdefgh
                          |  ||  |
                          |  |+--+ Die 4 Bits des niederwertigen Nibbles
                          |  |     oder auch einfach 'Low-Nibble'
                          |  |
                          +--+ Die 4 Bit des höherwertigen Nibbles
                               oder auch einfach 'High-Nibble' genannt.

[Karl H. (kbuchegg)]

Sven S. schrieb:

> void init_LCD(void)
> {
>   LCD_DATA_PORT &=~0xFF;  //set all outputs to 0
>   _delay_ms(30);         //startup time
>   LCD_DATA_PORT=0b00000010;//4-Bit mode
>   e_state();


Ab hier funktioniert das ganze zwar per Design, ist aber höchst 
missverständlich.
Ab dem Moment, ab dem du erfolgreich auf 4-Bit Interface umgeschaltet 
hast, kannst du nicht mehr Kommandos an das LCD geben, in dem du die 8 
Bit des Kommandos an die Datenleitungen legst und mit dem E-Pin 
wackelst! Ab dem Moment des erfolgreichen Umschaltens werden Kommandos 
ausschliesslich über die Funktion write_command abgewickelt, die dann 
das Kommando korrekt in 2 Happen (wegen 4 Bit Interface) an das LCD 
weitergibt. Ab hier diese Zerlegung selbst zu machen, ist ein 'Ask for 
trouble'.

>   LCD_DATA_PORT=0b00000010;//two line display with 5x8 font size
>   e_state();
>   LCD_DATA_PORT=0b00001000;
>   e_state();
>   LCD_DATA_PORT=0b00000000;//Display on, curser on, curser blink
>   e_state();
>   LCD_DATA_PORT=0b00001111;
>   e_state();

>   LCD_DATA_PORT=0b00000000;//clear display and return to home position
>   e_state();
>   LCD_DATA_PORT=0b00000001;
>   e_state();

Huch. Für das 'clear Display' und 'Cursor Home' hast du eigene 
Funktionen. Warum benutzt du sie nicht?


Der kritische Punkt in der Initialisierung des LCD ist das Umschalten 
auf 4 Bit Modus.(*) Danach bedeutet Initialisieren nur noch Kommandos 
über den offiziellen Weg der 'Kommando-Senden' Funktion an das LCD 
geben, so dass jede Funktionalität einen definierten, dir genehmen Wert 
einnimmt. Daztu hast du die Funktion, damit sich die um die Details wie 
zb die Zerlegung in Nibbles, kümmert.


(*) Und NB. Dein Umschaltcode ist eigentlich falsch. Laut Datenblatt ist 
zum sauberen Umschalten in den 4-Bit Modus mehr zu tun als du da tust. 
Es reicht nicht, wenn du das LCD aus dem 'Strom-an' Zustand auf 4 Bit 
umschalten kannst. Die Umschaltung muss aus JEDEM Zustand heraus 
klappen. Die dokumentierte Sequenz in den Datenblättern kann das und die 
wird sicherlich auch in deiner Code-Vorlage benutzt. Ich sagte schon: 
studier wie andere das machen und überleg dir, warum deren Code so 
aussieht wie er aussieht. Man kann viel lernen, indem man sich anderer 
Leute Code ansieht und studiert.

[Sven S. (nutellamann)]

Hallo,

das mit dem missverständlichen Namen der Funktion habe ich noch 
geändert, ich hatte mich einfach so gefreut, dass es endlich 
funktionierte ;D

Karl Heinz Buchegger schrieb:
> Huch. Für das 'clear Display' und 'Cursor Home' hast du eigene
> Funktionen. Warum benutzt du sie nicht?

Da habe ich die Funktionen nicht benutzt, weil weiter oben ja die Rede 
davon war, ich könne in der Initialisierung noch nicht auf die 
write_command() Funktion zurückgreifen.

Peter Dannegger schrieb:
> eim Init kannst Du noch kein Write_Command nehmen, sondern nur
> Write_Nibble.

Karl Heinz Buchegger schrieb:
> (*) Und NB. Dein Umschaltcode ist eigentlich falsch. Laut Datenblatt ist
> zum sauberen Umschalten in den 4-Bit Modus mehr zu tun als du da tust.
> Es reicht nicht, wenn du das LCD aus dem 'Strom-an' Zustand auf 4 Bit
> umschalten kannst. Die Umschaltung muss aus JEDEM Zustand heraus
> klappen.

Da habe ich was gelesen, man müsse da drei mal hintereinander die 
Umschaltsequenz benutzen, aber ohne scheint es ja auch zu funktionieren.
Mein "Referenz-Quelltext" ist übrigns von hier: 
http://extremeelectronics.co.in/avr-tutorials/using-lcd-module-with-avrs/ 
Das ist finde ich ein ziemliches Durcheinander, sodass die Quelltexte 
nicht soo hilfreich waren und ich mich mehr an den Datenblättern 
orientiert habe.

Karl Heinz Buchegger schrieb:
> Ab hier funktioniert das ganze zwar per Design, ist aber höchst
> missverständlich.
> Ab dem Moment, ab dem du erfolgreich auf 4-Bit Interface umgeschaltet
> hast, kannst du nicht mehr Kommandos an das LCD geben, in dem du die 8
> Bit des Kommandos an die Datenleitungen legst und mit dem E-Pin
> wackelst!

Ok da könnte ich ja noch versuchen, über die Bitverschiebung zu 
arbeiten, wie auch in der write_command() und write_data() Funktion?

Karl Heinz Buchegger schrieb:
> Die Umschaltung muss aus JEDEM Zustand heraus
> klappen.

Was wäre denn beispielsweise ein Szenario, in dem das nicht 
funktionieren würde?

[Karl H. (kbuchegg)]

Sven S. schrieb:

> Was wäre denn beispielsweise ein Szenario, in dem das nicht
> funktionieren würde?

Zum Beispiel wenn das LCD schon im 4-Bit Modus ist :-)

Zum Beispiel wenn du einen Prozessor-Reset machst, just in dem Moment in 
dem von einem LCD Kommando das erste Nibble schon übertragen wurde und 
das zweite noch nicht.

[Sven S. (nutellamann)]

Karl Heinz Buchegger schrieb:
> Zum Beispiel wenn du einen Prozessor-Reset machst, just in dem Moment in
> dem von einem LCD Kommando das erste Nibble schon übertragen wurde und
> das zweite noch nicht.

Ok das überrascht mich jetzt, ich habe noch über keine andere 
Möglichkeit gelsesen, außer die Nibbles hintereinander zu senden. 
Vielleicht habe ich ja was übersehen, ich schau noch mal nach.

Hier lernt man echt mehr als in der Schule thumbs up

[Karl H. (kbuchegg)]

Sven S. schrieb:
> Karl Heinz Buchegger schrieb:
>> Zum Beispiel wenn du einen Prozessor-Reset machst, just in dem Moment in
>> dem von einem LCD Kommando das erste Nibble schon übertragen wurde und
>> das zweite noch nicht.
>
> Ok das überrascht mich jetzt, ich habe noch über keine andere
> Möglichkeit gelsesen, außer die Nibbles hintereinander zu senden.

Darum gehts aber auch gar nicht.

Es geht darum, dass dann das LCD auf das 2.te Nibble wartet um das 
Kommando zu vervollständigen.
Da kommt dann auch was. Nämlich dein erstes Byte mit dem du nach dem 
Prozessorreset versuchst, das LCD wieder in einen 4 Bit Modus zu 
versetzen.

[Sven S. (nutellamann)]

Karl Heinz Buchegger schrieb:
> Darum gehts aber auch gar nicht.
>
> Es geht darum, dass dann das LCD auf das 2.te Nibble wartet um das
> Kommando zu vervollständigen.
> Da kommt dann auch was. Nämlich dein erstes Byte mit dem du nach dem
> Prozessorreset versuchst, das LCD wieder in einen 4 Bit Modus zu
> versetzen.

Ah der Reset des Displays hat gefehlt, wobei dies 3 Mal hintereinander 
gemacht werden sollte.

LCD_DATA_PORT=0x30;

Damit ist die Initialisierung weniger verwirrend hinsichtlich der 4 Bit 
Datenleitung und dem 8 Bit Wert am Port des Mikrocontrollers.

LCD_DATA_PORT=(LCD_DATA_PORT&0x0F)|0b1100;