Let's GO PIC cap.18

Micro-GT con 18F2550,LCD 16x2 e sensore di pressione


Indroduzione a cura ad.noctis as Marco Gottardo.

Questo diciottesimo capitolo del tutorial "Let's GO PIC !!!" sviluppato a cura di Mirko Musto apre una nuova era per la piattaforma Micro-GT I.D.E. e la sorella minore Micro-GT mini.

Il contenuto tecnico e' molto elevato e mostra non solo come istallare il PIC18F2550 nella Micro-Gt mini, ma anche come pilotare il display LCD a 2 righe 16 caratteri e come realizzare un sistema di lettura "barometrica" che comporta l'uso dei convertitori analogici digitali.

La programmazione dei PIC 18 e' di estrazione decisamente meno "didattica" di quella dei PIC16 ma rappresenta un passo praticamente obbligato per i tecnici che hanno superato la fase di apprendimento.

Realizzazione progettazione e sviluppo a cura di Mirko Musto.

Descrizione hardware del sistema.

 


Il sistema si compone di una Micro-GT mini assemblata per la specifica realizzazione, ovvero non sono state montate  cose non direttamente impegnate quali la porta seriale di comunicazione, il traslatore di livello MAX232 e i suoi 4 condensatori elettrolitici, e' stato montato il pulsante di reset il quarzo da 20Mhz con le capacita' ceramiche da 18pF.

Opzionalmente si e' pensato di installare un poliestre da 100nF in parallelo al pulsante allo scopo di evitare dei rimbalzi (come consigliato da databook, o meglio prendendo spunto dal circuito di autoreset in fase di accensione fig.4.2 del databook).

Sono stati installati due  degli otto led di stato su  PORTC.

Non ho installato i morsetti a vite in quanto non necessari, con drastica riduzione del costo circuitale.

Molto utile e comoda risulta il connettore ICSP indicato con pickit2/3 sulla serigrafia dato che ho usato questa metodologia di programmazione del PIC, diciamo che rispetto al metodo con bootloader non cambia molto visto che sempre un cavo bisogna collegare alla Micro-GT mini (seriale o ICSP), e poi la gestione bootloader nella serie 18F e superiori è un pò più complicata in quanto prevede lo spostamento,in base al tipo di bootloader e pic, del RESET_VECTOR_ADDRESS,  HIGH_INTERRUPT_VECTOR_ADDRESS,  LOW_INTERRUPT_VECTOR_ADDRESS .

La cosa però veramente simpatica è che il bootloader lavora diretto con porta usb quindi il pic si collega direttamente al pc per caricare l'hex. Ricordiamoci che, come per la serie 16F, rimane sempre il parametro LVP attivo.

 

 

Il PIC usato e' compatibile con la struttura della Micro-GT mini, ma in realta' e' un dispositivo piu' completo e piu' complesso dei fratelli minori della serie 16F.

Scarica da cliccando qui il databook del 18F2550.

 Vediamo il pinout del PIC 18F2550

Nell'immagine sottostante vediamo l'impiego dei principali PIN utilizzati nel presente progetto, altri non sono rappresentati perche' ovvi come ad esempio il collegamento al pulsante di reset, l'alimentazione, quarzo ect. Questi li trovate nello schema elettrico della Micro-gt mini:

 

 

 

 

Il clock impiegato e' esterno a 20Mhz, ma questo chip consente l'uso di un oscillatore interno fino a 8Mhz (se non si impega la periferica USB).

Interventi circuitali importanti


Nella foto precedente notiamo la presenza del condensatore al poliestere da 220nF inserito tra il pin (14 Vusb) e massa (un pin della fila più lontana dal PIC degli streepline previsti per i servomotori, qui non montati).

La presenza di questo condensatore non e' solo utile ma assolutamente essenziale e la non installazione comporta un malfunzionamento sia del PIC che della porta USB.

Un altro accorgimento essenziale prevede l'istallazione di una resistenza da 1K potrà tra RB5 (lato PIC) e pin D7 del  display.

Questo al fine di evitare che durante l'invio del dato/carattere si verifichi la eventuale rottura della porta  D7 o RB5.

Vediamo il perche':

Il controller interno all'LCD impiega il pin D7 come segnalazione di stato busy flag. In stato di "attesa dato" (ascolto) viene posto a zero (stato idle), quando invece il controller interno del display riceve un dato e si pone in elaborazione (quindi incapace di ricevere altri dati) pone D7 a livello logico 1 (5V) fino a fine elaborazione dato (mediamente della durata di poco meno 1ms).

Normalmente i programmatori si cautelano dalla rottura del PIC (o anche dell'LCD) dovuta a valore di tensione Vcc non attesa nel pin, semplicemente impostando il pin del PORT collegato al D7 in input e facendo il polling su D7. E questa sarebbe la corretta procedura da implementare.

Es: invio istruzione al display;

      TRISB=0b00100000;   RB5 input

       while(RB5);                 finchè RB5 è tenuta a livello 1 da D7 resta li fermo

      TRISB=0b00000000;  nel momento in cui D7=0 =>RB5=0 pongo RB5 output

       Posso inviare un'altra istruzione al display; 

E' quindi una soluzione software.

Personalmente ho trovato più comodo da implementare un ritardo dopo ogni istruzione, invio dato, di 1ms più che sufficiente per aspettare le operazioni interne svolte dal display, però lascio a voi la libera scelta, nelle routine che troverete nel sorgente, ripeto,  è comunque implementato un ritardo.

Ecco il sistema Micro-GT mini + Display LCD con una vista di insieme

Per tutte le altre info riguardo il display vi rimando alla mia antecedente pubblicazione 16f877A+LCD 16x2.

 


Brevi cenni e considerazioni sul 18F2550.


L'architettura interna del 18F2550 rispetto al PIC16F876A, ovvero quello che normalmente e' impiegato nei precedenti capitoli di "Let's GO PIC !!!" mostra una sezione contenente  prescaler e postscaler che svincolano la frequenza interna da quella del cristallo, o meglio sara' dipendente da certi fattori moltiplicativi fissi che aumentano o diminuiscono il clock interno. In sostanza con un unico quarzo esterno, ad esempio 4Mhz,  possiamo ottenere diversi valori interni.

Osserviamo l'immagine sottostante:

 

 

Osserviamo innanzitutto che esistono due distinti ingressi  a cui portare un oscillatore esterno, ovvero i pin 9 e 10  (compatibili con l'ingresso clock del PIC16F876), e altri due denominati T1OSO e T1OSI ripettivamente pin11 e 12, esiste inoltre una sorgente clock interna con frequenza base di 8 Mhz /31 Khz.

Vedremo ora il percorso del clock nel caso specifico della nostra applicazione evidenziato con una linea rossa:

-Quarzo da 20 Mhz posto in OSC1 e OSC2 e quindi nel primary oscillator.

- Il segnale entra nel PLL prescaler divide i 20 Mhz per 5 in modo da ottenere 4 Mhz, in quanto il PLL (phase loop lock)

  accetta solo 4 Mhz in ingresso, all'uscita del PLL otteniamo una frequenza di clock di 96 Mhz a questo punto 

ponendo   USBDIV =1 e FSEN=1 la nostra futura periferica USB funzionerà con un clock di 48 Mhz.

- Impostando il PLL postscaler in modo tale da ottenere 96 Mhz/6= 16 Mhz.

- Impostando FOSC in modo da fornire il clock 16 Mhz attraverso il mux alle periferiche.

 

nell'immagine evidenzio il PLL interno:

Quello dei settaggi del config per la serie 18 è una parte importante e complessa la stessa microchip ha creato integrazioni al datasheet stesso per facilitarne il suo settaggio segnalo quindi un datasheet di fondamentale importanza scaricabile direttamente dal sito microchip C_18_Config_Settings_51537f.pdf

Vediamo quindi i settaggi contenuti nel sorgente C:

#pragma config PLLDIV = 5        
#pragma config CPUDIV = OSC4_PLL6 
#pragma config USBDIV = 2  
#pragma config FOSC=HSPLL_HS  
#pragma config FCMEN = OFF
#pragma config IESO = OFF 
#pragma config PWRT = ON
#pragma config BOR = OFF 
#pragma config BORV = 1
#pragma config VREGEN = OFF   
#pragma config WDT = OFF
#pragma config WDTPS = 32768
#pragma config MCLRE = ON
#pragma config LPT1OSC = OFF 
#pragma config PBADEN=OFF  
#pragma config CCP2MX = OFF
#pragma config STVREN = ON  
#pragma config LVP=OFF     
#pragma config XINST = OFF 
#pragma config DEBUG = OFF
#pragma config CP0 = OFF    
#pragma config CP1 = OFF
#pragma config CP2 = OFF 
#pragma config CP3 = OFF
#pragma config CPB = OFF    
#pragma config CPD = OFF
#pragma config WRT0 = OFF 
#pragma config WRT1 = OFF
#pragma config WRT2 = OFF 
#pragma config WRT3 = OFF
#pragma config WRTB = OFF 
#pragma config WRTC = OFF
#pragma config WRTD = OFF 
#pragma config EBTR0 = OFF 
#pragma config EBTR1 = OFF 
#pragma config EBTR2 = OFF 
#pragma config EBTR3 = OFF 
#pragma config EBTRB = OFF
 

Quindi se con la serie 16F erano sufficenti pochi e semplici settaggi con la serie 18F sono molti di più ed è necessario sfogliare attentamente il datasheet per configurare il pic alle nostre esigenze hardware ottenendo cosi il suo corretto funzionamento,il compilatore è chiaramente il C18, oooooooo a proposito ragazzi qui non è necessario commentare riga per riga perchè se prendete in mano il databook che vi ho indicato prima è spiegato per filo e per segno ogni pragma... impossibile sbagliare! Mi raccomando la consultazione dei databook prodotti dal costruttore vanno letti anche se sono noiosi ed in inglese, anche se la fretta e la smania di vedere il pic lavorare ci porta solo a caricare un hex nel pic o fare l'analisi grammaticale del sorgente!   :-)

La scelta di questa configurazione (software e hardware) è stata dettata dal fatto che sarà implementata in una delle prossime pubblicazioni anche la comunicazione USB, altrimenti si sarebbe potuto sfruttare tranquillamente il clock interno di 8 Mhz evitando cosi di montare quarzo e condensatori con ulteriore risparmio sui costi.

 

Parti del sistema completo.

Il sistema si compone di:


Ecco il sistema completo (qui in fase di collaudo il sensore non è collegato,al suo posto c'è un trimmer), si può

notare il cavo usb installato connesso sia per alimentare il circuito da un pc sia per la comunicazione USB, cosa molto importante riguarda il display, come si vede dalla foto il trimmer per la regolazione del contrasto l'ho montato direttamente nel pcb del display stesso alla stessa maniera  tutti i piedini non utilizzati sono stati ponticellati nel pcb in modo tale che il cablaggio risultasse il più snello possibile.

 

 

Fasi di collaudo e video commento.

Nella fase finale della realizzazione sono stati prodotti i seguenti filmini, pubblicati su youtube in cui di discute sulla funzionalita', sulle problematiche incontrate, e sulle tarature da eseguire sul sistema.

Nell'ultimo filmino vedremo che la visualizzazione a display e di tipo realistico e che la pressione atmosferica letta e' quella reale.

 







In questo ultimo filmato vediamo risolto il problema della taratura del sensore rispetto a una scala in millibar.   Sul display ho anche inserito l'intestazione del progetto Micro-GT.

 
Nella foto sottostante Mirko Musto compara i dati barometrici con uno strumento "ufficiale" rispetto a quelli visualizzati nel display della sua realizzazione.


ADC ed implementazione trasduttore.

Appendice all'articolo.(fonte dal web: AUTRONICA)

Il sensore di pressione utilizzato dispone di questa documentazione che pur non essendo molto completa ci mette in grado di utilizzarlo nella nostra applicazione.

 

Il sensore contiene un ponte di Wheaston alimentato a +5V, che per la sua natura circuitale permette letture sia positive che negative del parametro letto anche quando alimentato in maniera unipolare.

Le resistenze del ponte variano il valore ohmico in funzione della depressione presente nel collettore di aspirazione dell'autoveicolo.

La tensione che si presenta ai morsetti del ponte e' in questo uitilizzo proporzionale al "carico motore" ovvero dira' alla centralina quei parametri che gli serviranno per il calcolo del tempo di iniezione.

La forma d'onda e' visibile in questa immagine oscilloscopica di fonte "documentazione internet AUTRONICA".

 

La forma d'onda rappresentata il segnale proveniente dai collettori di aspirazione di un motore acceso. Si tratta di una rappresentazione lineare della depressione che va formandosi nei collettori a causa della discesa dei singoli pistoni.

Si rileva che la tensione con il motore al minimo  (massima depressione) e' circa 1,25V, accelerando di colpo si legge la pressione atmosferica la tensione aumenta fino a circa 5V.

La curva sul tracciato oscilloscopico sara' piu' o meno accentuata in relazione alle accelerate di prova.

ecco dei parametri verosimili:

 

Purtroppo un datasheet vero e proprio del sensore in questione non sono riuscito a recuperarlo dato certo è che la pressione max misurata è di 100 kPa (cosi diceva l'etichetta) corrispondenti a 1000 mBar (anche se poi si spinge oltre questo limite) il trasduttore è di tipo analogico non so in ogni caso che tolleranza possa avere presumo che per la sua natura (ponte wheaston)si attesti all'incirca dal 5% al 10%. Quindi in base a questi parametri ho calcolato che 1 bit dell'ADC del pic corrisponde a circa 1,092 mBar e facendo dei confronti con un barometro in mio possesso ed i dati barometrici dell'A.R.P.A.V. (disponibili in internet) ho ottenuto un soddisfacente risultato. Chiaramente non sono certo della linearità su tutta la scala del trasduttore......

Ma se disponete di un qualsiasi altro trasduttorre potete ricalcolarvi la risoluzione ed implementarla nel sorgente con vostro godimento!

Vediamo ora come si procede per i calcoli:

Consideriamo prima di tutto che :

La pressione atmosferica normale o standard è quella misurata alla latitudine di 45°, al livello del mare e ad una temperatura di 15 °C, che corrisponde ad una colonna di mercurio di 760 mm. Nelle altre unità di misura corrisponde a:

1 atm = 760 mm Hg = 760 torr = 101 325 Pa = 1 013,25 mbar.

Con la diffusione dell'uso del Sistema internazionale anche in ambito meteorologico, la pressione atmosferica si misura in ettopascal (centinaia di Pascal) il cui simbolo è hPa. Dal momento che 1013,25 mbar = 101 325 Pa = 1013,25 hPa, si ha un'identità tra l'ettopascal ed il millibar.

 (fonte wikipedia)

 

 detto questo in base alla scala di conversione convertiamo i mmHg (millimetri di mercurio) in mBar (milliBar):

 

calcoliamo il delta/mBar e delta/V e vediamo il rapporto V/mbar:

         (4750 mV - 250 mV) / (1049,91 mBar - 169,98 mBar) => 4500 mV / 880 mBar

 a questo punto dividiamo per 4500 sopra e sotto ottenendo che per ogni variazione di 1 mV corrisponde una variazione di  0,195 mBar in base a questo sapendo che l' ADC per ogni bit convertito corrisponde una lettura in Volt di 4,883 mV (Vcc/1023) moltiplichiamo i 0,195 mBar per il valore in mV del bit ADC ottenendo il valore di 0,953 mBar per bit ADC:

4500 mV / 4500 = 1 mV             =>  delta mV

880 mBar / 4500 = 0,195 mBar  =>  delta mBar

5000 mV / 1023 = 4,883 mV      =>  risoluzione ADC

4,883 mV * 0,195 mBar = 0,953 mBar => 1 bit ADC vale 0,953 mBar

Questi sono i calcoli teorici in base ai dati acquisiti il valore invece inserito rapporto 1 bit ADC/mBar e di 1,092 una correzione dovuta alle sicure tolleranze e probabile offset del trasduttore, in queste condizioni la lettura si allinea con i riferimenti che vi ho detto prima (barometro e A.R.P.A.V.).  

 

Sorgente ADC.

A grandi linee la configurazione dell'ADC del 18F rimane simile a quello del 16F interessante è la libreria del C18 adc.h la quale facilita di molto tutta la procedura di configurazione ADC:

              

#include <p18cxxx.h>

#include <adc.h>

#include <delays.h>

int result;

void main( void )

{

  // configure A/D convertor

  OpenADC( ADC_FOSC_32      &

           ADC_RIGHT_JUST   &

           ADC_12_TAD,

           ADC_CH0          &

                     ADC_REF_VDD_VSS  &

           ADC_INT_OFF, ADC_CH10 );

 

  Delay10TCYx( 5 );     // Delay for 50TCY

  ConvertADC();         // Start conversion

  while( BusyADC() );   // Wait for completion

  result = ReadADC();   // Read result

  CloseADC();           // Disable A/D converter

}

Anche qui l'help del compilatore ci viene in aiuto con tutte le esplicazioni del caso anche se è molto intuitivo:

OpenADC() configura l'ADC porte (se an. o dig.) Vref, quale l'ingresso, tempo acquisizione, giustificazione reg. ect.

Corrisponde praticamente alla configurazione dei tre registri ADC:

ADCON1 = 0b00001110;      
ADCON0 = 0b00000000;      
ADCON2 = 0b10110100;       

ConvertADC() attiva la conversione. Che corrisponde a :            ADCON0bits.ADON = 1; 
 

BusyADC() aspetta la fine conversione. Che corrisponde a:        while(ADCON0bits.GO);

ReadADC() legge il risultato nei registri e lo carica nella variabile result.

result=ADRESH;
result=((result<<0x08)+ADRESL);

CloseADC() spegne l'ADC     .Che corrisponde a :                         ADCON0bits.ADON = 0; 

 

Sorgente LCD.

Ci sono inoltre anche librerie già implementate dal C18 ma qui ho preferito utilizzare le mie che avevo già creato  in precedenza (chiaramente se avete le vostre le potete tranquillamente sostituire)e sono:

void clock(void);
void inizializza(void);
void sposta(char y);
void visualizza(char posizione, char lettera);   

La "inizializza" inizializza appunto il display tipo interfaccia se 4 od 8 bit font ect. (Nel ns caso interfaccia= 4bit)

La "visualizza" implementa le altre due "clock" (EN) e "sposta" (nibble) si riferiscono rispettivamente area memoria

display (dove il carattere sarà visualizzato) e tipo carattere da visualizzare es:

per visualizzare a display in riga 1 colonna 1 la lettera "a" basterà scrivere   visualizza(0x80,65);   

dove appunto 0x80 è l'area di memoria display che individua riga 1 colonna 1 mentre (tabella ASCII alla mano) il carattere "a" equivale al numero 65, la routine "sposta " avendo implementato un' interfaccia 4 bit carica nella linea dati 4 bit alla volta dal più significativo al meno significativo.

 

Sorgente in C completo.

//********************************************************************************************//
//  Questo sorgente implementa il pic 18F2550 il suo ADC ed il pilotaggio di un              //
//  display alfanumerico 16x2.                                                                                                      //
//  Realizzato con compilatore C18+Mplab 15/09/2011 autore mirkomusto@yahoo.it    //
//*******************************************************************************************//
 
#include <p18f2550.h>
#include <Delays.h>
#include <adc.h>
 
#pragma config PLLDIV = 5               
#pragma config CPUDIV = OSC4_PLL6   
#pragma config USBDIV = 2   
#pragma config FOSC=HSPLL_HS     
#pragma config FCMEN = OFF
#pragma config IESO = OFF  
#pragma config PWRT = ON
#pragma config BOR = OFF  
#pragma config BORV = 1
#pragma config VREGEN = ON     
#pragma config WDT = OFF
#pragma config WDTPS = 32768
#pragma config MCLRE = ON
#pragma config LPT1OSC = OFF  
#pragma config PBADEN=OFF    
#pragma config CCP2MX = OFF
#pragma config STVREN = ON   
#pragma config LVP=OFF       
#pragma config XINST = OFF  
#pragma config DEBUG = OFF
#pragma config CP0 = OFF      
#pragma config CP1 = OFF
#pragma config CP2 = OFF  
#pragma config CP3 = OFF
#pragma config CPB = OFF      
#pragma config CPD = OFF
#pragma config WRT0 = OFF  
#pragma config WRT1 = OFF
#pragma config WRT2 = OFF  
#pragma config WRT3 = OFF
#pragma config WRTB = OFF  
#pragma config WRTC = OFF
#pragma config WRTD = OFF  
#pragma config EBTR0 = OFF  
#pragma config EBTR1 = OFF  
#pragma config EBTR2 = OFF  
#pragma config EBTR3 = OFF  
#pragma config EBTRB = OFF
 
#define D7   PORTBbits.RB5
#define D6   PORTBbits.RB4
#define D5   PORTBbits.RB3
#define D4   PORTBbits.RB2
#define EN   PORTBbits.RB1
#define RS   PORTBbits.RB0
#define led1 PORTCbits.RC0
 
char mi=0x00, ce=0x00, de=0x00, un=0x00;
long xt=0x00;
 
void configura(void);
void clock(void);
void inizializza(void);
void sposta(char y);
void visualizza(char posizione, char lettera);
 
void main (void){configura();
                 inizializza();
 
                 visualizza(0x84,77);    
                 visualizza(0x85,105);
                 visualizza(0x86,99);
                 visualizza(0x87,114);
                 visualizza(0x88,111);    
                 visualizza(0x89,45);
                 visualizza(0x8A,71);
                 visualizza(0x8B,84);
 
                 visualizza(0xC9,109);    
                 visualizza(0xCA,98);
                 visualizza(0xCB,97);
                 visualizza(0xCC,114);
                  
                 while (1){led1=!led1;  
                           OpenADC(ADC_FOSC_16 & ADC_RIGHT_JUST & ADC_16_TAD,
                                    ADC_CH0 & ADC_INT_OFF & ADC_REF_VDD_VSS,
                                    ADC_1ANA);
                           Delay10TCYx( 5 );      
                             ConvertADC();          
                             while( BusyADC() );    
                           xt = ReadADC();        
                           CloseADC();            
                
                           xt=(xt*1092);
                           xt=(xt/1000);
                            
                           mi=((xt/1000)+48);            
                             ce=(((xt/100)%10)+48);        
                             de=(((xt/10)%10)+48);         
                             un=(((xt/1)%10)+48);          

*Scusate l'intromissione nel calcolo delle migliaia,centinaia,decine,unità si somma sempre 48, questo per allineare il risultato con la corretta visualizzazione display:

Esempio se l'unità trovata vale 5 ed eseguiamo visualizza(0xC7,5);    se guardiamo la tabella ASCII al numero 5 corrisponde se non vado errato ad un istruzione seriale, quindi vedremo un carattere "strano", però se al 5 aggiungo 48 (che corrisponde al valore 0) ottengo 53 che corrisponde alla tabella ASCII al numero 5 visualizza(0xC7,53);  vedrò quindi visualizzato il numero 5 appunto.*
                    
                           visualizza(0xC4,mi);
                             visualizza(0xC5,ce);
                             visualizza(0xC6,de);
                             visualizza(0xC7,un);
                            
                          }  //end while
                 }   // end main
 
void clock(void){Delay1KTCYx(16);     
                   EN=0x01;
                   Delay1KTCYx(16);     
                   EN=0x00;
                   Delay1KTCYx(16);}    
 
void configura(void){LATA  = 0x00;
                     TRISA = 0xFF;             
                      //PORTA = 0x00;
                      LATB  = 0x00;
                      TRISB = 0x00;             
                      PORTB = 0x00;
                      LATC  = 0x00;
                      TRISC = 0xFA;             
                      PORTC = 0x00;
                     Delay1KTCYx(640);}
 
void inizializza(void){ EN=0x00;
                           RS=0x00;                                
                           Delay1KTCYx(640);                        
                              D7=0x00; D6=0x00; D5=0x01; D4=0x00;      
                              clock();
                              Delay1KTCYx(240);                           
                               clock();
                              Delay1KTCYx(160);                           
                              clock();
                              Delay1KTCYx(160);                           
                              sposta(0x28);                              
                              sposta(0x08);                              
                              sposta(0x0C);                              
                              sposta(0x01);                              
                              Delay1KTCYx(80);}                           
 
void visualizza(char posizione, char lettera){RS=0x00;
                                                  sposta(posizione);
                                              RS=0x01;
                                              sposta(lettera);}
 
void sposta(char y){char dato0=0x00,dato1=0x00,dato2=0x00,dato3=0x00,
                          dato4=0x00,dato5=0x00,dato6=0x00,dato7=0x00;
                    dato0=y; y>>=0x01;
                    dato1=y; y>>=0x01;
                    dato2=y; y>>=0x01;
                    dato3=y; y>>=0x01;
                    dato4=y; y>>=0x01;
                    dato5=y; y>>=0x01;
                    dato6=y; y>>=0x01;
                    dato7=y;
                    D7=dato7; D6=dato6; D5=dato5; D4=dato4;
                    clock();
                       D7=dato3; D6=dato2; D5=dato1; D4=dato0;
                    clock();}
 
Questo sorgente così com'è potete copiarlo ed incollarlo in ambiente Mplab con compilatore C18, compilare ed ottenere il vs hex è probabile che vi appaia un errore  tipo "error could not find file c018i.o" per risolvere questo problema dovete aprire:

da Mplab=> select project=> build option=>project

a questo punto seleziona su Directories tab =>Include Search Path=>click "new" e cerca nella directory MCC18 la diretory "h" la selezioni click su applica, poi di nuovo Directories tab =>Library Search Path=>click "new" e cerca nella directory MCC18 la diretory "lib" la selezioni click su applica. Fatto questo sarete anche voi in grado di compilare e modificare il sorgente e non dovrebbero più esserci ostacoli al ns BUILD SUCCESS! 

scarica file hex:   peppa.hex

Ogni lacuna, errore o dimenticanza sarà amorevolmente integrata grazie per aver letto questa pubblicazione

buon smanettamento a tutti e ci vediamo alla prossima con l'implementazione del emulatore seriale via USB .

 

 This opera Let's GO PIC!!! cap18 is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Italy License..

Concorso vinci il PCB della Micro-GT

Sul link seguente troverai le condizioni per concorrere alla vicinta el circuito stampato della Micro-GT presentata in questo articolo.

Leggi attentamente le condizioni per partecipare e riceverai via posta il tuo esemplare.

http://www.gtronic.it/energiaingioco/it/scienza/vinci_Micro-GT.html

Per gli utenti che volessero recarsi in visita a Padova, visitate il sito di jenny tramite il link sottostante.

http://www.bb-yewilliam.it/

  Pagina precedente