Tempi segnali su display HD44780

[thexeno]

Ciao. Ho riaperto in un nuovo thread per ordine.

Riassumendo, ho scritto un programma per testare un display alfanumerico HD44780 16x2.

Tutto funziona, anche il controllo del flag BF per sapere se il display è inattivo, ma ho problemi quando faccio il controllo per far tornare il cursore nella home, cioè è come se non ci fosse.

Per rispettare i tempi, mi metto sul lato sicuro e e setto dati e segnali (RS, RW) contemporaneamente e rispetto i tempi di esecuzione del "clock" E. Vi mostro l'esempio:

Nel main ho questo:

Codice: Seleziona tutto

write_comm(LCD_FUNCTIONSET|LCD_8BITMODE|LCD_2LINE|LCD_5x8DOTS);

    while (write_comm(LCD_BUSYCHECK) != 0);

     write_comm(LCD_DISPLAYCONTROL | LCD_DISPLAYON | LCD_CURSOROFF | LCD_BLINKON);

     while (write_comm(LCD_BUSYCHECK) != 0);

    write_comm(LCD_ENTRYMODESET|LCD_ENTRYLEFT);

     while (write_comm(LCD_BUSYCHECK) != 0);

        write_comm(LCD_RETURNHOME);
    __delay_ms(2);  // <- QUELLO MISTERIOSO!
    while (write_comm(LCD_BUSYCHECK) != 0);
   
//     uint16_t a = 0b0000000001001000; // H

     write_comm(LCD_WRITEDATA|'x');

     while (write_comm(LCD_BUSYCHECK) != 0);

     write_comm(LCD_WRITEDATA|'u');
     
     while (write_comm(LCD_BUSYCHECK) != 0);

     write_comm(LCD_WRITEDATA|'@');

       while (write_comm(LCD_BUSYCHECK) != 0);

    while (1) {

    } // while


e la write_comm è descritta così, insieme alla generazione dell'impulso:

Codice: Seleziona tutto

void pulse(){
    PORTCbits.RC2 = 0;
    __delay_us(1);   // 1us enable cycle time
    PORTCbits.RC2 = 1;
    __delay_us(1);
    PORTCbits.RC2 = 0;
    __delay_us(100);
}

bool write_comm(uint16_t comando){
    if (comando == LCD_BUSYCHECK)
    {
        bool flag = 1;
        TRISD = 0xFF; //8 bit data
        PORTCbits.RC0 = comando >> 9;
        PORTCbits.RC1 = comando >> 8;
        pulse();
        flag = PORTD & (1 << 8);
        TRISD = 0x00; //8 bit data
        return flag; // for checking purposes, ready flag
    }
    PORTD = comando;
    PORTCbits.RC0 = comando >> 9; //RS
    PORTCbits.RC1 = comando >> 8;  // R/W
    pulse();
    return 0; // scarta
}

I define:

Codice: Seleziona tutto

#define LCD_CLEARDISPLAY 0x0001
#define LCD_RETURNHOME 0x0002
#define LCD_ENTRYMODESET 0x0004
#define LCD_DISPLAYCONTROL 0x0008
#define LCD_CURSORSHIFT 0x0010
#define LCD_FUNCTIONSET 0x0020
#define LCD_SETCGRAMADDR 0x0040
#define LCD_SETDDRAMADDR 0x0080
#define LCD_BUSYCHECK 0x0100
#define LCD_WRITEDATA 0x0200

Inserendo i 2ms dopo il RETURNHOME funziona, se non lo faccio quando resetto il micro "a caldo", a volte il display sceglie una delle 3 locazioni in cui scrivo il carattere "a caso", quando il programma riparte, invece di partire dalla prima posizione. Ripeto, a volte: dev'essere un tempo non rispettato, o quasi.

In questo articolo http://www.electroyou.it/tardofreak/wiki/pic18f47j53-un-modulo-in-c-per-pilotare-display-lcd ho letto due cose che non mi sono chiare:

Codice: Seleziona tutto

void HD44780_writeCmd(unsigned char n)
{
  // Per inviare un comando la linea RS deve essere posta a 0
  HD44780_RS = 0;
  // Invia il dato 
  writeByte(n);
  // Ritarda per attendere la completa esecuzione del comando
  // In questo caso dipende dal comando
  // questi ritardi sono di 1600 e 43 us massimi
  if (!(n & 0xFC)) delay1600us(); else delay43us();
}

//-----------------------------------------------------------------------------
void HD44780_writeData(unsigned char n)
{
  // Per inviare un comando la linea RS deve essere posta a 0
  HD44780_RS = 1;
  // Invia il dato 
  writeByte(n);
  // Ritarda per attendere la completa esecuzione del comando
  // anche questo ritardo deve essere 43us
  delay43us();
}

Perché viene fatta una sola lettura del flag e in base a quello impostare il ritardo? Non va bene una lettura in polling, come dice nel datasheet? Credo che a livello funzionale sia l'unica differenza... credo! Però deduco che quel programma li funziona.
Ma cosa sbaglio io, se non metto quei due millisecondi? Il flag dovrebbe rimanere a 1 fino a quando il display non riceve, e dopo il RETURN HOME pare che a volte sia "pronto" per ricevere anche quando non lo è, constringendomi a mettere una ritardo manuale. Cosa mi sfugge?

[TardoFreak]

Non viene letto nessun flag.
Individuo il comando e, in base a che comando é, seleziono il ritardo.

[thexeno]

E' vero, scusa. Avevo dato una occhiata veloce sul forum per vedere cose simili e appena ho trovato qualcosa inerente la mia parte ho copiato/incollato, figuraccia. Quindi si spiega come mai funziona... il tuo!

Ora mia vien da pensare, se nemmeno li è stato fatto un controllo sul flag, se la lettura del flag stesso è una cosa che si fa in generale... cioè mi piace come idea di aspettare "esattamente" quanto il display dice, chiedendoglielo. Facendo così, in effetti, se il display non c'è o è rotto tutto il sistema è piantato in un while.

Non a caso la mancanza di risposte a un post è indice del fatto che mi devo chiedere se ha senso quel che ho implementato.

[TardoFreak]

Utilizzando i ritardi fissi si usano anche meno pin.
Vabbè, sarà anche un po' meno veloce è un display alfanumerico e non ci fanno migliaia di operazioni come invece si fa con quelli grafici.
Inoltre il codice è più semplice.
Insomma, non penso valga la pena di prendersi tanti mal di pancia, per un display alfanumerico poi.

[thexeno]

Ok, messaggio ricevuto. Davo ascolto a questo prurito per un motivo più "didattico" che pratico, per imparare a districarmi meglio tra le varie funzioni e funzionalità. Certo non credo ci sia una differenza prestazionale, è un discorso solo concettuale qui.

PS: è vero che leggere un bit con la struttura PORTXbits.RXn è più veloce che fare uno shift come ho fatto? (anche se concettualmente parlando per me è più comprensibile con lo shift, mi rendo conto a che "altezza" leggo e posso variare lo shift con una variabile).

[TardoFreak]

Dipende da come lo compila il compilatore. Puoi provare i due modi ed andarti a vedere il lavoro dietro le quinte. Ti fai generare il listato in assembly e ti levi lo sfizio.
Inoltre andare a vedere come lavora il compilatore è una cosa molto interessante ed istruttiva.
A volte trovi delle sorprese!

Comunque non hai fatto male a provare a testare il bit di stato, la sperimentazione è sempre utile, non è mai tempo perso.

[thexeno]

Mi sento preso per i fondelli da un display. Ho appena scoperto che lo shift lo faccio di 9 posizioni, risultando SEMPRE in un azzeramento del flag. Il motivo per cui funziona è che esegue qualche operazione in cui resetta un bit (senza effettivamente leggerlo) dando il tempo di stabilizzarsi. Questo spiega perché con il cursore che torna alla home, ovvero comando che chiede tempo, il flag non funziona: la funzione write_comm(BUSYCHECK) fa prendere tempo ma in questo caso non abbastanza.

Anche leggendo il bit giusto però non funziona, rimendo sempre in "busy". MA POI.............

Quant'è vero che i santi sono scesi a trovarmi per chiedermi cosa c'è che non andava, ho risolto!! La lettura del dato fornito dal display va fatto mantenendo E alto! Non pulsarlo! Ho interpretato male il datasheet.

[thexeno]

Ora vorrei porre una domanda, solo per curiosità.

Il datasheet qui: http://lcd-linux.sourceforge.net/pdfdocs/hd44780.pdf, inizializzazione p. 46 per il modo a 4 bit.
SBAGLIO o ci sono DUE fasi separate da UNA attesa da 4.1ms?

No perché dopo un pomeriggio sprecato scopro che tutti in giro fanno 3 fasi in sequenza, ovvero 2 attese da 4.1ms. Infatti poi funziona.
E' sbagliato il datasheet? Avrei dovuto seguire le correzioni? Lo chiedo perché se avessi interpretato male, eviterei che un episodio simile riaccada.