Initalisierung eines LCD Displays

[Sabi (Gast)]

Hallo Jungs,
ich hab ein Problem mit der Initalisierung eines einfachen 2*16 
LCD-Displays. Habe auch schon das halbe Forum durchforstet und einige 
Dinge ausprobiert.

Bin schon 2 Tage dran um rauszubekommen wieso sich  das schöne Ding 
nicht richtig ansteuern läßt. :) Das Display ist aufjedenfall super in 
Ordnung, konnte es mit einem Arduino ohne Probleme ansteuern.

Folgendes Display wird verwendet:

http://www.watterott.com/de/RGB-backlight-positive-LCD-16x2-extras-black-on-RGB

Aber jetzt benutze ich einen Infineon XC888 und bekomme einfach keinen 
Text darauf. Ich werde euch meinen Code mal anhängen.

Wäre super wenn mal einer von euch da drüber schauen könnte und mir 
meinen Fehler aufzeigt.

Grüßle

#include <xc888.h>
//Function declarations
void port_init(void);
void delay(int);
void lcdinit(void);
void writecmd(int);
void writedata(char);
void ReturnHome(void);
void wait(unsigned int time);
//*******************
//Pin description
/*
P4.4 to P4.7 is data bus
P4.0 is RS
P4.1 is R/W 
P4.2 is E
*/
//********************
// Defines Pins
sbit RS = 0xC9; // Command or Data
sbit E  = 0xCA; // Enable Port
// R/W dauerhaft auf Masse
// ***********************************************************
// Main program
//
#define P4 P4_DATA
void main(void)
{
   port_init();                                     //Make all ports zero
   lcdinit();                                      //Initilize LCD
   writedata('H');                                 //write
   writedata('e');                                 //write
   writedata('l');                                 //write
   writedata('l');                                 //write
   writedata('o');                                 //write
   ReturnHome();                                   //Return to 0 position      
  while(1)
  {;  
  }
}
void lcdinit(void)
{
  ///////////// Reset process from datasheet /////////
   wait(450);

   P4 &= 0x0F;       // Make P2.4 to P2.7 zero
   P4 |= (0x30&0xF0);    // Write 0x3
  
   E  = 1;               // => E = 1
   delay(250);
  
   E  = 0;               // => E = 0
   delay(250);

   P4 &= 0x0F;       // Make P2.4 to P2.7 zero
   P4 |= (0x30&0xF0);    // Write 0x3
  
   E  = 1;               // => E = 1
   delay(250);
  
   E  = 0;               // => E = 0
   delay(250);
   delay(300);
   
   P4 &= 0x0F;       // Make P2.4 to P2.7 zero
   P4 |= (0x30&0xF0);    // Write 0x3
  
   E  = 1;               // => E = 1
   delay(250);
   E  = 0;               // => E = 0
   delay(250);

     delay(650);

   P4 &= 0x0F;       // Make P2.4 to P2.7 zero
   P4 |= (0x20&0xF0);    // Write 0x2
  
   E  = 1;               // => E = 1
   delay(250);
   E  = 0;               // => E = 0
   delay(250);
   delay(650);

  /////////////////////////////////////////////////////
   wait (1);
   writecmd(0x28);    //function set
   wait (1);
   writecmd(0x0c);    //display on,cursor off,blink off
   wait (1);
   writecmd(0x01);    //clear display
   wait (3);
   writecmd(0x06);    //entry mode, set increment
   wait (30);
}

void port_init(void)
{
P4_DIR = 0xFF;
PORT_PAGE=1;  
P4_PUDEN=0x00;
P4_PUDSEL=0xFF;  
PORT_PAGE=0;
}

void delay(int a)
{
   int i;
   for(i=0;i<a;i++);
   i=0;
}

void writedata(char t)
{
   RS = 1;             // This is data
   delay(250);
   P4 &= 0x0F;       // Make P2.4 to P2.7 zero
   P4 |= (t&0xF0);  // Write Upper nibble of data

   E  = 1;             // => E = 1
   delay(250);
   
   E  = 0;             // => E = 0
   delay(250);
  
   P4 &= 0x0F;       // Make P2.4 to P2.7 zero
   P4 |= ((t<<4)&0xF0);// Write Lower nibble of data

   E  = 1;             // => E = 1
   delay(250);
   E  = 0;             // => E = 0
   delay(250);
}

void writecmd(int z)
{
   RS = 0;             // This is command

   P4 &= 0x0F;       // Make P2.4 to P2.7 zero
   P4 |= (z&0xF0);     // Write Upper nibble of data

   E  = 1;             // => E = 1
   delay(250);
  
   E  = 0;             // => E = 0
   delay(250);
   

   P4 &= 0x0F;       // Make P2.4 to P2.7 zero
   P4 |= ((z<<4)&0xF0);// Write Lower nibble of data

   E  = 1;             // => E = 1
   delay(250);
   
   E  = 0;             // => E = 0
   delay(250);
}

void ReturnHome(void)     //Return to 0 location
{
  writecmd(0x02);
    delay(1500);
}

void wait(unsigned int time)
{
unsigned int zaehler = 0;
TMOD = 1;
TL0 = 0x50;
TH0 = 0xFB;
TCON = 0x10;
while(time != zaehler)
  {
    if(TF0)
    {
      TF0=0;
      TL0=0x20;
      TH0=0xD1; //Reload Wert von 65536-12000 = 53536 => 0xD120 => 1ms timer (12000*83.33 = 999960ns)
      zaehler++;
    }
  }
    
}

[Johannes M. (johannesm)]

Das Datenblatt gibt ziemlich genaue Angaben zum Timing bei der 
Initialisierung. Mit deiner delay Funktion sieht es aber so aus, als 
wenn du ins blaue einfach mal 250 Takte wartest. Gibt es da vielleicht 
eine besser geeignete delay Funktion bei deinem Compiler die für deinen 
uC passt?

[troll (Gast)]

Johannes M. schrieb:
> Gibt es da vielleicht
> eine besser geeignete delay Funktion bei deinem Compiler die für deinen
> uC passt?

Das selbe wollte ich gerade fragen. Den for-Mist da wird der Optimizer 
wegschmeißen, ergo: Keine Wartezeit.

[Sabi (Gast)]

Hey Johannes, vielen Dank für die Antwort.

Ja, das mit der Timing Funktion stimmt, das habe ich einfach grob 
überschlagen.
Aber ich habe gelesen, dass es ziemlich egal ist wenn man die Pausen 
länger macht, und nach meinen groben Berechnungen kommt folgendes raus:

24mhz = 0.041us pro Takt
250*0.041 = 10,25us Wartezeit

... Ach, da hab ich wohl falsch überschlagen, okay das werde ich mal 
ausprobieren.

Für die längeren Wartezeiten habe ich ja die wait Funktion geschrieben.

Aber ansonsten müsste das so doch hinhauen oder?

Grüßle

[Sabi (Gast)]

Okay, das mit dem Optimizer wäre ja blöd.

Dann werd ichs mal versuchen das alles über den Timerdelay zu 
realisieren.

Benutze Keil 4.0, habe sonst jetzt keine Idee wie ich da einen delay 
hinbekomme ohne Timer oder die for Schleife. Ihr vielleicht? :)

Grüßle

[Cyblord -. (cyblord)]

Im Grunde sind alle delays natürlich auch nur loops. Du musst halt die 
RICHTIGE Anzahl Befehle ermitteln um die korrekte Wartezeit zu bekommen 
und du musst gucken dass das nicht wegoptimiert wird. Auf Timer würd ich 
da nicht gehen, viel zu aufwendig. Gibt doch auch 
Delay-Loop-Calculators. Oder rechne dirs selber aus und überprüfe im 
Output ob die Schleife auch da bleibt oder wegoptimiert wird. Kann man 
nicht trotzdem die delay Funktionen des GCC als Vorlage hernehmen wie 
man sowas macht? Vor allem sind das doch sowieso Assemblerbefehle. Also 
guck dir an wie das da gemacht wird.

gruß cyblord

[Sabi (Gast)]

Ihr hattet recht, der Compiler hat die for Schleifen immer wegoptimiert.
Wenn ich die nop (); aufrufe bleibt die for Schleife drin, top das 
werd ich morgen gleich ausprobieren. Vielen Dank euch schonmal :)

int i;
for(i=0;i<a;i++)
{_nop_ ();}
i=0;

[Sabi (Gast)]

Hallo Leute, irgendwie tut sich immer noch nichts bei dem LCD, d.h ich 
muss die Delay Zeit wohl doch noch einmal richtig berechnen. Aber 
irgendwie versteh ich nicht wie ich raussfinde wie lange die Ausführung 
des nop (); Befehls geht, geschweige denn der gesamten for Schleife 
dauert.

Könnt ihr mir einen Tip geben?

Wenn ich debugge und bis zu dieser for-Schleife komme sieht der Assembly 
so aus wie im Anhang.

Wie gesagt die CPU Clock läuft mit 24 Mhz

[Nun (Gast)]

Nochwas. viele LCD wollen nach dem Reset speziell lang warten. ZB 
Millisekunden.

[Sabi (Gast)]

Ja, dafür wird die Funktion wait(450) in der lcd_init aufgerufen. Somit 
wartet der Microcontroller 45ms.

Grüßle

[waf (Gast)]

Zwei Dinge fallen mir auf:
1) R/W muss auf 0
2) Init mit 0x28 zwei mal senden, dazwischen 10ms warten
WAF

[waf (Gast)]

Noch ein Hinweis, RS muss wie RW vor und während der Initialisierung auf 
0 (Low)

Gruß
WAF

[Sabi (Gast)]

Hey Leute, habs leider immer noch nicht zum laufen bekommen. Hab nochmal 
alle Leitungen durchgepinnt und musste feststellen das alles richtig 
angeschlossen ist^^.
Danke für den Hinsweis mit dem RS bit, werde ich morgen ausprobieren.


Ich habe immernoch die Vermutung, dass es doch am Timing liegt, aber 
werde aus dem Datenblatt irgendwie nicht schlau, hab es mal als Datei 
angehängt. Welche Frequenz gilt den jetzt hier für meine Befehle, mit 
welcher Frequenz werden diese abgearbeitet? Will daraus ja einen delay 
kreieren.

Danke schonmal im Vorraus

Grüßle

[Karl H. (kbuchegg)]

Du kannst ja als erstes einfach mal alle delays durch deine wait 
Funktion ersetzen und da so in der Größenordnung von 30 Millisekunden 
einstellen. Jedenfalls trau ich dieser wait Funktion eher über den Weg, 
als das was du da mit dem delay angestellt hast.

Wenn deine Wartezeiten erst mal zu lange sind, dann ist das nicht weiter 
schlimm. Du könntest auch Sekunden machen damit du extern an den pins 
messen kannst, bzw. mit ein paar LED nachverfolgen kannst in welcher 
Reihenfolge sich welche Pins am LCD ändern. Langsamer darfst du. Aber 
schneller darfst du nicht.

Zum jetzigen Zeitpunkt ist erst mal wichtig, dass die Initialisierung 
überhaupt klappt. Schneller machen kannst du sie immer noch.