LCD Display 128x64 e PIC Pierin

[Luca1995]

Salve a tutti :)
Vi pongo il problema:
A scuola stiamo preparando un bel progetto che comprende microcontrollori, trasduttori, meccanica, display appunto e altre diavolerie.....io ho il compito di creare delle funzioni e codici in C col PIC Pierin per poter scrivere dei dati su questo piccolo schermo.
Il modello è LGM12864B-NSW-BBS.
Dopo vari tentativi, guide, ecc... mi devo arrendere e cercare l'aiuto di qualche buona anima perché non avendo mai avuto una minima esperienza in questo campo non so proprio come fare!!!
Il datasheet penso di saperlo a memoria (anche perché molto breve)....ecco il codice che ho scritto in MPLAB-IDE

Codice: Seleziona tutto

// File di definizione dei registri del micro.
#include "p18f47j53.h"

// File di configurazione dei fuses
#include "configurazione.h"   

// Mappatura delle interrupt
#include "mappa_int.h"

// Header del main
#include "main.h"

//Dichiaro del funzioni dase per LCD Display

//////////////////////////////////////////////////////////////////////////////////////// SCRITTURA/LETTURA
//scrittura

#define  GLCD_CS1(n)   LATBbits.LATB0 = (n)
#define  GLCD_CS2(n)   LATBbits.LATB1 = (n)
#define  GLCD_RS(n)   LATBbits.LATB2 = (n)
#define  GLCD_RST(n)   LATBbits.LATB5 = (n)
#define  GLCD_RW(n)   LATBbits.LATB3 = (n)
#define  GLCD_E(n)      LATBbits.LATB4 = (n)

#define GLCD_D0(n)   LATDbits.LATD0 = (n)
#define GLCD_D1(n)   LATDbits.LATD1 = (n)
#define GLCD_D2(n)   LATDbits.LATD2 = (n)
#define GLCD_D3(n)   LATDbits.LATD3 = (n)
#define GLCD_D4(n)   LATDbits.LATD4 = (n)
#define GLCD_D5(n)   LATDbits.LATD5 = (n)
#define GLCD_D6(n)   LATDbits.LATD6 = (n)
#define GLCD_D7(n)   LATDbits.LATD7 = (n)

//lettura

#define GLCD_D0_Read   PORTDbits.RD0
#define GLCD_D1_Read   PORTDbits.RD1
#define GLCD_D2_Read   PORTDbits.RD2
#define GLCD_D3_Read   PORTDbits.RD3
#define GLCD_D4_Read   PORTDbits.RD4
#define GLCD_D5_Read   PORTDbits.RD5
#define GLCD_D6_Read   PORTDbits.RD6
#define GLCD_D7_Read   PORTDbits.RD7

/////////////////////////////////////////////////////////////////////////////////////////////// DEFINIZIONE TRIS SOLO OUT

#define GLCD_TRIS_CS1      TRISBbits.TRISB0 = 1
#define GLCD_TRIS_CS2      TRISBbits.TRISB1 = 1
#define GLCD_TRIS_RS      TRISBbits.TRISB2 = 1
#define GLCD_TRIS_RST      TRISBbits.TRISB5 = 1
#define GLCD_TRIS_RW      TRISBbits.TRISB3 = 1
#define GLCD_TRIS_E         TRISBbits.TRISB4 = 1

/////////////////////////////////////////////////////////////////////////////////////////////// DEFINIZIONE TRIS IN/OUT

#define GLCD_TRIS_D0_IN   TRISDbits.TRISD0 = 1
#define GLCD_TRIS_D1_IN   TRISDbits.TRISD1 = 1
#define GLCD_TRIS_D2_IN   TRISDbits.TRISD2 = 1
#define GLCD_TRIS_D3_IN   TRISDbits.TRISD3 = 1
#define GLCD_TRIS_D4_IN   TRISDbits.TRISD4 = 1
#define GLCD_TRIS_D5_IN   TRISDbits.TRISD5 = 1
#define GLCD_TRIS_D6_IN   TRISDbits.TRISD6 = 1
#define GLCD_TRIS_D7_IN   TRISDbits.TRISD7 = 1

#define GLCD_TRIS_D0_OUT   TRISDbits.TRISD0 = 0
#define GLCD_TRIS_D1_OUT   TRISDbits.TRISD1 = 0
#define GLCD_TRIS_D2_OUT   TRISDbits.TRISD2 = 0
#define GLCD_TRIS_D3_OUT   TRISDbits.TRISD3 = 0
#define GLCD_TRIS_D4_OUT   TRISDbits.TRISD4 = 0
#define GLCD_TRIS_D5_OUT   TRISDbits.TRISD5 = 0
#define GLCD_TRIS_D6_OUT   TRISDbits.TRISD6 = 0
#define GLCD_TRIS_D7_OUT   TRISDbits.TRISD7 = 0

////////////////////////////////////////////////////////////////////////////////////////////////////

#define PAUSA_E ritardo(1)
#define PAUSA_INIT ritardo(100)




//------------------------------------------------------------------------------
// Variabili globali
//------------------------------------------------------------------------------
#pragma udata
volatile unsigned short timer_delay;    // Timer software
unsigned char TRIS_BUS;

// ------------------------------------------------------ 
// GLCD Picture name: Immagine.bmp           
// GLCD Model: KS0108 128x64           
// ------------------------------------------------------ 





//------------------------------------------------------------------------------
// Funzione di servizio delle interrupt ad ALTA priorità
//------------------------------------------------------------------------------
#pragma code
#pragma interrupt highPriorityInterrupt
void highPriorityInterrupt()
{
  // Verifica quale flag ha causato l' interrupt
  // Esegui la parte di codice di servizio dell' interrupt
  // Azzera il flag che ha causato l' interrupt
  // ...
}

//------------------------------------------------------------------------------
// Funzione di servizio delle interrupt a BASSA priorità
//------------------------------------------------------------------------------
#pragma interruptlow lowPriorityInterrupt
void lowPriorityInterrupt()
{
  // Verifica quale flag ha causato l' interrupt
  // Esegui la parte di codice di servizio dell' interrupt
  // Azzera il flag che ha causato l' interrupt
  // ...
 
  // Gestione dell' interrupt del timer 2
  if(PIR1bits.TMR2IF)
  {
    // gestione del timer software. Il timer software deve decrementarsi
    // fino ad arrivare a 0. Una volta arrivato a 0 resta fermo a 0.
    if (timer_delay) timer_delay--;
      
    // Resetta il flag che ha generato l' interrupt
    PIR1bits.TMR2IF = 0;
  }
}

//------------------------------------------------------------------------------
// Prototipi delle funzioni
//------------------------------------------------------------------------------
#pragma code
void timer2_deInit(void);
void ritardo(int x);
void impulso(int x);
//------------------------------------------------------------------------------
// Funzioni
//------------------------------------------------------------------------------
#pragma code

//------------------------------------------------------------------------------
// De-inizializza il timer 2 e lo porta nello stato in cui si trovava
// subito dopo il RESET
void timer2_deInit(void)
{
  T2CON = 0;            // Resetta il timer 2 control register
  TMR2 = 0;             // Azzera il contatore interno
  PR2 = 0;              // Azzera il registro comparatore
  PIE1bits.TMR2IE = 0;  // Disabilita l' interrupt
  IPR1bits.TMR2IP = 0;  // Resetta il bit di priorità dell' interrupt
  PIR1bits.TMR2IF = 0;  // Azzera il flag di interrupt
}

void ritardo(int x)
{
   timer_delay = x;
   for(;;){
      if(!timer_delay){
            break;}
} }      



//FUNZIONI DEL DISPLAY

//Questa funzione la useremo al momento di leggere o scrivere qualcosa dal bus dati del display
void Enable_Strobe(void){
  GLCD_E(1);
  PAUSA_E;
  GLCD_E(0);
  PAUSA_E;
}

//Effettua il reset del display !!Attenzione non è LCD_Clear dopo il reset il display va reinizializzato!!!
void GLCD_RESETcmd(void){
  //Reset LCD
  GLCD_RST(1);
  PAUSA_INIT;
  GLCD_RST(0);
  PAUSA_INIT;
  GLCD_RST(1);
  PAUSA_INIT;
}

//IMPOSTO LE PORTE D COME OUTPUT O INPUT (0 output, 1 input)

void GLCD_Set_Port(unsigned char ch)
{
   if(ch == 1){
      TRIS_BUS = 1;
      GLCD_TRIS_D0_IN;
             GLCD_TRIS_D1_IN;
                GLCD_TRIS_D2_IN;
              GLCD_TRIS_D3_IN;
              GLCD_TRIS_D4_IN;
              GLCD_TRIS_D5_IN;
              GLCD_TRIS_D6_IN;
              GLCD_TRIS_D7_IN;
   }
   else{
      TRIS_BUS = 0;
      GLCD_TRIS_D0_OUT;
         GLCD_TRIS_D1_OUT;
           GLCD_TRIS_D2_OUT;
           GLCD_TRIS_D3_OUT;
           GLCD_TRIS_D4_OUT;
           GLCD_TRIS_D5_OUT;
           GLCD_TRIS_D6_OUT;
           GLCD_TRIS_D7_OUT;
   }
   PAUSA_E;
}

////////////////////////////////////////////////////////////////////////////////CONTROLLA LE PORTE DATI

//scrive un dato nel bus
void GLCD_Ctrl_Port(unsigned char ch){

if(TRIS_BUS == 1){GLCD_Set_Port(0);}//Se il bus dati è configurato come input lo riconfigura come output

if(ch & 1){GLCD_D0(1);}else{GLCD_D0(0);}
if(ch & 2){GLCD_D1(1);}else{GLCD_D1(0);}
if(ch & 4){GLCD_D2(1);}else{GLCD_D2(0);}
if(ch & 8){GLCD_D3(1);}else{GLCD_D3(0);}
if(ch & 16){GLCD_D4(1);}else{GLCD_D4(0);}
if(ch & 32){GLCD_D5(1);}else{GLCD_D5(0);}
if(ch & 64){GLCD_D6(1);}else{GLCD_D6(0);}
if(ch & 128){GLCD_D7(1);}else{GLCD_D7(0);}
}

////////////////////////////////////////////////////////////////////////////////LEGGE LE PORTE DATI

unsigned char GLCD_Ctrl_Port_Read(void){
unsigned char ch = 0;
if(TRIS_BUS == 0){GLCD_Set_Port(1);}      //Se il bus dati è configurato come output lo riconfigura come input

if(GLCD_D7_Read == 1){ch=ch | 128;}
if(GLCD_D6_Read == 1){ch=ch | 64;}
if(GLCD_D5_Read == 1){ch=ch | 32;}
if(GLCD_D4_Read == 1){ch=ch | 16;}
if(GLCD_D3_Read == 1){ch=ch | 8;}
if(GLCD_D2_Read == 1){ch=ch | 4;}
if(GLCD_D1_Read == 1){ch=ch | 2;}
if(GLCD_D0_Read == 1){ch=ch | 1;}
return ch;
}

////////////////////////////////////////////////////////////////////////////////INVIA UN DATO all'LCD GRAFICO

//invio un dato al controller del display selezionandolo tramite la varabile chip & chop
//Ch è il valore da inviare
//colore invece se == 2 inverte i byte (negativo)

void Write_Data(unsigned char ch, unsigned char chip, unsigned char colore)
   {
      if(chip == 1){GLCD_CS1(1);GLCD_CS2(0);} //seleziono il chip 1
      else{GLCD_CS1(0);GLCD_CS2(1);}             // seleziono il chip 2
         
      GLCD_RW(0); //scrivo
      GLCD_RS(1); //invio un dato
      
      if(colore==2){GLCD_Ctrl_Port(~ch);}
      else{GLCD_Ctrl_Port(ch);}
   
      Enable_Strobe();
}

////////////////////////////////////////////////////////////////////////////////INVIA UN COMANDO all'LCD GRAFICO
//Invia un comando al display

void Write_Cmd(unsigned char ch,unsigned char chip){

if(chip == 1){GLCD_CS1(1);GLCD_CS2(0);} //seleziono il chip 1
         else{GLCD_CS1(0);GLCD_CS2(1);} //seleziono il chip 2

     GLCD_RW(0); //scrivo
     GLCD_RS(0); //invio un comando

     GLCD_Ctrl_Port(ch);
   
     Enable_Strobe();
}

////////////////////////////////////////////////////////////////////////////////LEGGE UN DATO dall'LCD GRAFICO
//legge un dato dal display selezionato tramite comando

unsigned char Read_Data(unsigned char chip){
unsigned char ch;
if(chip == 1){GLCD_CS1(1);GLCD_CS2(0);} //seleziono il chip 1
         else{GLCD_CS1(0);GLCD_CS2(1);} //seleziono il chip 2

     GLCD_RW(1); //leggo
     GLCD_RS(1); //leggo un dato
     GLCD_E(1);
     PAUSA_E;
     ch=GLCD_Ctrl_Port_Read();
     GLCD_E(0);
     PAUSA_E;
   
return ch;
}

////////////////////////////////////////////////////////////////////////////////SET Y START ADD
void GLCD_SetY_StartAdd(unsigned char ch,unsigned char chip){

if(ch <= 63){
             Write_Cmd((ch | 0b11000000),chip);
             }
}

////////////////////////////////////////////////////////////////////////////////SET Y ADD
void GLCD_SetY_Add(unsigned char ch,unsigned char chip){

if(ch <= 63){
             Write_Cmd((ch | 0b01000000),chip);
             }
}

////////////////////////////////////////////////////////////////////////////////SET PAGE ADD
void GLCD_SetPage_Add(unsigned char ch,unsigned char chip){

if(ch <= 7){
             Write_Cmd((ch | 0b10111000),chip);
             }
}

////////////////////////////////////////////////////////////////////////////////DISPLAY LDC ON/OFF
void GLCD_ON(unsigned char ch,unsigned char chip){

if(ch <= 1){
             Write_Cmd((ch | 0b00111110),chip);
             }
}

////////////////////////////////////////////////////////////////////////////////scrive lo stesso byte su tutta la pagina
void GLCD_Clear_Page(unsigned char ch,unsigned char chip,unsigned char page){

unsigned char i;
  GLCD_SetPage_Add(page,chip);
  GLCD_SetY_Add(0,chip);
 
  for(i=0;i<64;i++){
                    Write_Data(ch,chip,0);
                    }

}

////////////////////////////////////////////////////////////////////////////////CHIP CLEAR
void GLCD_Clear_Chip(unsigned char ch,unsigned char chip){

unsigned char i;

for(i=0;i<8;i++){
                  GLCD_Clear_Page(ch,chip,i);}

}

////////////////////////////////////////////////////////////////////////////////GLCD CLEAR
void GLCD_ClearAll(void){
GLCD_Clear_Chip(0,1);
GLCD_Clear_Chip(0,2);
}


////////////////////////////////////////////////////////////////////////////////LEGGI un BYTE dall'LCD
unsigned char GLCD_ReadByte(unsigned char page,unsigned char y,unsigned char chip){
unsigned char ch;
GLCD_SetPage_Add(page,chip);
GLCD_SetY_Add(y,chip);
ch=Read_Data(chip);
return ch;
}

////////////////////////////////////////////////////////////////////////////////Scrive un BYTE sull'LCD
void GLCD_WriteByte(unsigned char ch,unsigned char color,unsigned char page,unsigned char y,unsigned char chip){
GLCD_SetPage_Add(page,chip);
GLCD_SetY_Add(y,chip);
Write_Data(ch,chip,color);
}



////////////////////////////////////////////////////////////////////////////////INIZIALIZZA l'LCD GRAFICO
void GLCD_My_init(void){

unsigned char ch=0;
///////////////////Inizializzo le porte del processore
GLCD_Set_Port(0);

GLCD_TRIS_CS1;
GLCD_TRIS_CS2;
GLCD_TRIS_RS;
GLCD_TRIS_RST;
GLCD_TRIS_RW;
GLCD_TRIS_E;

GLCD_Ctrl_Port(0);

GLCD_CS1(0);
GLCD_CS2(0);
GLCD_RW(0);
GLCD_RS(0);
GLCD_E(0);

PAUSA_INIT;

GLCD_RESETcmd();//Reset GLCD

//Protocollo di inizializzazione Vedi Datasheet
//Imposto lo zero nell'asse Y
GLCD_SetY_StartAdd(0,1);PAUSA_INIT;
GLCD_SetY_StartAdd(0,2);PAUSA_INIT;

//Posiziono il puntatore dell'asse Y sul punto 0
GLCD_SetY_Add(0,1);PAUSA_INIT;
GLCD_SetY_Add(0,2);PAUSA_INIT;

//Posiziono il cursore nella pagina 0
GLCD_SetPage_Add(0,1);PAUSA_INIT;
GLCD_SetPage_Add(0,2);PAUSA_INIT;

//invio il cmd di accensione!!
GLCD_ON(1,1);PAUSA_INIT;
GLCD_ON(1,2);PAUSA_INIT;

//Ed infine lo "LAVO"
GLCD_ClearAll();PAUSA_INIT;
}

void GLCD_XY_byte(unsigned char x,unsigned char y, unsigned char *Yp,unsigned char *page,unsigned char *chip){
if(y>55){*page=7;  goto out;}
if(y>47){*page=6;  goto out;}
if(y>39){*page=5;  goto out;}
if(y>31){*page=4;  goto out;}
if(y>23){*page=3;  goto out;}
if(y>15){*page=2;  goto out;}
if(y>7) {*page=1;  goto out;}
else{    *page=0; }
out:
if(x > 63){*chip=1;*Yp=x-64;}else{*chip=2;*Yp=x;}
}

void GLCD_Goto_XY(unsigned char x,unsigned char y){
unsigned char Yp,page,chip;

GLCD_XY_byte(x,y,&Yp,&page,&chip);
GLCD_SetPage_Add(page,chip);
GLCD_SetY_Add(Yp,chip);
}

////////////////////////////////////////////////////////////////////////////////Scrivo un byte con coordinate X,Y
void GLCD_WriteByte_XY(unsigned char ch,unsigned char color,unsigned char x,unsigned char y){
unsigned char Yp,page,chip;
GLCD_XY_byte(x,y,&Yp,&page,&chip);
GLCD_WriteByte(ch,color,page,Yp,chip);
}

////////////////////////////////////////////////////////////////////////////////Leggo un byte con coordinate X,Y
unsigned char GLCD_ReadByte_XY(unsigned char x,unsigned char y){
unsigned char Yp,page,chip,ch;
GLCD_XY_byte(x,y,&Yp,&page,&chip);
ch=GLCD_ReadByte(page,Yp,chip);
return ch;
}

///////////////////////////////////////////////////////////////////////////////Scrivo vera e propria immagine
void GLCD_WriteForImm(unsigned char const immagine[],unsigned char color,unsigned char l,unsigned char h,unsigned char x,unsigned char y){

unsigned char xImm,yImm;
unsigned int xArr=0;
                           for(yImm=0;yImm<h;){
                                                for(xImm=0;xImm<l;xImm++){
                                                                           GLCD_WriteByte_XY(immagine[xArr],color,(x+xImm),(y+yImm));
                                                                           xArr=xArr+1;
                                                                           }
                                                yImm=yImm+8;}
}


//------------------------------------------------------------------------------
// MAIN
void main(void)
{
char Immagine[16] = {1,2,3,4,5,4,2,3,4,2,3,5,6,2,2,3};
  // Fa partire il PLL.
  // Anche se viene selezionato tramite i bit di configurazione
  // il suo funzionamento non è automatico. Ha bisogno di un comando.
  OSCTUNEbits.PLLEN = 1;
  // Attende abbastanza tempo per far stabilizzare il PLL
  Delay1KTCYx(100);
  // Da ora in poi abbiamo il PLL funzionante ed il micro con il turbo.
 
  // -------- Inizializzazione delle periferiche --------
 

 
 
  // De-inizializza il timer2. Non sarebbe necessario perché il micro esce
  // allo stato di RESET ma è comunque buona pratica de-inizializzare sempre
  // le periferiche per non tralasciare nessun bit.
  timer2_deInit();
  // Inizializza il timer 2 per interrupt ogni millisecondo.
  // prescaler divide per 16
  T2CONbits.T2CKPS = 2;
  // Postscaler divide per 5
  T2CONbits.T2OUTPS = 4;
  // Imposta il valore comparatore a 150
  PR2 = 150;
  // Imposta l' interrupt del Timer 2 a priorita' bassa
  IPR1bits.TMR2IP = 0;
  // abilita interrupt del timer
  PIE1bits.TMR2IE = 1;
 
  // -------- Selezione ed abilitazione delle interrupt -------- 
  // Ora che si sono inizializzate tutte le periferiche si possono abilitare
  // Oppurtunamente le interrupt
  // abilita le interrupt a bassa priorita'
  RCONbits.IPEN = 1;
  // abilta tutte le interrupt a priorità bassa
  INTCONbits.GIEL = 1;
  // Abilita tutte le interrupt in generale
  INTCONbits.GIEH = 1;         
 
  // -------- Attivazione delle periferiche -------- 
  // Con le interrupt abilitate possiamo ora far partire il timer 2
  // Accende il timer
  T2CONbits.TMR2ON = 1;
   
  // Inizializza la variabile che funge da timer software
  timer_delay = 0;
  // Inizializza la variabile di conteggio


 
   GLCD_My_init();
  // -------------- Ciclo infinito di funzionamento -------------
  for(;;)
  {   

   GLCD_WriteForImm(Immagine[],0,32,8,0,0);
      
  } // for(;;)
}

Cosa non va??

[MarcRider]

così è un po difficile, cosa fa il display al termine delle operazioni?

[Luca1995]

Non ho capito la domanda........comunque adesso ho semplificato il codice perché stavo diventando pazzo.
Ho ricominciato da capo con funzioni semplici e di base per scrivere un byte alla volta.
Ecco

Codice: Seleziona tutto

// File di definizione dei registri del micro.
#include "p18f47j53.h"

// File di configurazione dei fuses
#include "configurazione.h"   

// Mappatura delle interrupt
#include "mappa_int.h"

// Header del main
#include "main.h"


/* Display connections */
#define Scrivi_Byte LATD
#define Leggi_Byte PORTD
#define Direzione_Bus TRISD
#define GLCD_CS1    LATBbits.LATB0
#define GLCD_CS2    LATBbits.LATB1
#define GLCD_RS     LATBbits.LATB2
#define GLCD_RW    LATBbits.LATB3
#define GLCD_RST    LATBbits.LATB5
#define GLCD_EN     LATBbits.LATB4




//------------------------------------------------------------------------------
// Variabili globali
//------------------------------------------------------------------------------
#pragma udata
volatile unsigned short timer_delay;    // Timer software


//------------------------------------------------------------------------------
// Funzione di servizio delle interrupt ad ALTA priorità
//------------------------------------------------------------------------------
#pragma code
#pragma interrupt highPriorityInterrupt
void highPriorityInterrupt()
{
  // Verifica quale flag ha causato l' interrupt
  // Esegui la parte di codice di servizio dell' interrupt
  // Azzera il flag che ha causato l' interrupt
  // ...
}

//------------------------------------------------------------------------------
// Funzione di servizio delle interrupt a BASSA priorità
//------------------------------------------------------------------------------
#pragma interruptlow lowPriorityInterrupt
void lowPriorityInterrupt()
{
  // Verifica quale flag ha causato l' interrupt
  // Esegui la parte di codice di servizio dell' interrupt
  // Azzera il flag che ha causato l' interrupt
  // ...
 
  // Gestione dell' interrupt del timer 2
  if(PIR1bits.TMR2IF)
  {
    // gestione del timer software. Il timer software deve decrementarsi
    // fino ad arrivare a 0. Una volta arrivato a 0 resta fermo a 0.
    if (timer_delay) timer_delay--;
      
    // Resetta il flag che ha generato l' interrupt
    PIR1bits.TMR2IF = 0;
  }
}

//------------------------------------------------------------------------------
// Prototipi delle funzioni
//------------------------------------------------------------------------------
#pragma code
void timer2_deInit(void);


//------------------------------------------------------------------------------
// Funzioni
//------------------------------------------------------------------------------
#pragma code

//------------------------------------------------------------------------------
// De-inizializza il timer 2 e lo porta nello stato in cui si trovava
// subito dopo il RESET
void timer2_deInit(void)
{
  T2CON = 0;            // Resetta il timer 2 control register
  TMR2 = 0;             // Azzera il contatore interno
  PR2 = 0;              // Azzera il registro comparatore
  PIE1bits.TMR2IE = 0;  // Disabilita l' interrupt
  IPR1bits.TMR2IP = 0;  // Resetta il bit di priorità dell' interrupt
  PIR1bits.TMR2IF = 0;  // Azzera il flag di interrupt
}

//------------------------------------------------------------------------------
void ritardo(int time)
{
   timer_delay = time;
   for(;;){
      if(!timer_delay)break;
   }   
}   

void Enable(void)
{
   GLCD_EN = 1;
   ritardo(1);
   GLCD_EN = 0;
   
}
   
void Set_Chip(int chip)
{
   if(chip==1)
   {
      GLCD_CS1 = 1;
      GLCD_CS2 = 0;
   }
   else
   {
      GLCD_CS1 = 0;
      GLCD_CS2 = 1;
   }
}

void Set_Y (int y)
{
   GLCD_RS = 0;
   GLCD_RW =0;
   LATD = y;
   LATDbits.LATD7 = 0;
   LATDbits.LATD6 = 1;
   Enable();
}

void Set_Page (int page)
{
   GLCD_RS = 0;
   GLCD_RW =0;
   LATD = page;
   LATDbits.LATD7 = 1;
   LATDbits.LATD6 = 0;
   LATDbits.LATD5 = 1;
   LATDbits.LATD4 = 1;
   LATDbits.LATD3 = 1;
   Enable();
}

void Display_Line (int line)
{
   GLCD_RS = 0;
   GLCD_RW =0;
   LATD = line;
   LATDbits.LATD7 = 1;
   LATDbits.LATD6 = 1;
   
   Enable();
}

void Display_OFF (void)
{
   GLCD_RS = 0;
   GLCD_RW =0;
   LATD = 0x3E;
   Enable();
}

void Display_ON (void)
{
   GLCD_RS = 0;
   GLCD_RW =0;
   LATD = 0x3F;
   Enable();
}

void Status_Read (int busy, int on_off, int reset)
{
   GLCD_RS = 0;
   GLCD_RW =1;
   LATDbits.LATD7 = busy;
   LATDbits.LATD6 = 0;
   LATDbits.LATD5 = on_off;
   LATDbits.LATD4 = reset;
   LATDbits.LATD3 = 0;
   LATDbits.LATD2 = 0;
   LATDbits.LATD1 = 0;
   LATDbits.LATD0 = 0;
   Enable();
}

void WriteDisplayByte(int data, int chip)
{   
   GLCD_EN = 0;
   ritardo(1);   
   GLCD_RW =0;
   ritardo(1);
   GLCD_RS = 1;   
   Set_Chip(chip);
   LATD = data;
   GLCD_EN = 1;
   GLCD_EN = 0;
   GLCD_EN = 1;
}

int ReadDisplayByte(void)
{
   GLCD_RS = 1;
   GLCD_RW =1;
   Enable();
   return(PORTD);
}



// MAIN
void main(void)
{
  char c;  // utizzata per la durata dei lampeggi
 
  // Fa partire il PLL.
  // Anche se viene selezionato tramite i bit di configurazione
  // il suo funzionamento non è automatico. Ha bisogno di un comando.
  OSCTUNEbits.PLLEN = 1;
  // Attende abbastanza tempo per far stabilizzare il PLL
  Delay1KTCYx(100);
  // Da ora in poi abbiamo il PLL funzionante ed il micro con il turbo.
 
  // -------- Inizializzazione delle periferiche --------
 
  // Inizializza la PORTD
  // bit 4 input pulsante PL0
  //  "  5 input pulsante PL1
  //  "  6 output LED LED1
  //  "  7 output LED LED2
 
  // Mette a 0 tutte le uscite
 
 
 
  // De-inizializza il timer2. Non sarebbe necessario perché il micro esce
  // allo stato di RESET ma è comunque buona pratica de-inizializzare sempre
  // le periferiche per non tralasciare nessun bit.
  timer2_deInit();
  // Inizializza il timer 2 per interrupt ogni millisecondo.
  // prescaler divide per 16
  T2CONbits.T2CKPS = 2;
  // Postscaler divide per 5
  T2CONbits.T2OUTPS = 4;
  // Imposta il valore comparatore a 150
  PR2 = 15;
  // Imposta l' interrupt del Timer 2 a priorita' bassa
  IPR1bits.TMR2IP = 0;
  // abilita interrupt del timer
  PIE1bits.TMR2IE = 1;
 
  // -------- Selezione ed abilitazione delle interrupt -------- 
  // Ora che si sono inizializzate tutte le periferiche si possono abilitare
  // Oppurtunamente le interrupt
  // abilita le interrupt a bassa priorita'
  RCONbits.IPEN = 1;
  // abilta tutte le interrupt a priorità bassa
  INTCONbits.GIEL = 1;
  // Abilita tutte le interrupt in generale
  INTCONbits.GIEH = 1;         
 
  // -------- Attivazione delle periferiche -------- 
  // Con le interrupt abilitate possiamo ora far partire il timer 2
  // Accende il timer
  T2CONbits.TMR2ON = 1;
   
  // Inizializza la variabile che funge da timer software
  timer_delay = 0;
  // Inizializza la variabile di conteggio
  c = 0;
 
  // -------------- Ciclo infinito di funzionamento -------------
  for(;;)
  {
   
Display_OFF();

Set_Y (7);
Set_Page(1);
Display_Line(1);
WriteDisplayByte(0x38,1);
Display_ON();
ritardo(10000);


   
  } // for(;;)
}

Ma anche adesso, come le funzioni che ho utilizzato nel for(;;) finale, non riesco a vedere neanche un pixel che cambia colore.....

[MarcRider]

per iniziare, leggendo questo sul datasheet:

instruction from MPU. When RSTB becomes low, following procedure is occurred.
1. Display off
2. Display start line register become set by 0.(Z-address 0)
While RSTB is low, No instruction except status read can by accepted. Therefore, execute other
instructions after making sure that DB4= (clear RSTB) and DB7=0 (ready) by status read instruction.
The conditions of power supply at initial power up are shown in table 1.


Bisogna che fuori dal ciclo for, almeno la prima volta esegui il reset, e devi attendere almeno 1us. prima di iniziare questa procedura.
E poi non devi rifarla, ammeno che non prevedi un crash, una disalimentazione solo del display etc.

Poi il cambio colore, non ho capito cosa significa. se intendi il cursore che lampeggia o qualcosaltro...

poi scusa ma...

Codice: Seleziona tutto

void ritardo(int time)
{
   timer_delay = time;
   for(;;){
      if(!timer_delay)break;
   }   
}   

void Enable(void)
{
   GLCD_EN = 1;
   ritardo(1);
   GLCD_EN = 0;
   
}

non so che quarzo usa il pierin, io ho un 8Mhz e divide la frequenza per 4, e con un solo colpo di clock impiego 0.5us. Vedendo il PIC che monta, e quindi potrebbe anche non suddividere per 4, e con il codice "se è diverso da 1 blocca) e impostando il ritardo a 1... quanto tempo aspetteresti?

[TardoFreak]

Sei sicuro di avere anche collegato e regolato bene il contrasto?

[Luca1995]

Allora, il PIC lavora con una frequenza di 48MHz che diviso 4 danno 12MHz. Per come ho impostato prescaler, contatore e postscaler ho un'interrupt ogni 100us.

In questo modo inserendo 1 nella funzione lui fa girare il ciclo for infinito fino a quando la variabile timer_delay, gestita da interrupt per un decremento di 1 ogni volta, non vale 0.

Il colore è inteso se si disegna nero su bianco o il rispettivo negativo di una immagine.
Comunque nel secondo programma, che è più semplice, per il momento il colore non c'è.

Poi non riesco a capire se lo "Status read" è un codice che devo inviare o ricevere dal display......
Il contrasto è regolato bene con un trimmer da 10k perché sullo schermo vedo chiaramente tutti i pixel color giallo-grigio-chiaro su sfondo blu (retroilluminazione).

Forse chiedo troppo ma sapreste scrivere a parole una piccola lista delle operazioni da fare perché, oltre a non capire bene tutto il datasheet, ci sono scritti dei piedini che non capisco, per esempio CS3 e CS1B....

perché li fanno così complicati........

Sarebbe più semplice se ogni 8 pixel fossero direttamente collegato ad una cella di memoria da un byte, la quale, insieme alle altre, sono indirizzate con un bus ad n linee e infine un semplice enable.
No loro per sti 4 puntini di uno schermo ci devono mettere 3 integrati........

Forse sono io che non capisco, non conoscendo il campo dell'elettronica che di occupa di display.
Grazie per gli aiuti che mi avete fornito

[MarcRider]

status read o busy flag, è input lato MPU, cioè il display mette a 1 una uscita, finché non ha finito le operazioni.

Reads the internal status
BUSY
0: Ready
1: In operation
ON/OFF
0: Display ON
1: Display OFF
RESET
0: Normal
1: Reset

quindi quando interroghi il display, se ti restituisce 1, sta ancora lavorando se ti restituisce 0, allora è pronto a ricevere altri comandi. Per iniziare ti consiglio come stai facendo, di non usare il Busy flag.

Per l'inizializzazione, basta che esegui quelle due righe, il comando di displayoff, e return home, e devi stare attento ad aspettare il tempo di avvio, basta che sia effettivamente superiore a quello descritto.
http://www.mikroe.com/downloads/get/1908/s6b0108_spec.pdf
Questo dovrebbe essere il controller del tuo display. Non c'è scritto molto di più del datasheet del display, di solito però è più dettagliato. Ti rispiega la fase di reset, e ci sono i grafici dei tempi di attesa.
Il display presenta tutti i pixel neri?

[Luca1995]

Ho modificato tutto in questo modo ma ancora non funziona

Codice: Seleziona tutto

// File di definizione dei registri del micro.
#include "p18f47j53.h"

// File di configurazione dei fuses
#include "configurazione.h"   

// Mappatura delle interrupt
#include "mappa_int.h"

// Header del main
#include "main.h"


/* Display connections */
#define Scrivi_Byte LATD
#define Leggi_Byte PORTD
#define Direzione_Bus TRISD
#define GLCD_CS1    LATBbits.LATB0
#define GLCD_CS2    LATBbits.LATB1
#define GLCD_RS     LATBbits.LATB2
#define GLCD_RW    LATBbits.LATB3
#define GLCD_RST    LATBbits.LATB5
#define GLCD_EN     LATBbits.LATB4




//------------------------------------------------------------------------------
// Variabili globali
//------------------------------------------------------------------------------
#pragma udata
volatile unsigned short timer_delay;    // Timer software


//------------------------------------------------------------------------------
// Funzione di servizio delle interrupt ad ALTA priorità
//------------------------------------------------------------------------------
#pragma code
#pragma interrupt highPriorityInterrupt
void highPriorityInterrupt()
{
  // Verifica quale flag ha causato l' interrupt
  // Esegui la parte di codice di servizio dell' interrupt
  // Azzera il flag che ha causato l' interrupt
  // ...
}

//------------------------------------------------------------------------------
// Funzione di servizio delle interrupt a BASSA priorità
//------------------------------------------------------------------------------
#pragma interruptlow lowPriorityInterrupt
void lowPriorityInterrupt()
{
  // Verifica quale flag ha causato l' interrupt
  // Esegui la parte di codice di servizio dell' interrupt
  // Azzera il flag che ha causato l' interrupt
  // ...
 
  // Gestione dell' interrupt del timer 2
  if(PIR1bits.TMR2IF)
  {
    // gestione del timer software. Il timer software deve decrementarsi
    // fino ad arrivare a 0. Una volta arrivato a 0 resta fermo a 0.
    if (timer_delay) timer_delay--;
      
    // Resetta il flag che ha generato l' interrupt
    PIR1bits.TMR2IF = 0;
  }
}

//------------------------------------------------------------------------------
// Prototipi delle funzioni
//------------------------------------------------------------------------------
#pragma code
void timer2_deInit(void);

//------------------------------------------------------------------------------
// Funzioni
//------------------------------------------------------------------------------
#pragma code

//------------------------------------------------------------------------------
// De-inizializza il timer 2 e lo porta nello stato in cui si trovava
// subito dopo il RESET
void timer2_deInit(void)
{
  T2CON = 0;            // Resetta il timer 2 control register
  TMR2 = 0;             // Azzera il contatore interno
  PR2 = 0;              // Azzera il registro comparatore
  PIE1bits.TMR2IE = 0;  // Disabilita l' interrupt
  IPR1bits.TMR2IP = 0;  // Resetta il bit di priorità dell' interrupt
  PIR1bits.TMR2IF = 0;  // Azzera il flag di interrupt
}

//------------------------------------------------------------------------------
void ritardo(int time)
{
   timer_delay = time;
   for(;;){
      if(!timer_delay)break;
   }   
}   

void Enable(void)
{
   GLCD_EN = 1;
   ritardo(1);
   GLCD_EN = 0;
   
}
   
void Set_Chip(int chip)
{
   if(chip==1)
   {
      GLCD_CS1 = 1;
      GLCD_CS2 = 0;
   }
   else
   {
      GLCD_CS1 = 0;
      GLCD_CS2 = 1;
   }
}

void Set_Y (int y)
{
   GLCD_RS = 0;
   GLCD_RW =0;
   LATD = y;
   LATDbits.LATD7 = 0;
   LATDbits.LATD6 = 1;
   Enable();
}

void Set_Page (int page)
{
   GLCD_RS = 0;
   GLCD_RW =0;
   LATD = page;
   LATDbits.LATD7 = 1;
   LATDbits.LATD6 = 0;
   LATDbits.LATD5 = 1;
   LATDbits.LATD4 = 1;
   LATDbits.LATD3 = 1;
   Enable();
}

void Display_Line (int line)
{
   GLCD_RS = 0;
   GLCD_RW =0;
   LATD = line;
   LATDbits.LATD7 = 1;
   LATDbits.LATD6 = 1;
   
   Enable();
}

void Display_OFF (void)
{
   GLCD_RS = 0;
   GLCD_RW =0;
   LATD = 0x3E;
   Enable();
}

void Display_ON (void)
{
   GLCD_RS = 0;
   GLCD_RW =0;
   LATD = 0x3F;
   Enable();
}

int Status_Read_Busy (void)
{   
   int a;
   GLCD_RS = 0;
   GLCD_RW =1;
   Enable();
   a = PORTDbits.RD7;
   return(a);
}

int Status_Read_ON_OFF(void)
{
   int a;
   GLCD_RS = 0;
   GLCD_RW =1;
   Enable();
   a = PORTDbits.RD5;
   return(a);
}

int Status_Read_Reset(void)
{
   int a;
   GLCD_RS = 0;
   GLCD_RW =1;
   Enable();
   a = PORTDbits.RD4;
   return(a);
}

void WriteDisplayByte(int data, int chip)
{   
   GLCD_EN = 0;
   ritardo(1);   
   GLCD_RW =0;
   ritardo(1);
   GLCD_RS = 1;   
   Set_Chip(chip);
   LATD = data;
   GLCD_EN = 1;
   GLCD_EN = 0;
   GLCD_EN = 1;
}

int ReadDisplayByte(void)
{
   GLCD_RS = 1;
   GLCD_RW =1;
   Enable();
   return(PORTD);
}




// MAIN
void main(void)
{
  // Fa partire il PLL.
  // Anche se viene selezionato tramite i bit di configurazione
  // il suo funzionamento non è automatico. Ha bisogno di un comando.
  OSCTUNEbits.PLLEN = 1;
  // Attende abbastanza tempo per far stabilizzare il PLL
  Delay1KTCYx(100);
  // Da ora in poi abbiamo il PLL funzionante ed il micro con il turbo.
 
  // -------- Inizializzazione delle periferiche --------
 
  // Inizializza la PORTD
  // bit 4 input pulsante PL0
  //  "  5 input pulsante PL1
  //  "  6 output LED LED1
  //  "  7 output LED LED2
 
  // Mette a 0 tutte le uscite
  GLCD_RST = 0;
 
 
  // De-inizializza il timer2. Non sarebbe necessario perché il micro esce
  // allo stato di RESET ma è comunque buona pratica de-inizializzare sempre
  // le periferiche per non tralasciare nessun bit.
  timer2_deInit();
  // Inizializza il timer 2 per interrupt ogni millisecondo.
  // prescaler divide per 16
  T2CONbits.T2CKPS = 2;
  // Postscaler divide per 5
  T2CONbits.T2OUTPS = 4;
  // Imposta il valore comparatore a 150
  PR2 = 15;
  // Imposta l' interrupt del Timer 2 a priorita' bassa
  IPR1bits.TMR2IP = 0;
  // abilita interrupt del timer
  PIE1bits.TMR2IE = 1;
 
  // -------- Selezione ed abilitazione delle interrupt -------- 
  // Ora che si sono inizializzate tutte le periferiche si possono abilitare
  // Oppurtunamente le interrupt
  // abilita le interrupt a bassa priorita'
  RCONbits.IPEN = 1;
  // abilta tutte le interrupt a priorità bassa
  INTCONbits.GIEL = 1;
  // Abilita tutte le interrupt in generale
  INTCONbits.GIEH = 1;         
 
  // -------- Attivazione delle periferiche -------- 
  // Con le interrupt abilitate possiamo ora far partire il timer 2
  // Accende il timer
  T2CONbits.TMR2ON = 1;
   
  // Inizializza la variabile che funge da timer software
  timer_delay = 0;
  // Inizializza la variabile di conteggio
 
  ritardo(1);
  GLCD_RST = 1;
  // -------------- Ciclo infinito di funzionamento -------------
  for(;;)
  {
   
Display_OFF();

for(;;)
{
   if(!Status_Read_Busy)break;
}

Set_Y (7);
Set_Page(1);
Display_Line(1);
WriteDisplayByte(0x38,1);
Display_ON();
ritardo(10000);


   
  } // for(;;)
}

[MarcRider]

perdonami, ma sul main continuo a vedere che generi un codice in loop, e non hai eseguito sto famoso reset. prima del ciclo for infinito, scrivi una funzione di reset.

Codice: Seleziona tutto

main....

// INIZIO RESET
if(Status_Read_Busy)
{
Nop();
}

Display_OFF();
Set_Y (0);
InviaComandoZalDisplay(RS=0,RW=0, DB7-DB0 = 11000000) // vedi DS reset register Z
// FINE reset

for(;;) ....


/*
RESET
The system can be initialized by setting RSTB terminal at low level when turning power on, receiving instruction
from MPU.
When RSTB becomes low, following procedure is occurred.
· Display off
· Display start line register become set by 0. (Z-address 0)
While RSTB is low, No instruction except status read can be accepted. Therefore, execute other instructions after
making sure that DB4 = 0 (clear RSTB) and DB7 = 0 (ready) by status read instruction.
*/


Prova così. miraccomando i ritardi nelle istruzioni. Fammi sapere se migliora.