Problem LCD -- PIC

[Hans W. (coglione)]

Hallo liebe uC - Gemeinde.

Seit ein paar Tagen bin ich bei einem Problem. Ich komme einfach nicht 
mehr weiter.

Das Umfeld:
- LCD 2*16
- PIC 18F4520
- MPLABX mit XC8 Codec (neuste Version)
- Pickit3

Alles ist programmiert und sollte auch funktionieren, aber das tut's 
nicht :)

Ich arbeite mit den __delay_us() und __delay_ms() für die Pausen. Aber 
genau da vermute ich das Problem.
Wenn ich alle Delays auskommentiere und mit dem Debugger die Schritte 
selber weiter schalte, dann wird der LCD initialisiert und funktioniert. 
Von da an kann ich Code ändern und laden.
Sobald ich aber den Controller vom Netz trenne und wieder starte geht 
nichts mehr, bis ich wieder das obige anwende.

Was kann das sein, ich bin am Ende meines Lateins :) :(

[Nico (nico123)]

Hallo Hans!
Hältst Du denn die Timings deines Displays ein (die stehen im 
Datenblatt)?
Wenn Du deinen Quellcode posten kannst, können wir dir besser helfen! 
Die genaue Bezeichnung des Displays ist auch wichtig!

[Hans W. (coglione)]

Die Pausen sind sogar etwas grösser als im Datenblatt,
die Init - Sequenz hat auf dem alten MPLAB funktioniert.
Aber da gab es das #use delay, was meiner Meinung besser ist, da man 
dort auch Sekunden eingeben konnte und keine Grenze hatte ( mit 
__delay_ms kann ich nicht mal 100ms eingeben, schon motzt er.

Hier der Code:

#include <xc.h>
#include <stdio.h>

#pragma config OSC = INTIO67    // Oscillator Selection bits (Internal oscillator block, port function on RA6 and RA7)
#pragma config PWRT = ON        // Power-up Timer Enable bit (PWRT enabled)
#pragma config BOREN = OFF      // Brown-out Reset Enable bits (Brown-out Reset disabled in hardware and software)
#pragma config WDT = OFF        // Watchdog Timer Enable bit (WDT disabled (control is placed on the SWDTEN bit))
#pragma config MCLRE = OFF      // MCLR Pin Enable bit (RE3 input pin enabled; MCLR disabled)


#define LCD_RS      LATBbits.LATB5
#define LCD_RW      LATBbits.LATB6
#define LCD_E       LATBbits.LATB7
#define LCD_DATA    LATD
#define _XTAL_FREQ  8000000      // Clock frequency in Hz
//#define __delay_us(x) _delay((unsigned long)((x)*(_XTAL_FREQ/8000000.0)))
//#define __delay_ms(x) _delay((unsigned long)((x)*(_XTAL_FREQ/8000.0)))

void initLCD();
void writeLCD(char byte);
void enableLCD();
void enableLCD1();
void clock_set();


void main (){

    TRISA = 0x00;
    TRISB = 0x00;
    TRISC = 0x00;
    TRISD = 0x00;
    TRISE = 0x00;
    OSCCON = 0xFF;
    LATA = 0x00;
    LATB = 0x00;
    LATC = 0x00;
    LATD = 0x00;
    LATE = 0x00;
    
    initLCD();
    
    while(1)
    {
        LATC = 0x80;        //LED EIN
        writeLCD('A');    // ein Zeichen auf LCD schreiben
    }
}
void initLCD()
{
        LCD_RS = 0;
        LCD_RW = 0;
        LCD_E = 0;
        __delay_ms(50);
  LCD_DATA = 0b00111000;      //Function set
  enableLCD();
        LCD_DATA = 0b00111000;      //Function set
  enableLCD();
  LCD_DATA = 0b00001100;      //Display ON/OFF Control
  enableLCD();
  LCD_DATA = 0b00000001;      //clear
  enableLCD();
  LCD_DATA = 0b00000111;      //Entry Mode set
  enableLCD();
  __delay_ms(20);
        LCD_DATA = 0x01;                        // Clear LCD
        enableLCD();   
}
/*
 * Kommunikation mit dem LCD
 */
void writeLCD(char byte)
{ 
    LCD_RW=0;
    LCD_RS=0;
    LCD_DATA= byte;
    LCD_E = 1;
    LCD_RS=1;
    __delay_ms(1);
    LCD_E = 0;
    __delay_us(40);
}
/*
 * Erzeugen eines Enable Strobbes, der Dauer 20µs
 */
void enableLCD()
{
    LCD_E=1;
    __delay_us(40);
    LCD_E=0;
    __delay_us(40);
}
// langer Strobe für die 2ms Pause in der INIT
void enableLCD1()
{
    LCD_E=1;
     __delay_ms(2);
    LCD_E=0;
    __delay_us(40);
}

[test (Gast)]

Mach mal das

#define _XTAL_FREQ 8000000

vor

#include <xc.h>

Der braucht das ja schon da drin.

[Castlerock (Gast)]

und vielleicht solltest du die Funktion "enableLCD1" in der INIT 
benutzen wie in dein Komentar beschrieben :-)

[Klaus (Gast)]

Hans Wiederkehr schrieb:
> // langer Strobe für die 2ms Pause in der INIT
> void enableLCD1()
> {
>     LCD_E=1;
>      __delay_ms(2);
>     LCD_E=0;
>     __delay_us(40);
> }

Seit wann muß das E-Signal 2 ms lang high sein? Das ist doch irgendwie 
quatsch. Wahrscheinlich fängt die Zeit für das Display erst an zu 
zählen, wenn E auf low geht. Die lange Pause gehört ans Ende, und die 
Länge des Enable Pulses ist so rund eine µs, höchstens zwei

MfG Klaus

[Peter D. (peda)]

Hans Wiederkehr schrieb:
> // langer Strobe für die 2ms Pause in der INIT
> void enableLCD1()
> {
>     LCD_E=1;
>      __delay_ms(2);
>     LCD_E=0;
>     __delay_us(40);
> }

Das ist falsch.
Die Wartezeit bis zum nächsten Befehl beginnt nach dem Enable-Puls.
Für den Enable-Puls selber sind 1µs dicke ausreichend:

void enableLCD1()
{
    LCD_E=1;
     __delay_us(1);
    LCD_E=0;
    __delay_ms(2);
}

[Chris (Gast)]

_XTAL_FREQ/8000000.0
sollte sein:
_XTAL_FREQ/4000000.0
dasselbe bei _ms delay.

[Hans W. (coglione)]

So, ich hab jetzt alle Ratschläge befolgt und geändert:

- XTAL_FREQ kommt als aller erstes
- Die Enable Funktion hat jetzt : E = 1, 1uS delay, E=0, 40 us delay.

Klappt immer nich nicht. Wieder das selbe wie bisher :(

Mir fallen gleich die Haare aus :) :)


Hat noch wer ne Idee?

Hier der neue code:

#define _XTAL_FREQ 8000000

#include <xc.h>
#include <stdio.h>
#include <stdlib.h>

#pragma config OSC = INTIO67    // Oscillator Selection bits (Internal oscillator block, port function on RA6 and RA7)
#pragma config PWRT = ON        // Power-up Timer Enable bit (PWRT enabled)
#pragma config BOREN = OFF      // Brown-out Reset Enable bits (Brown-out Reset disabled in hardware and software)
#pragma config WDT = OFF        // Watchdog Timer Enable bit (WDT disabled (control is placed on the SWDTEN bit))
#pragma config MCLRE = OFF      // MCLR Pin Enable bit (RE3 input pin enabled; MCLR disabled)


#define LCD_RS      LATBbits.LATB5
#define LCD_RW      LATBbits.LATB6
#define LCD_E       LATBbits.LATB7
#define LCD_DATA    LATD

void initLCD();
void writeLCD(char byte);
void enableLCD();

int i = 0;

void main (){

    TRISA = 0x00;
    TRISB = 0x00;
    TRISC = 0x00;
    TRISD = 0x00;
    TRISE = 0x00;
    OSCCON = 0xFF;
    LATA = 0x00;
    LATB = 0x00;
    LATC = 0x00;
    LATD = 0x00;
    LATE = 0x00;

    initLCD();
    
    while(1)
    {
        LATC = 0x00;
        if (i == 0);
        {
          LATC = 0x80;        //LED EIN
          writeLCD('G');    // ein Zeichen auf LCD schreiben
          i = 1;
        }
    }
}

void initLCD()
{


        LCD_RS = 0;
        LCD_RW = 0;
        LCD_E = 0;
        __delay_ms(50);
  LCD_DATA = 0b00111000;      //Function set
  enableLCD();
        LCD_DATA = 0b00111000;      //Function set
  enableLCD();
         LCD_DATA = 0b00111000;      //Function set
  enableLCD();
  LCD_DATA = 0b00001100;      //Display ON/OFF Control
  enableLCD();
  LCD_DATA = 0b00000001;      //clear
  enableLCD();
        __delay_ms(2);
  LCD_DATA = 0b00000111;      //Entry Mode set
  enableLCD();
        LCD_DATA = 0x01;                        // clear 
        enableLCD();
        __delay_ms(2);
}
/*
 * Kommunikation mit dem LCD
*/
void writeLCD(char byte)
{ 
    LCD_RW=0;
    LCD_RS=0;
    __delay_us(1);
    LCD_DATA= byte;
    LCD_RS = 1;
    enableLCD();
}
/*
 * Erzeugen eines Enable Strobbes, der Dauer 20µs
*/
void enableLCD()
{
    LCD_E=1;
    __delay_us(2);
    LCD_E=0;
    __delay_us(50);
}

[Karl H. (kbuchegg)]

Hö, hö, ho

Hier

  LCD_DATA = 0b00111000;      //Function set
  enableLCD();
        LCD_DATA = 0b00111000;      //Function set
  enableLCD();
         LCD_DATA = 0b00111000;      //Function set
  enableLCD();

sind jeweils Wartezeiten einzuhalten!


Bitte lass diesen Quatsch

    while(1)
    {
        LATC = 0x00;
        if (i == 0);
        {
          LATC = 0x80;        //LED EIN
          writeLCD('G');    // ein Zeichen auf LCD schreiben
          i = 1;
        }
    }

wenn du etwas beim hochfahren des Programms nur einmalig ausführen 
willst, dann zieh es vor die while Schleife. Aber mach da keine 
Kunstprojekte draus. Das ist alles Code, den man erneut überprüfen muss, 
ob du dir da nicht wieder irgendwo einen Fehler eingebaut hast. Sinnlos 
überprüfen muss

....
   LATC = 0x80;        //LED EIN
   writeLCD('G');    // ein Zeichen auf LCD schreiben

   while(1)
   {
   }
}

feddich. Das ist simpel, überschaubar und mann muss nicht überlegen ob 
das so stimmt. Dein Problem ist jetzt das Timing für das LCD richtig 
hinzukriegen. Beschäftige dich damit und nicht mit irgendwelchen anderen 
zusätzlichen Komplikationen. Die lösen dein Problem ganz sicher nicht.
Wenn das LCD erst mal läuft, dann kannst du dich nach Herzenslust 
austoben. Aber bitte nicht vorher. Das sind alles Dinge, die selbst 
wieder potentielle Fehler enthalten können. Und genau das kannst du 
jetzt überhaupt nicht brauchen.

[Karl H. (kbuchegg)]

Du sagst, du kannst das Programm durchsteppen und wenn du das tust, dann 
initialisiert es richtig.

Kannst du auch Breakpoints setzen?

Wenn ja, dann setz halt erst mal einen Breakpoint hier hin

void initLCD()
{


        LCD_RS = 0;
        LCD_RW = 0;
        LCD_E = 0;
        __delay_ms(50);
  LCD_DATA = 0b00111000;      //Function set
  enableLCD();

   <------------- Breakpoint

        LCD_DATA = 0b00111000;      //Function set
  enableLCD();
         LCD_DATA = 0b00111000;      //Function set
  enableLCD();

wenn du dann weiterlaufen lässt, initialisiert das LCD wenn du 
weitersteppst?

Wenn du den Breakpoint tiefer setzt

void initLCD()
{


        LCD_RS = 0;
        LCD_RW = 0;
        LCD_E = 0;
        __delay_ms(50);
  LCD_DATA = 0b00111000;      //Function set
  enableLCD();
        LCD_DATA = 0b00111000;      //Function set
  enableLCD();

<--------

         LCD_DATA = 0b00111000;      //Function set
  enableLCD();

initialisiert es dann, wenn du weitersteppst?


Sinn der Sache ist es, rauszufinden, wo die du dem LCD eine zu kurze 
Pause gibst. Indem du einen Breakpoint setzt, läuft das Programm bis 
dort hin mit voller Geschwindigkeit und danach langsamer. D.h. durch das 
versetzen des Breakpoints unterteilst du die Initialisierung in einen 
Teil, der volle Kanne abläuft und einen der langsamer abläuft. AN der 
Stelle, an der sich das Verhalten ändert (von funktioniert auf 
funktioniert nicht), würde ich mal ansetzem, dass du da dem LCD etwas zu 
wenig Zeit lässt.