In questa guida cercheremo di capire come funziona e come si controlla un display grafico con controller ks0108...
La prima cosa da capire è come è fatto questo LCD,da cosa è composto...
Questo display è fondamentalmente composto da una matrice a cristalli liquidi (il vetrino che contiene fisicamente i pixel) e 2 circuiti integrati uno che si chiama ks0107 e l'altro quello che ci interessa ks0108,entrambi creati per lavorare insieme...
Cioè il ks0107 controllerà la y del nostro display mentre il ks0108 controllerà la x "le coordinate le intendo guardando il display con il lati minori in verticale"
Siccome il ks0108 è in grado di gestire solo 64 linee allora ne utilizzeremo due!
Nell'immagine precedente è rappresentato il controolo di un display con più pixel ma il principio è lo stesso...I controller vengono collegati in modo da lavorare insieme...
Adesso veniamo al sodo,dopo aver fatto un pò di teoria andiamo a ciò che veramente ci interessa.
Come si contollano?Come facciamo a scrivere una frase?visualizzare un' immagine?
La foto sopra è la skin di prova dell'alfano che sto costruendo nell'altra sezione di questo sito...
STEP1: Come si collega e a cosa servono i vari contatti
ATTENZIONE L'IMMAGINE SOPRA è PURAMENTE ILLUSTRATIVA...LA POSIZIONE DEI PIEDINI CAMBIA DI DISPLAY IN DISPLAY!!!!!
ATTENZIONE2 Fate attenzione quando acquistate LCD grafici di questo tipo spesso necessitano di un convertitore buck boost esterno che generi una tensione negativa di circa -10V per regolare il contrasto invece altri lo hanno integrato e lo si regola con un semplice potenziometro prelevando la tensione negativa direttamente dal piedino Vee...
La funzione dei Piedini:
V0: Serve a regolare il contrasto usando la differenza di potenziale creata fra i piedine Vee e GND
CS1: Controlla il controller destro
CS2: Controller sinistro
E: Ci permette di disabilitare la linea dati del display in modo da poter usare gli stessi piedini per più cose
RW: serve per dire al display se voglio leggere o scrivere un dato
RS: RegisterSelect ,con il suo controllo indichiamo al display se gli inviamo un dato o un comando
RST: Reset è un piedino invertito quindi quando è 0 i controller si resettano
D0...D7: Sono la linea Dati del display
Sotto c'è un pò di codice c/c++ con delle definizioni... Perche ho fatto questo?
Ho fatto ciò in modo tale che le librerie che scriveremo in questa sede saranno utilizzabbili senza modifiche particolari su qualunque tipo di processore o sistema Embedded che abbia la possibilità di controllare delle porte IO...
Per adesso ho configurato le porte per essere compatibili con arduino,ma nel codice ci sono esempi sul come riconfigurarle per altri processori...
Dichiarazione dei pin
///////////////////////////////////////////////////////////////////////////////
//RedBaronTM
//Lunedi 12 dicembre 2011
//
///////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////Per chi usa Arduino
//qui bisogna inserire il pin a cui collegheremo le porte del nostro LCD
#define GLCD_pinCS1 14
#define GLCD_pinCS2 15
#define GLCD_pinRS 16
#define GLCD_pinRST 17
#define GLCD_pinRW 18
#define GLCD_pinE 19
#define GLCD_pinD0 20
#define GLCD_pinD1 21
#define GLCD_pinD2 22
#define GLCD_pinD3 23
#define GLCD_pinD4 24
#define GLCD_pinD5 25
#define GLCD_pinD6 26
#define GLCD_pinD7 27
//Per chi usa altri controllori basterà solo sostituire ad esempio
//nel caso della microchip
//digitalWrite(GLCD_pinCS1, n) con PORTBbits.RB0=(n)
//digitalRead(GLCD_pinD0) con PORTBbits.RB0
//pinMode(GLCD_pinCS1, OUTPUT) con TRISBbits.TRISB0=0
//pinMode(GLCD_pinCS1, INPUT) con TRISBbits.TRISB0=1
#define GLCD_CS1(n) digitalWrite(GLCD_pinCS1, n)
#define GLCD_CS2(n) digitalWrite(GLCD_pinCS2, n)
#define GLCD_RS(n) digitalWrite(GLCD_pinRS, n)
#define GLCD_RST(n) digitalWrite(GLCD_pinRST, n)
#define GLCD_RW(n) digitalWrite(GLCD_pinRW, n)
#define GLCD_E(n) digitalWrite(GLCD_pinE, n)
#define GLCD_D0(n) digitalWrite(GLCD_pinD0, n)
#define GLCD_D1(n) digitalWrite(GLCD_pinD1, n)
#define GLCD_D2(n) digitalWrite(GLCD_pinD2, n)
#define GLCD_D3(n) digitalWrite(GLCD_pinD3, n)
#define GLCD_D4(n) digitalWrite(GLCD_pinD4, n)
#define GLCD_D5(n) digitalWrite(GLCD_pinD5, n)
#define GLCD_D6(n) digitalWrite(GLCD_pinD6, n)
#define GLCD_D7(n) digitalWrite(GLCD_pinD7, n)
#define GLCD_D0_Read digitalRead(GLCD_pinD0)
#define GLCD_D1_Read digitalRead(GLCD_pinD1)
#define GLCD_D2_Read digitalRead(GLCD_pinD2)
#define GLCD_D3_Read digitalRead(GLCD_pinD3)
#define GLCD_D4_Read digitalRead(GLCD_pinD4)
#define GLCD_D5_Read digitalRead(GLCD_pinD5)
#define GLCD_D6_Read digitalRead(GLCD_pinD6)
#define GLCD_D7_Read digitalRead(GLCD_pinD7)
/////////////////////////////////////////Pin I� Solo OUT
#define GLCD_TRIS_CS1 pinMode(GLCD_pinCS1, OUTPUT)
#define GLCD_TRIS_CS2 pinMode(GLCD_pinCS2, OUTPUT)
#define GLCD_TRIS_RS pinMode(GLCD_pinRS, OUTPUT)
#define GLCD_TRIS_RST pinMode(GLCD_pinRST, OUTPUT)
#define GLCD_TRIS_RW pinMode(GLCD_pinRW, OUTPUT)
#define GLCD_TRIS_E pinMode(GLCD_pinE, OUTPUT)
////////////////////////////////////////Pin dati IN/OUT
#define GLCD_TRIS_D0_IN pinMode(GLCD_pinD0, INPUT)
#define GLCD_TRIS_D1_IN pinMode(GLCD_pinD1, INPUT)
#define GLCD_TRIS_D2_IN pinMode(GLCD_pinD2, INPUT)
#define GLCD_TRIS_D3_IN pinMode(GLCD_pinD3, INPUT)
#define GLCD_TRIS_D4_IN pinMode(GLCD_pinD4, INPUT)
#define GLCD_TRIS_D5_IN pinMode(GLCD_pinD5, INPUT)
#define GLCD_TRIS_D6_IN pinMode(GLCD_pinD6, INPUT)
#define GLCD_TRIS_D7_IN pinMode(GLCD_pinD7, INPUT)
#define GLCD_TRIS_D0_OUT pinMode(GLCD_pinD0, OUTPUT)
#define GLCD_TRIS_D1_OUT pinMode(GLCD_pinD1, OUTPUT)
#define GLCD_TRIS_D2_OUT pinMode(GLCD_pinD2, OUTPUT)
#define GLCD_TRIS_D3_OUT pinMode(GLCD_pinD3, OUTPUT)
#define GLCD_TRIS_D4_OUT pinMode(GLCD_pinD4, OUTPUT)
#define GLCD_TRIS_D5_OUT pinMode(GLCD_pinD5, OUTPUT)
#define GLCD_TRIS_D6_OUT pinMode(GLCD_pinD6, OUTPUT)
#define GLCD_TRIS_D7_OUT pinMode(GLCD_pinD7, OUTPUT)
/////BISOGNERà SOSTITUIRE IN CASO DI CONTROLLORE DIVERSO DA ARDUINO ANCHE LE
/////FUNZIONI PER LA PAUSA
#define PAUSA_E delayMicroseconds(1);//1Ms
#define PAUSA_INIT delay(100); //100Ms
Fatto ciò abbiamo detto al nostro compilatore che sia MPLAB,Mikroelektronica,Arduino,ecc ecc... come vogliamo chiamare le nostre porte.
Il prossimo passo sarà scrivere un sottoprogramma che ci permetta di inviare un dato o un comando al nostro display...
STEP2: Come inviare o ricevere un Dato/Comando
Per Inviare un dato o un comando
1) inizializzare i pin
2) Reset Display
Seguendo la tabella sotto non ci sarà difficile capire come i settare i piedini per l'invio dei dati
Quello che la tabella non ci dice è come dire al controller di leggerli... niente di più semplice:
Esempio con il comando "display on"
GLCD_CS1(1);//seleziono il chip 1
GLCD_CS2(0);
GLCD_RW(0); //scrivo
GLCD_RS(0); //invio un comando
GLCD_Ctrl_Port(0b00111111); Carico il valore letto in tabella per accendere il display
GLCD_E(1); abilito Enable così il controller capisce che deve leggere il dato
PAUSA_E;
GLCD_E(0);//disattivo enable e sono pronto per il prossimo dato
PAUSA_E;
}
Se invece fosse stato un dato anzichè un comando avrei soltanto dovuto portare la linea RS a 1
Adesso veniamo col creare qualche libreria che ci sarà utile per controllare il nostro display:
Primo pezzo della libreria per l'invio di un Comando o un Dato
//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
}
unsigned char TRIS_BUS = 0;
//Variabile per ricordarci se il bus dati è un'uingresso o un'uscita
//Normalmente con un pic leggerei la variabile TRIS# siccome "Arduino non lo consente di primo impatto"
//ho inizializzato una variabile su cui ricordare se il registro è di input o output
//Imposta le porte dati come input o output
void GLCD_Set_Port(unsigned char ch){
if(ch == 1){//input
TRIS_BUS = 1;
GLCD_TRIS_D7_IN;
GLCD_TRIS_D7_IN;
GLCD_TRIS_D7_IN;
GLCD_TRIS_D7_IN;
GLCD_TRIS_D7_IN;
GLCD_TRIS_D7_IN;
GLCD_TRIS_D7_IN;
GLCD_TRIS_D7_IN;
}
else{//output
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;}
////////////////////////////////////////////////////////////////////////////////CONTOLLA 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
//Legge il dato sul bus
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
//invuio un dato al controller del display selezionandolo tramite la variabile chip
//Ch è il valore da inviare
//colore invece se = 2 inverte il byte
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); //scrivo
GLCD_RS(1); //leggo un dato
GLCD_E(1);
PAUSA_E;
ch=GLCD_Ctrl_Port_Read();
GLCD_E(0);
PAUSA_E;
return ch;
}
Questi prototipi da me scritti servono a far capire cosa fare per inviare un determinato dato al display...
Anche se la loro semantica è poco rigorosa ma servirà allo scopo, Quello di far capire ad una persona con poche conoscenze in materia cosa fare per far funzionare il propio display grafico!
STEP3: Tabella dei comandi
STEP4: Inizializzazione
1) Inviare al display il comando "Display Start Line"
2) Inviare il comando "Set Address" che ci riservirà ogni volta che vorremo spostarci all'interno del quadrante
3) Inviare il comando "Set Page" per selezionare la pagina dove vogliamo scrivere "Vedi immagine sotto Step4"
4) Accendere il Display con il comando "DispalyON/OFF"
Ora bisognera ripetere questa operazione 2 volte perchè non dimentichiamoci che i controller sono 2!
Spiegato ciò vediamo un pò come inviare queste cose fisicamente al display:
Codice per l'inizializzazione del display
////////////////////////////////////////////////////////////////////////////////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);
}
}
////////////////////////////////////////////////////////////////////////////////SET PAGE ADD
void GLCD_ON(unsigned char ch,unsigned char chip){
if(ch <= 7){
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_SetY_Add(0,chip);
GLCD_SetPage_Add(page,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'GLCD
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 dall'GLCD
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;
}
Grazie a tutti i prototipi scritti fino ad ora possiamo già inizializzare il nostro display!
Semplicemente con il comando "GLCD_My_init();"
Download Prima prova con Arduino
STEP4: La prima immagine
Per visualizzare un'immagine dobbiamo creare una Funzione che invii al controller le coordinate da visualizzare e il dato secondo l'immagine sopra, e che ripeta ciò per tutti i byte di cui è composta l'immagine Ricordandoci che lasse y è suddiviso in pagine e che quindi ogni bit del byte corrisponde ad un pioxel...
1a Funzione trasforma le coordinate xy del display in dati più "mangiabili"
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);
}
2a Funzione Per scrivere/leggere un byte all'indirizzo X Y
////////////////////////////////////////////////////////////////////////////////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;
}
3a Funzione quella che visualizzerà l'immagine vera e propia
////////////////////////////////////////////////////////////////////////////////GLCD scrivi 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;}
}
Questa Funzione è limitata ad immagini con altezza multipla di 8... Ma è più che sufficiente per chi vuole visualizzare un'immagine ed ha poche pretese...!
Sò che questi prototipi possono essere semplificati ma per migliorare la "leggibilità" e la portabilità ho preferito andare per le lunghe...
STEP5 Creare un'immagine da visualizzare
Per visualizzare un'immagine all'interno del nostro lcd dobbiamo prima disegnarla con paint in modalità monocromatica,poi trasformarla in un'array e poi visualizzarla tramite la funzione descritta prima.
1a Disegnare la nostra immagine:
Per disegnare la nostra immagine utilizzeremo paint:
1) restringiamo il nostro fille alle misure dell'immagine che vogliamo, nel nostro caso 128pixel x 64pixel
2) salviamo tutto in modalità bitmap monocromatica
3)Creamo la nostra immagine e la salviamo
Questa è l'immagine che ho creato con paint
2a Trasformare l'immagine in qualcosa di più commestibile per il micro
Per Trasformare l'immagine in un formato comprensibile dal micro dobbiamo trasformarla in un Array composto da tanti byte quanti sono i pixel / 8
Cioè nel nostro caso essendo 128 x 64 pixel utilizzeremo 128 byte per ogni pagina quindi in totale sono 8 pagine e 1024Byte
Per fare questa trasformazione useremo un programma che viene allegato con un software chiamato mikroC che è a pagamento ma per ciò che serve a noi và benissimo anche la demo...
http://www.mikroe.com/eng/products/view/231/mikroc-pro-for-dspic/
Installato il programma,apritelo
andate su tools
GLCD Bitmap Editor
Selezionate KS0108
Fate Load BMP
Selezionate la vostra Immagine
Poi Fate "Copy Code to ClipBoard"
A quel punto non dovete fare altro che incollare tutto nel vostro main o la vostra libreria (Fate come più vi piace)
Questo è il vettore contenente la nostra immagine:
// ------------------------------------------------------
// GLCD Picture name: Immagine.bmp
// GLCD Model: KS0108 128x64
// ------------------------------------------------------
const code char Immagine[1024] = {
16, 82, 33, 32, 0, 40, 70, 12, 32, 173, 129, 64, 32, 26, 0, 0, 0, 0, 1, 200, 0, 1, 130, 133, 136, 129, 194, 195, 226, 224, 233, 224, 240, 240, 240, 248, 248, 248, 248, 252, 252, 252, 252, 252, 252, 254, 254, 254, 254, 254, 254, 254, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 254, 254, 254, 254, 254, 254, 254, 254, 252, 252, 252, 252, 252, 252, 254, 248, 249, 248, 242, 240, 240, 232, 224, 224, 228, 192, 212, 130, 128, 128, 128, 0, 18, 176, 32, 0, 0, 24, 6, 0, 176, 36, 66, 3, 202, 0, 48, 1, 92, 0, 130, 0, 28, 8,
0, 100, 0, 0, 6, 141, 48, 32, 32, 160, 132, 224, 242, 224, 241, 248, 250, 252, 252, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 254, 254, 252, 252, 248, 251, 241, 240, 232, 192, 140, 132, 4, 13, 6, 176, 32, 133, 8, 17, 18, 128,
20, 8, 0, 193, 56, 56, 60, 62, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 191, 191, 191, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 62, 61, 56, 52, 193, 0, 0, 1, 1,
224, 30, 1, 0, 255, 255, 255, 131, 131, 131, 199, 255, 254, 126, 0, 0, 0, 192, 224, 240, 48, 48, 48, 240, 224, 224, 0, 0, 192, 224, 240, 112, 48, 48, 32, 255, 255, 255, 0, 0, 0, 255, 255, 255, 195, 195, 195, 255, 255, 190, 0, 0, 0, 112, 48, 48, 48, 48, 112, 240, 224, 192, 0, 0, 240, 240, 240, 64, 96, 112, 112, 0, 192, 224, 240, 112, 48, 48, 112, 240, 224, 192, 0, 0, 240, 240, 240, 96, 96, 112, 240, 240, 224, 192, 0, 3, 3, 3, 3, 255, 255, 255, 255, 3, 3, 3, 3, 0, 0, 255, 255, 255, 127, 248, 224, 128, 224, 248, 63, 255, 255, 255, 255, 0, 1, 30, 224, 0,
7, 120, 128, 0, 63, 63, 63, 1, 1, 3, 15, 31, 62, 60, 48, 32, 0, 15, 31, 63, 51, 51, 51, 51, 51, 59, 3, 0, 15, 31, 63, 48, 48, 48, 24, 63, 63, 63, 0, 0, 0, 63, 63, 63, 48, 48, 48, 57, 63, 31, 15, 0, 0, 30, 62, 63, 51, 51, 19, 63, 63, 63, 0, 0, 63, 63, 63, 0, 0, 0, 0, 0, 15, 31, 63, 48, 48, 48, 56, 63, 31, 15, 0, 0, 63, 63, 63, 0, 0, 0, 0, 63, 63, 63, 0, 0, 0, 0, 0, 63, 63, 63, 63, 0, 0, 0, 0, 0, 0, 63, 63, 63, 0, 1, 7, 7, 7, 1, 0, 63, 63, 63, 63, 0, 128, 120, 7, 0,
128, 64, 0, 3, 12, 24, 56, 120, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 120, 56, 24, 12, 3, 0, 0, 128, 0,
104, 20, 68, 118, 250, 84, 136, 211, 92, 17, 113, 23, 7, 15, 31, 159, 31, 63, 63, 127, 127, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 127, 255, 63, 127, 63, 31, 47, 135, 39, 163, 17, 1, 0, 0, 128, 192, 80, 80, 192, 1, 0, 0,
104, 122, 76, 115, 203, 253, 255, 123, 62, 242, 250, 118, 150, 136, 44, 200, 128, 144, 252, 176, 158, 180, 248, 249, 113, 225, 151, 171, 39, 151, 199, 167, 175, 143, 15, 191, 127, 31, 31, 63, 63, 63, 63, 63, 63, 127, 127, 127, 127, 127, 127, 127, 127, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 127, 127, 127, 127, 127, 127, 127, 127, 63, 63, 63, 63, 63, 63, 31, 31, 31, 31, 15, 15, 15, 7, 7, 7, 15, 3, 7, 133, 65, 17, 128, 128, 16, 164, 20, 9, 1, 34, 1, 0, 25, 192, 39, 2, 158, 128, 6, 0, 9, 1, 0, 24, 0, 66
};
3a Dove metto tutta questa roba nel main?
Nel main di arduino inserirò nell'esempio di prima che ho messo come file allegato le nuove funzioni per la visualizzazione delle immagini e la dichiarazione del vettore contenetne l'immagine vera e propia...
su Arduino Procederò in questo modo:
Definizioni.
Vettore immagine.
Prototipi.
Setup().
Main().
All'interno del main ho richiamato:
///////////////// Immagine,Colore,lunghezza,alteza,x iniziale,y iniziale
h è l'altezza pari a 64
l è la lunghezza della nostra immagine = 128
infine x,y =0 perche l'immagine prende tutto lo schermo...
GLCD_WriteForImm(Immagine,0,128,64,0,0);
delay(5000);
//stessa cosa ma con colore invertito
GLCD_WriteForImm(Immagine,2,128,64,0,0);
delay(5000);
Cioè non faccio altro che visualizzare l'immagine che abbiamo appena creato....
Prima normale come l'abbiamo disegnata: Color=0; poi Invertita Color=2;
Questo è il video di ciò che abbiamo creato.... Spero di essere stato utle a tutti quelli che leggeranno!!!
Datasheet:
SE QUALCUNO TROVA ERRORI IN CIO CHE LEGGE O SEMPLICEMENTE PENSA CHE QUALCOSA NON SIA CHIARA MI PUO CONTATTARE E CERCHERO DI RISCRIVERE IN MODO PIU' CHIARO!
Accetto anche Ramanzine per eventuale scarsa conoscenza della mia lingua con parole o frasi scritte male...
Per tutti quelli invece ch credono che ciò che ho scrito siano tutte st...ate possono tranquillamente lasciare questo sito senza alcun rancore...