Programmazione dello schermo Touch Screen su

Programmazione dello schermo Touch
Screen su EasyPic5
1)
2)
3)
4)
5)
6)
7)
8)
9)
10)
11)
12)
13)
Schermo GLCD (Graphic LCD) + Schermo Touch-Screen.
Schermo LCD a 2 righe.
PIC16F887.
Display 7-segment (X4)
Entrate PORTA PORTB PORTC PORTD PORTE (X8 X8 X8 X8 X4).
Uscite PORTA PORTB PORTC PORTD PORTE (X8 X8 X8 X8 X4).
Dip-switch per selezione modalità d'uso.
Interfaccia di programmazione.
Interfaccia di alimentazione esterna.
Convertitore analogico digitale.
Zoccoli per eventuali PIC.
Programmazione seriale
Uscite PORT esterne.
Area di progetto 4AT 2008/09
Software di programmazione
Suite di programmazione Mikroelektronika contenente: 1) Ambiente di sviluppo MikroC.
2)Software di programmazione PicFlash.
3)Driver di interfacciamento PC ↔ PIC.
Progetti
In totale sono stati portati a termine 6 progetti.
1)
Uso generale del GLCD.
2)
Uso del GLCD per generare un segmento con estremi 2 punti premuto sul TouchSreen.
Autore: Calenda Marco & Barbon Christian & Michieletto Matteo
3)
Uso del GLCD per generare un cerchio trascinabile dall'utente.
Autore: Calenda Marco & Barbon Christian
4)
Uso del GLCD per generare un semplice tastierino numerico.
Autore: Calenda Marco & Barbon Christian & Michieletto Matteo
5)
Uso del GLCD per creare una calcolatrice in grado si sommare sottrarre e moltiplicare.
Autore: Barbon Christian & Michieletto Matteo
6)
Uso del GLCD per visualizzare un breve filmatino in stile GIF.
Autore: Calenda Marco
7)
Uso del GLCD per ricreare il giochino del pinball tramite TouchScreen.
Autore: Calenda Marco
8)
Uso del GLCD per ricreare il giochino del campo minato (ancora in fase di sviluppo).
Autore: Barbon Christian
Progetto 1, L'uso del GLCD
L'uso del GLCD è molto ostico all'inizio e necessita di numerose prove prima di trovare la
configurazione di pin, jumper vari.
Per cominciare NON leggete il manuale delle istruzioni perché le indicazioni riportate sono
SBAGLIATE. Probabilmente in fase di traduzione sono stati fatti degli errori.
Configurazione funzionante per fare funzionare il GLCD:
1)Settare tutti i dip-switch (in figura n 7 in alto) su OFF.
2)Settare tutti i dip-switch (in figura 7 in basso) su ON tranne quello per la
retroilluminazione del
LCD.
1)Off,off,off,off,off,off,off,off 2)on,on,on,on,on,on,off,on.
3)Scollegare tutti i jumper nell'interfaccia del convertitore analogico ↔ digitale.
Progetto 2, Segmento tra due punti
NOTA: La programmazione del PIC è abbastanza difficoltosa perché Microc rileva SOLO gli errori
sintattici, e non quelli logici. Quindi fate attenzione a tutti i warning che vi da e tentate di fare in
modo che prima di programmare il pic non ce ne sia neanche uno!
A volte potrebbe darvi errori del tipo :” Const_(ecc ecc).Trunched” ecco per risolverli (di solito li da
quando tentate di scrivere un stringa con la funzione GLCD_Write_text()) dovete definire la stringa
che volete scrivere come una variabile e dirgli di scrivere quella. Supponiamo che lo faccia per un
problema di ram. Il programma è allegato in nell'appendice.
Progetto 3, Il cerchio
Disegnare un cerchio non è difficile, c'è la funzione apposita. Il problema era spostarlo, ingrandirlo
o rimpicciolirlo e tramutarlo in un quadrato. Con l'aiuto dei flag non è stata difficoltosa la
realizzazione di tale progetto ed è ampiamente commentato nell'appendice.
Progetto 4, Il tastierino numerico
É stato il programma più noioso che abbiamo fatto ma vi consiglio di studiarlo ugualmente perché e
propedeutico al successivo progetto, quello della calcolatrice.
Il programma non fa altro che stampare sul GLCD dei “box” con scritti all'interno dei numeri e
rilevando la pressione su uno di essi lo scrive a lato.
Di per se il programma non è difficile. Basa rilevare la coordinata di dove si è premuto e poi
controllare se il punto è interno ad uno dei box, e se si viene stampato il numero corrispondente.
Progetto 5, La calcolatrice
Ripescando il file dell'esercizio precedente non è difficile memorizzare i numeri premuti per poi
sommarli, sottrarli o moltiplicarli a seconda del tasto di operazione premuto. Tutto allegato in
appendice.
Progetto 6, La gif e il tool BitmapToGlcd
Ebbene si. Eravamo ad un punto morto dell'area progetto . Fu così che navigando nei meandri del
software Mikroc trovammo un voce che suonava più o meno così :”Bitmap to Glcd converter”. Con
questa tool, abbinata alla funzione GLCD_Image() era possibile trasformare una bitmap
monocromatica di opportune dimensioni in una matrice di int, interpretabile poi dalla funzione che
la stampava sul GLCD. E allora per divertimento abbiamo creato una simpatica scenetta di un
omino che spara ad un altro omino. XD
Progetto 7, Il pinball
Probabilmente il programma più difficile insieme al campo minato. Nel GLCD viene disegnata la
tipica barretta del pinball scorrevole tramite touchscreen insieme ad un pallina che cade verso terra,
i limiti del GLCD sono i limiti dell'area di gioco. Per elaborare tutti i rimbalzi della pallina si è
ricorso a una variabile flag che a seconda del numero che portava codificava una determinata
angolazione. Per esempio flag=1 la pallina sta cadendo in basso verso sinistra oppure flag=0 la
pallina sta salendo in alto a destra ecc ecc.
Ovviamente cadono anche i tipici “regali” che allungheranno la barretta di gioco.
Conclusione
L'uso del GLCD è molto simpatico ma risulta ostico all'inizio. Non scoraggiatevi e provate e
riprovate i programmi. Una volta capita la meccanica di funzionamento risulterà molto più facile
programmare questo componente.
Esempio di programma in C
/*Programma per basetta EasyPic5 con PIC16F887.
Il programma simula il gioco del pinball mediante lo schermo touch screen
e permette di spostare la barretta orrizzontale tramite la semplice
pressione tramite un semplice pennino per palmari.*/
unsigned int x_coord, y_coord;
long
int
x_coord128, y_coord64;
// le coordinate x e y scalate
cal_x_min, cal_y_min, cal_x_max, cal_y_max; // le costanti di calibrazione
char text1[] = "BASSO SX";
char text2[] = "ALTO DX";
const unsigned int ADC_THRESHOLD = 50;
pannel
// Il minimo valore di pressione primia di attivare il touch
int x1=0;
int y1=0;
int x2;
int y2;
int cont=0;
char punts[7];
int xpall=12;
int ypall=11;
int xregalo=45;
int yregalo=0;
int barra=10;
int flag=0;
int punt=0;
// ritorna uno se è stata rilevata una pressione altrimenti ritorna 0
char PressDetect() {
unsigned adc_rd;
char result;
// rilevamento pressione
PORTC.F0 = 0;
// DRIVEA = 0
PORTC.F1 = 0;
// DRIVEB = 0
Delay_us(3500);
adc_rd = ADC_read(1);
result = (adc_rd > ADC_THRESHOLD);
//ripete ilò detect dopo 2 millisecondi
Delay_ms(2);
adc_rd = ADC_read(1);
result = result & (adc_rd > ADC_THRESHOLD);
return result;
}
unsigned int GetX() {
unsigned int result;
//legge la x
// legge
// se è rilevato un uno logico
PORTC.F0 = 1;
// DRIVEA = 1
PORTC.F1 = 0;
// DRIVEB = 0
Delay_ms(5);
result = ADC_read(0); // legge il valore della x da ra0
return result;
}
unsigned int GetY() {
unsigned int result;
//legge la y
PORTC.F0 = 0;
// DRIVEA = 0
PORTC.F1 = 1;
// DRIVEB = 1
Delay_ms(5);
result = ADC_read(1); // legge il valore della y da ra1
return result;
}
void Calibrate() {
Glcd_Dot(0,63,1);
Glcd_Write_Text(text1,10,3,1);
while (!PressDetect());
//legge le costanti di calibrazione per ovviare alla non linearità dello scermo touch pannel
cal_x_min = GetX() - 10;
cal_y_min = GetY() - 10;
Delay_ms(100);
Glcd_Fill(0);
Glcd_Dot(127,0,1);
Glcd_Write_Text(text2,10,4,1);
while (!PressDetect()) ;
// stessa cosa di sopra
cal_x_max = GetX() + 5;
cal_y_max = GetY() + 5;
Delay_ms(100);
}
void main() {
PORTA = 0x00;
TRISA = 0x03;
TRISB = 0x00;
// RA0 e RA1 sono input analogici
ANSEL = 0x03;
TRISE = 0xf8;
ANSELH = 0;
// il resto digitale
PORTC = 0 ;
TRISC = 0 ;
// PORTC è in uscita
Sound_Init(&PORTE, 3);
Glcd_Init(&PORTB, 0, 1, 2, 3, 5, 4, &PORTD); // inizializzo lcd
Glcd_Fill(0);
Glcd_Set_Font(FontSystem5x8, 5, 8, 32);
Glcd_Write_Text("Calibrazione", 24, 3, 1);
Delay_ms(1500);
Glcd_Fill(0);
Calibrate();
//calibro il touch pannel
Glcd_Fill(0);
while (1){
while (1){
glcd_fill(0);
x2=x1+barra;
//calcolo la coordinata della parte destra della barretta
Glcd_Box(x1,60,x2,61,1);
//disegno la barretta
Glcd_Circle(xpall,ypall,1,1);
//disegno la pallina
if (punt>1 ) {Glcd_Box(xregalo,yregalo,xregalo+3,yregalo+3,1);yregalo++;}
//se si è arrivati ad un determinato punteggio disegno anche un regalo
if (ypall==59 && xpall<x2 && xpall>x1) {if (flag==0) flag=1;
//se la palla colpisce la barratte la faccio rimbalzare
if (flag==2) flag=3;
punt++;}
if (yregalo==59 && xregalo<x2 && xregalo>x1) {barra+=5;}
//se il regalo colpisce la barretta la faccio allungare
if (yregalo==59) {punt=0;yregalo=0;xregalo++;}
if (ypall==0 )
//in ogni caso quando arriva alla fine azzero il punteggio
{if (flag==1) flag=0;
//se la pallina colpisce il bordo la faccio rimbalzare tenendo conto dell'angolazione di impatto
if (flag==3) flag=2;
punt++;
if (xpall==0 )
}
{ if (flag==2) flag=0;
if (flag==3) flag=1;
punt++;
if (ypall==64)
}
{glcd_fill(0);
// se cade il giocatore perde
Glcd_Write_Text("Scarsoooooo", 24, 3, 1);
delay_ms(1000);
break;}
if (xpall==127 )
{if (flag==0) flag=2;
if (flag==1) flag=3;
punt++;
}
if (flag==0) {xpall++; ypall++;}
//in base al falg settato la pallina si muoverà con determinate angolazioni
if (flag==1) {xpall++; ypall--;}
if (flag==2) {xpall--; ypall++;}
if (flag==3) {xpall--; ypall--;}
if (PressDetect()) {
//e questa è la funzione che permetterà di spostare la barretta
//y1=GetY();
x_coord = GetX() - cal_x_min;
y_coord = GetY() - cal_y_min;
x1 = (x_coord * 128l) / (cal_x_max - cal_x_min);
y1 = (64 -(y_coord *64) / (cal_y_max - cal_y_min));
if ((x1 < 0) || (x1 > 127))
continue;
if ((y1 < 0) || (y1 > 63))
continue;
}
}
xpall==12;
ypall==11;
barra=10;
}
}