Identificazione progetto

Filmato del progetto

Potete vedere un filmato del test del progetto in questo link

Scarica il file .hex da questo link.

Scarica sorgenti per MplabX e Hitech C

Scarica lo schema elettrico del progetto in formato Eagle V6.3

Scarica lo schema elettrico del progetto in formato immagine PNG

Potete richiedere il vostro esemplare della Micro-GT IDE o mini via e-mail all'indirizzo  ad.noctis@gmail.com

Premessa    Scarica l'articolo in formato DOC

Appassionato di elettronica fin da ragazzo, non mi è mai stato possibile trovare il tempo per dedicarmi concretamente a studiarne i principi. Da neo pensionato, finalmente ho potuto realizzare il mio sogno ed adesso mi sfogo cercando di apprendere più possibile quanto la scienza dell’elettronica può darmi.

In particolar modo, avendo svolto il lavoro di informatico, per ragioni di lavoro, mi sono appassionato ai microcontrollori PIC, ho fatto tante scorpacciate di libri, ho comprato tante schede molto pubblicizzate, ho studiato come un matto i vari testi e le varie riviste acquistate nel tempo acquisendo molte informazioni e molta cultura specifica. A conti fatti potevo costatare che mi mancava sempre qualcosa che non mi permetteva di sviscerare a fondo le questioni di mio interesse, cercando poi di realizzare qualcosa, dovevo sbattere la testa qua e là cercando il pezzo mancante per testare o completare il puzzle che qualche volta, non per mia volontà restava incompleto.

Ho avuto la fortuna tramite, la comunità di GRIX, di conoscere l’Ing. Marco Gottardo e di conseguenza le Sue pubblicazioni, le Sue realizzazioni, in particolare le Sue schede Micro GT versatile IDE e la versione più piccola Micro GT mini, tutte FREEPORT. Questa conoscenza mi ha dato l’opportunità di frequentare il Centro Culturale ZIP di Padova dove Egli tiene dei corsi inerenti sia i microcontrollori che i PLC, oltre a corsi tipo elettronica, elettrotecnica, informatica ed altro in genere.

Benedetto il Signore che mi ha messo su questa strada! Finalmente ho potuto colmare le mie lacune e chiarirmi i molti dubbi che mi assillavano lasciandomi come un "pesce lesso", mi hanno aiutato molto anche le molteplici pubblicazioni edite sempre dallo stesso Ing. Gottardo.

Oltretutto, avendo acquistato le due predette schede, finalmente sono libero di testare e creare ciò che mi passa per la testa, senza i limiti che altri hardware mi imponevano, ho messo da parte tutta la ferraglia precedentemente acquistata ed adesso finalmente mi sto sfogando come meglio mi aggrada, disponendo di attrezzature FREEPORT che posso gestire secondo mia volontà.

La scheda Micro GT versatile IDE, inoltre, ha le interfacce per le periferiche a bordo per Display LCD, Display Grafico 128x64 punti, display sette segmenti  oltre che le interfacce di potenza per pilotare direttamente uno stepper motor (o in alternativa due motori DC dino a 2A cisacuno), un ponte H fino 8A per pilotare un motore di potenza più grosso. Ovviamte ha le cose ovvie come un elevato numero di I/O digitali e analogici.

Le figure seguenti ritraggono rispettivamente alla Micro GT Versatile IDE ed alla Micro GT mini:

Ho di recente frequentato il corso inerente i microcontrollori PIC presso il Centro ZIP di Padova, egregiamente tenuto dall’Ing. Gottardo, corso sostanzialmente riferito alla pubblicazione LET’S GO PIC!!! (Versione Inglese), di cui lo Stesso ne è l’autore; Adesso, ricco della cultura e dell’esperienza acquisite durante il corso, sia approfondendo, con il predetto libro, ogni argomento trattato, ho deciso di mettere in opera quanto appreso e di realizzare alcune creazioni che da tempo mi prefiggevo di costruire per mio piacimento ed utilità.

La prima di queste consiste in un termometro che possa rilevare la temperatura interna ed esterna alla mia autovettura che ne è priva. Esistono, in vendita, svariati accessori, anche a poco prezzo, che  fanno egregiamente questo lavoro, ma credo che un elettronicofilo (permettetemi questa licenza diciamo poetica!) debba avere il piacere di godersi le sue creazioni con la soddisfazione di vederle funzionare compiacendosene anche e traendone l’utilità per cui sono state progettate.

Quale migliore opportunità per sfruttare quanto predetto!

Preciso che questo progetto non è tutta farina del mio sacco, ma deriva principalmente dagli esercizi del corso e dall’esperienza in esso maturata, così ho potuto riprogettare il tutto a mio intendimento e, disponendo della Micro-GT versatile IDE, ho potuto testare realmente ed in toto il funzionamento dell’insieme prima di procedere alla realizzazione del relativo PCB e passare alla effettiva realizzazione del progetto. La versatilità della scheda Micro-Gt consente di poter correggere eventuali errori di progettazione, di effettuare modifiche in corso d’opera, liberandoti dall’unica alternativa di ricominciare il tutto dall’inizio con grande spreco di materiale e di tempo. Inoltre è possibile vedere il progetto funzionare realmente, anche se assemblato in via provvisoria.

Schema elettrico con descrizione

(Lo schema, in formato Eagle, del circuito che intendo realizzare è scaricabile dal seguente LINK,:

Download schema elettrico Misurare le temperature interna e esterna con LM35

Mia prima preoccupazione era di testare se quanto era nelle mie intenzioni e quanto progettato fosse realmente funzionante e di poter testare in anteprima il progetto senza interessarmi della realizzazione, anche minima, di un hardware atto a soddisfare i miei test per, successivamente, passare alla fase definitiva, ho potuto soddisfare la mia esigenza con la Micro GT versatile IDE.

Attualmente il progetto gira perfettamente nella Micro-GT IDE con a bordo il PIC della Microchip PIC16F877A (40 pin), ma è mia intenzione realizzare una versione per il PIC 16F876 (28 pin) per applicarla alla Micro-GT mini.

Questa prima versione del progetto prevede l’impiego di due sensori LM35 che, configurati come nella figura sottostante, possono spaziare in un range di temperatura che va da +2 °C a +150 °C.

Il progetto è stato buttato giù di getto per sperimentare i suddetti sensori ed acquisirne la dovuta confidenza e conoscenza, infatti questo progetto è la base di test per un secondo, concepito per la gestione di un acquario, la prossima realizzazione comunque prevederà sempre l’impiego degli LM35, ma configurati come nell’immagine successiva, in modo tale da poter rilevare temperature in un range che va da -55 °C a +150 °C.

Di seguito è possibile vedere lo schema del progetto, ancora da perfezionare, infatti, per il momento questo non è l’argomento da trattare, mio scopo attuale è di creare un software in grado di gestire, secondo necessità, sia i due sensori di temperatura che un display LCD a 2 righe per 16 caratteri; Per l’hardware, continuo a ripetere, ho utilizzato la scheda Micro-GT versatile IDE che permette di interfacciare tutte le periferiche, in modo FREEPORT cioè di connetterle, attraverso stripline, direttamente ai pin del PIC, consentendo di testare il progetto senza, almeno inizialmente, far perdere tempo con la realizzazione del PCB, con la saldatura dei componenti ed altro.

Questo schema, comunque, può aiutare a comprendere quali sono i collegamenti dei componenti illustrando, anche, la filosofia della realizzazione.

 Nella parte alta è rappresentata la zona dell’alimentazione, si notano i due IC 7812 e 7805 ed in particolare i due diodi D1 e D2 che collegati al pin "GND" del 7812 consentono di poter disporre, in futuro, dei 13,2V necessari per la programmazione ICSP, stesso scopo ha il connettore SV1, occorre fornire in ingresso una tensione sufficientemente superiore ai 13,2V (15V vanno molto bene, tuttavia per il momento non affrontiamo l’argomento che merita una trattazione separata e più completa).

I due LM35 sono alimentati a 5V ed i due segnali sono connessi ai pin 2 e 3 del PIC16F877A corrispondenti ai PORT RA0 e RA1 ovvero agl’ingressi analogici AN0 ed AN1, il pin 5 (RA3) è utilizzato come ingresso per la tensione di riferimento positiva, una sorta di soglia superiore al quale può arrivare il valore massimo raggiunto dal valore analogico in campo da inviare al convertitore integrato nel PIC, ovvero un ADC a 10 bit.

In altre parole, anche se il chip è alimentato a Vdd = 5V, la porzione dell'architettura interna che riguarda i convertitori, l’ADC sarà alimentato a questa Vref (voltaggio fornito dal signal output del LM35) utilizzata come soglia. Dal momento che il datasheet dell’LM35 indica la tensione di 10mV per ogni grado centigrado di temperatura produrrà solo 1V a 100 gradi centigradi. Se usiamo come valore di 2,5 V Vref ci troveremo all'incirca nel centro banda e non di un quinto.

Lo schema prevede, fra l’altro, il pulsante S1 che permette il RESET del microcontrollore, un quarzo a 20 Mhz con i due condensatori da 18 pF, usato come oscillatore esterno, uno zoccolo TEXTOOL per l’alloggiamento del PIC (nella realizzazione finale sarà utilizzato un socket 40 pin DIL), un display 2 righe per 16 caratteri (standard HD44780/HD47780, interfacciato con il metodo a 8 bit), il trimmer TR3 per la regolazione del contrasto del display, la resistenza R5  al pin 14 del display e la resistenza R6 che limita a circa +4,2V la tensione per la retroilluminazione, in serie al diodo D5 che evita problemi per eventuali errate connessioni.

Le immagini che precedono mostrano la scheda Micro-GT versatile IDE, in funzione, completa dei vari componenti previsti dal progetto (nella seconda specificati per tipo e/o mansione), opportunamente collegati, tramite cavetti di facile costruzione casalinga, ai vari pin delle stripline che, consentono di dialogare direttamente con i PORT del PIC.

Nell’immagine seguente si nota il display 2 linee x 16 caratteri, indicante le temperature rilevate dai sensori LM35 alla sua destra, a sinistra è stato posto un termometro per auto, interno/esterno, acquistato al costo di pochi €uro, che mostra le temperature registrate dai suoi sensori, come si può notare tutte le rilevazioni si aggirano attorno ai 26°C, le piccole differenze sono accettabili, e comunque per quanto riguarda gli LM35 rientrano nella tolleranza prevista e voluta di 0,5°C. Le indicazioni del termometro comprato, sono prese in considerazione soltanto a livello indicativo e comunque non si discostano molto da quelle rilevate dai sensori del progetto

Analizziamo adesso i componenti principali e come, in particolare, si collegano alla Micro-GT, pertanto riporto lo schema dei componenti della scheda completo di tutte le indicazioni relative alle strip-line, agli switch ed ai jumper per le opportune configurazioni.

Bisogna, anche, comprendere il significato dei 16 pin del display LCD 2 x 16 e quelli dell’LM35.

Vediamo per primo il display LCD 2 x 16.

I pin 1 e 2, Vss e Vdd, sono rispettivamente la massa e l’alimentazione a +5V, nella Micro-GT vi sono svariate possibilità di prelevare sia la massa che i 5+V;

il pin 3, Vo, collegato al centrale del trimmer TR2 permette la regolazione del contrasto del display LCD, nella foto precedente è quello insieme al condensatore elettrolitico;

i pin 4, 5 e 6, RS, RW ed E, vanno collegati rispettivamente ai pin 10, 9 e 8 del PIC16F877A, ovvero alle porte RE0, RE1 e RE2, che nei PIC delle famiglie a 40 pin, sono state progettate proprio per assolvere i compiti specifici per le funzioni RS, R/W ed E, ovviamente occorre redigere opportunamente il codice relativo per la loro gestione, nei PIC privi del PORT E (PIC 28 pin o inferiori), occorre utilizzare altre porte anche se non specificatamente previste per lo scopo. Nella Micro-GT sono da utilizzare i pin della strip SV24;

-       Il pin RS - Register Select - è la linea di controllo con la quale il microcontrollore comunica al display se sta inviando sul bus (righe DB0 a DB7) un comando (RS = 0) oppure un dato (RS = 1);

-       il pin - R/W Read, Write - è un'altra linea di controllo con la quale il microcontrollore comunica al display se si intende inviargli un dato (R/W = 0) o leggerne (riceverne) uno (R/W = 1);

-       il pin - E Enable - è una linea di controllo con cui è possibile attivare il display affinchè acquisisca dati ed istruzioni tramite il bus dati (E = 1);

i pin dal 7 al 14, DB0 ~ DB7, fanno parte del BUS in cui viaggeranno i dati da visualizzare o i comandi di controllo che il display LCD deve eseguire, questi pin, nel nostro caso collegati al PORTB, possono essere configurati adeguatamente per usarli in modalità 8 bit o modalità 4 bit, nel nostro caso ho preferito la modalità 8bit. Nella Micro-GT utilizzare i pin della strip SV17;

i pin 15 e 16, A/Vee e K, sono rispettivamente il positivo (+4,2V) e la massa che alimentano la retroilluminazione del display.

Per quanto riguarda il sensore LM35, ci sono solo 3 pin da collegare:

il +Vs nel nostro caso a +5V, la massa ed il Vout (in posizione centrale) che restituirà il valore di temperatura sotto forma di mV.

La risoluzione del sensore, data dal databook comporta che a 10mV (0,010mV), corrisponderà un valore di 1°C, e così via in maniera lineare.

Descrizione del firmware

Prima di dedicarci al codice del firmware, c’è da trattare l’argomento relativo all’acquisizione di segnali analogici, infatti, gli LM35 forniranno al PIC dei segnali sotto forma di tensione (mV) che, convertiti in formato digitale, saranno poi trattati opportunamente per ottenere il corrispondente in gradi di temperatura.

Pertanto, è essenziale parlare dei registri ADCON0 e ADCON1 prima di procedere con la scrittura del software e capire come configurarli adeguatamente.

Riferiamoci alla tabella di pag. 217 del testo LET’S GO PIC !!! The Book, che specifica il significato di alcuni bit del registro ADCON1:

Analizzandola possiamo notare, nella prima colonna a sinistra, indicati i 4 bit meno significativi del registro ADCON1 (PCFG0, PCFG1, PCFG2 e PCFG3);

La tabella prevede 15 combinazioni corrispondenti alle sue 15 righe. Ognuna mostra come viene utilizzato il pin DIGITAL I/O commutato per funzionare come ingresso ANALOGICO, confrontando il contenuto della prima colonna a sinistra con la prima colonna a destra.

È meglio capire, inoltre, qual è il significato dei BIT contenuti nei registri ADCON0 e ADCON1:

ADCON0

0 - ADCS1 Frequenza oscillatore
1 - ADCS0 Fosc/8 (1/4Mhz=0.23uS .25*8=2uS minimo 1.6uS)
0 - CHS2 Seleziona l'ingresso dell'ADC
0 - CHS1 Seleziona l'ingresso dell'ADC
0 - CHS0 Seleziona l'ingresso dell'ADC
0 - ADGO Mettere a 1 per inizio conversione, 0  per fine conversione.
0 - non usato
0 - ADON ON/OFF ADC (1 ON); Quando è ON assorbe potenza
 

ADCON1

1 - ADFM Risultato giustificato a destra (0 SX)
0 - non usato
0 - non usato
0 - non usato
0 - PCFG3 Tutti ingressi analogici
0 - PCGG2 Vref
0 - PCFG1 Vdd
0 - PCFG0 Vss

Tenendo presente la configurazione scelta, effettuata nella tabella di prima (per le mie necessità ho utilizzato la configurazione della riga 6 con Chan/Ref "2/1",

ovvero 2 canali analogici più 1 canale per la tensione di riferimento +Vref), nonché quanto previsto dal data-sheet del PIC16F877A, che spiega come impostare tali registri per questo microcontrollore, è possibile adesso impostare i due registri, che fatte le opportune valutazioni vanno configurati nel modo seguente:

ADCON0=0b11cccn0n (c = canale n = 1 o 0)

ADCON1=0b10001010

abbiamo:

dalla stessa tabella rileviamo che i 2 canali analogici da usare sono AN0 e AN1 mentre quello abilitato come tensione di riferimento +Vref, sempre dalla tabella si vede essere RA3.

Per generare il corretto valore di riferimento ho posto il voltmetro tra il cursore del trimmer R1 (nel mio caso ho usato un potenziometro) ed il riferimento a massa più vicino e ruotato il trimmer fino ad avere un valore il più vicino possibile a 2,5 volt.

La risoluzione ADC può essere facilmente ottenuta sapendo che il valore di fondo scala impostato è 2,5 V, da cui si ricava che la risoluzione del segnale  analogico è = 2500/1024 = 2,44 mV ;

Siccome il sensore LM35 restituisce 10mV (0,010 V) per ogni °C abbiamo:

(risoluzione analogica x 2,44 x 1000) / (1000 x 10[mV/°C]) = (risoluzione analogica x 2440 / 100 )

È arrivato il momento di vedere il codice del firmware scritto e di commentarlo convenientemente;

il software si compone sostanzialmente di un file principale "temperatura.c", delle librerie "Delay.h", "ADC.h", "LCD.h" e "leggi_sensori.h" che si aggiungono a quelle del compilatore, analizziamo il tutto, un file  alla volta, attraverso i commenti del codice stesso, comunque, nel file principale in sostanza c’è poco, infatti oltre alle inclusione delle librerie, ad alcune definizioni, alla configurazione dei FUSES, non c’è molto altro, il tutto viene praticamente effettuato dalle funzioni contenute nelle librerie del programmatore, ciò fa si che il codice risulta più pulito e poco esteso.

 Scarica il firmware completo per MPLAB X

****************************

File sorgente temperatura.c

/************************************************
*           Autore - Giuseppe Bonfiglio                             *
* Visualizza i valori di canali analogici su LCD 2 x 16 *
* Rilevazione temperature Interna ed Esterna           *
* tramite due sensori LM 35 in fascia positiva             *
* da 2 °C a 150 °C                                                            *
* 30 agosto 2013                                                             *
* Progetto Misurazione di  Temperatura   su 2 canali *
* Piattaforma - Micro-GT IDE                                        *
* MPLAB - X Vers. 1.81                                                 *
* Compilatore  HI-TECH PICC (v. 9.81)                     *
* MCU - PIC 16F877A                                                   *
* Sorgente - temperatura.c                                          *
************************************************/

#define _LEGACY_HEADERS // permette di acquisire la sintassi dei compilatori precedenti


// Inclusione delle librerie standard del compilatore
#include<pic.h>
#include<stdio.h>
#include<stdlib.h>
#include<math.h>

// Inclusione di librerie create dal programmatore
#include"Delay.h"
#include"ADC.h"

// Assegnazione dei PORT ______ alle funzioni EN, R/W e RS
#define EN RE0 //SV 24 pin 3 della Micro GT IDE
#define RW RE1 //SV 24 pin 2 della Micro GT IDE
#define RS RE2 //SV 24 pin 1 della Micro GT IDE

__CONFIG (HS & WDTEN & PWRTDIS & BORDIS & LVPDIS & DUNPROT & WRTEN & DEBUGDIS & UNPROTECT); // Configurazione dei Fuses

// Predichiarazione delle varie funzioni che saranno richiamate dal codice
void CLOCK ();
void CLEAR ();
void CONFIGURA ();
void INIZIALIZZA ();
void splash ();
void VAI (unsigned char r, unsigned char c);
void SCRIVI (char lettera);
void FRASE (unsigned char l, unsigned char n, const char* msg1);
void Rileva_temperatura (int canale, int riga);

// Inclusione di altre 2 librerie create dal programmatore
#include"LCD.h"
#include"leggi_sensori.h"

void main (){ // Routine principale

CONFIGURA (); // Richiama la funzione che imposta
                             // le configurazioni occorrenti
INIZIALIZZA (); // Richiama la funzione che inizializza il display 2 x 16
CLEAR ();          // Richiama la funzione pulisce il display 2 x 16
DelayMs (10);   // Richiama la funzione di ritardo per 10Ms
splash ();           // Richiama la funzione che visualizza sul
                           // display 2 x 16 una o più frasi iniziali

while (1){           // Ciclo di loop infinito, infatti 1 = TRUE cioè sempre  VERO

Rileva_temperatura (1, 1); // Richiama la funzione che tratta la lettura del canale
                        // analogico n° 1 e dopo la relativa trasformazione in
                        // carattere e opportuna formattazione
                       // la visualizza alla riga 1 del display 2 x 16
DelayS (2);   // Richiama la funzione di ritardo per 2S

Rileva_temperatura (2, 2); // Come prima ma per il canale 2 e per la riga 2
DelayS (2);

CLRWDT (); // Azzera il WDT  Watch Dog Timer
}
}

La libreria ADC.h è studiata per leggere il valore del canale analogico "n" e di restituirne il valore alla funzione chiamante per il suo successivo trattamento.

File libreria ACD.h
/******************************************************
* MODULO PER LA LETTURA DEI CANALI ANALOGICI *
*                                                                                                     *
* chiamare la fz leggi_ad(n);                                                      *
* dove n: è il numero del canale in ingresso                            *
******************************************************/

int leggi_ad(char canale)
{
int valore;

ADCON0 = (canale << 3) + 0xC1; // enable ADC, RC osc + 193
// il 193 setta il clock ->  0xC1 = 193 = 0b11000001.
// pertanto alla fine il valore di ADCON0
// sarà uguale a: 0b00000100 + 0b11000001
// ovvero ADCON0 = 0b11000101

DelayUs(10); //Ritardo per dare modo all'A/D
// di stabilizzarsi

ADGO = 1; // Fa partire la conversione.
// Vedi quanto detto prima nella fase descrittiva

while(ADGO) // Fintanto che ADGO = 1
continue; //Attende che la conversione sia completa

valore = ADRESL; //Parte bassa del risultato
valore = valore + (ADRESH<<8); //Parte alta del risultato
// Vedi pag. 240 del testo LET’S GO PIC!!! The Book

return(valore);
}
 

La libreria leggi_sensori.h legge il valore analogico fin mV fornito prima dal canale 1 e dopo dal canale 2, trasformare il valore restituito da "float" ad "intero a base 10" e poi a "carattere", infine formatta la stringa carattere e la trasmette al display LCD che la visualizzerà, ora nella riga 1 ed in seguito nella riga 2 a seconda del canale analogico analizzato.

Per questa routine ho usato delle semplici manipolazioni di array e stringhe senza complicarmi l’anima avenso solo l’intento di vedere e comprendere a fondo tutti gli eventi, in ogni loro fase; Ci sarà tempo, in futuro, per la scrittura di algoritmi "da calli al cervello" che fanno bello il programmatore ma che non fanno capire nulla, con un colpo d’occhio, a chi si avvicina all’interpretazione del codice, perdonatemi la mia semplicità, ma posso assicurare che tutto funziona perfettamente!

File libreria leggi_sensori.h

/************************************
*       File: leggi_sensori.h          *
*                                                 *
*   Author: Giuseppe Bonfiglio   *
*                                                 *
*              Created on                 *
*     1 settembre 2013, 22.52     *
************************************/
 
void Rileva_temperatura (int can, int r) {
 
    int i;
    float TP;
    int temp;
    char buffer[5];
    char bufferOut[17] = "0"; // Verificare se pulisce la stringa
 
 
        bufferOut[14] = 44; // Virgola
        bufferOut[16] = '\0'; // Carattere di Fine Stringa
 
        bufferOut[0] = 84; // T
        bufferOut[1] = 109; // M
        bufferOut[2] = 112; // P
        bufferOut[3] = 46; // . PUNTO
        bufferOut[4] = 32; // Spazio
 
        bufferOut[7] = 116; // t
        bufferOut[8] = 46; // . PUNTO
        bufferOut[9] = 176; // °
        bufferOut[10] = 67;            // C
 
        int lunghezza = 0;
        TP = leggi_ad(can);
        temp = (TP * 2440) / 1000 ;
        itoa(buffer, temp, 10); // Conversione da intero in base 10 a carattere
                                        // con l'inserimento del risultato in buffer []
 
        i=0;
        while(buffer[i]|= '\0') { // Viene calcolata la lunghezza
            i++; // della stringa contenente il
        } // valore analogico in carattere
        lunghezza = i;
 
        switch (lunghezza) {
            case 0:
                bufferOut[11] = 32;
                bufferOut[12] = 32; // Spazio
                bufferOut[13] = 48; // 0 Zero
                bufferOut[15] = 48;
            break;
 
            case 1:
                bufferOut[11] = 32;
                bufferOut[12] = 32;
                bufferOut[13] = 48;
                bufferOut[15] = buffer[0];
            break;
 
            case 2:
                bufferOut[11] = 32;
                bufferOut[12] = 32;
                bufferOut[13] = buffer[0];
                bufferOut[15] = buffer[1];
            break;
 
            case 3:
                bufferOut[11] = 32;
                bufferOut[12] = buffer[0];
                bufferOut[13] = buffer[1];
                bufferOut[15] = buffer[2];
            break;
 
            case 4:
                bufferOut[11] = buffer[0];
                bufferOut[12] = buffer[1];
                bufferOut[13] = buffer[2];
                bufferOut[15] = buffer[3];
             break;
           }
 
    if(r == 1) {
        bufferOut[5] = 73; // I
        bufferOut[6] = 110; // n
     }
    else {
        bufferOut[5] = 69; // E
        bufferOut[6] = 120; // x
    }
 
    DelayMs(10);
 
    FRASE(r,1,bufferOut);
}
 
 

La libreria LCD.h si incarica di visualizzare nel display LCD tutti i caratteri che vengono trasmessi, analizzando il codice non è difficile comprenderne il significato, pertanto non mi dedicherò più di tanto all’argomento ed eventualmente tratterò la questione in modo più appropriato realizzando un progetto specifico per il display LCD 2 x 16.

 
/* File: LCD.h
 *
 * Gestisce la visualizzaione nel display LCD
 *
 * Created on 30 agosto 2013, 22.54
 */
 
/*
 
void CLEAR(){RS=0; RW=0;
PORTD=0x01;
CLOCK();
DelayMs(3); // da 2 a 5 millisecondi
}

void CLOCK(){EN=1;
DelayMs(1);
EN=0;
}

void CONFIGURA(){
TRISA=0xFF; // 0b11111111
TRISB=0b11111111;
TRISC=0b1111; // primo nibble ingressi, lascio libera la seriale
TRISD=0;
TRISE=0;
PORTD=0;
PORTE=0;
OPTION=0x80;
ADCON1=0b10001010;
}

void INIZIALIZZA(){RS=0; RW=0; PORTD=0x30; //PORTD=0x30 equivale gestione
// 8 bit e font 5x8
DelayMs(15);
CLOCK(); // specifiche tecniche con
// delay per 3 volte
DelayMs(10);
CLOCK();
DelayMs(10);
CLOCK();
DelayMs(10);
RS=0; RW=0; PORTD=0x38;
CLOCK();
DelayMs(1);
RS=0; RW=0; PORTD=0x08;
CLOCK();
DelayMs(1);
RS=0; RW=0; PORTD=0x0C;
CLOCK();
DelayMs(1);
RS=0; RW=0; PORTD=0x01;
CLOCK();
DelayMs(1);
RS=0; RW=0; PORTD=0x03;
CLOCK();
DelayMs(1);
}

void SCRIVI(char lettera){RS=1; RW=0; PORTD=(lettera);
CLOCK();
DelayUs(50);
}
void VAI(unsigned char r, unsigned char c){unsigned char a=0;
RS=0; RW=0;
if(r==1){a=c+127;}
if(r==2){a=c+191;}
PORTD=(a);
CLOCK();
DelayUs(50);}

void FRASE(unsigned char l, unsigned char n, const char* msg1){
while(n<=16){VAI(l,n);
SCRIVI(*msg1++);
n++;
}
n=1;
}

void splash(){ //scrive su LCD la presentazione per alcuni secondi
FRASE(1,1,"Peppe Bonfiglio");
FRASE(2,1," L' Elimo ");
DelayS(4);
CLEAR();
FRASE(1,1,"Termom. 2 sens.");
FRASE(2,1,"Interno Esterno");
DelayS(4);
CLEAR();
DelayMs(2);

};

 

Piattaforme usate:

hardware :Micro-GT versatile IDE

Software : MPLAB X IDE v1.80

Compilatore : HI-TECH PICC (v9.81)

Programmatore : Microchip PICkit^TM 3

Questo progetto è ridistribuibile secondo i termini di licenzaCreative Commons Attribuzione-Condividi allo stesso modo 3.0 Italia

  Pagina precedente