Quarta parte del tutorial di Marco Gottardo sui PIC. In questo capitolo si userà la sezione Display LED della scheda Micro-GT PIC versatile IDE tramite RS232, ma le nozioni saranno applicabili a qualunque demoboard che piloti i display in multiplexer tramite il CD451

Let's GO PIC!!!

Pilotaggio del Display a 7 segmenti

Tramite porta seriale RS232.

(contiene anche un programma utile come base per tutti quelli che utilizzeranno la porta seriale RS232)

Di ad.noctis as Marco Gottardo


In questo quarto capitolo vedremo svariati esercizi di pilotaggio del Display LED montato a bordo della Micro-GT PIC versatile I.D.E. ma le nozioni potranno essere impiegati pari pari a qualunque sistema che piloti il digit tramite un decoder BCD/sette segmenti Led.

Nozioni Hardware generali e impostazioni della Micro-GT.


Prima di dedicarci all'uso massiccio dei 4 digit a sette segmenti montati a bordo del sistema di sviluppo Micro-GT PIC versatile I.D.E. acquisiamo in maniera guidata i rudimenti della programmazione in C per PIC 16 in modo da poter manipolare dati numerici o di passarli come parametrizzazione ai PORT di I/O dei microcontroller.
Nel primo esempio supporremo il sistema a microcontrollore formato solo dal circuito di reset, ovvero un banale pullup del valore di 10Kohm al pin 1 (MCLR negato) del prodotto di riferimento per tutti i tutorial "Let's GO PIC!!!" ovvero il potente e completo 16F877A, o il suo fratellino minore 16F876A che ha il pin di reset nella stessa posizione.

Cliccare qui per informazioni sulla scheda di sviluppo.

Il circuito di alimentazione composto anche semplicemente da un regolatore di tensione positivo a +5V, è bene che venga circondato da un insieme minimo di componenti quali un LED per la segnalazione dello stato acceso/spento, un condensatore elettrolitico, di valore non critico, a valle del regolatore avente lo scopo di "ammorbidire" le accensioni del micro. Questo circuito minimale andrà bene solo per prove di laboratorio, in cui si presume che il circuito sia a valle ben alimentato da un buon "power supply" con una continua ben livellata e stabilizzata di cui il nostro regolatore faccia solo da adattatore al livello TTL richiesto dal PIC. Nel caso si volesse eseguire una scheda vendibile e definitiva andranno ben calcolati i condensatori di livellamento a monte e di riserva energetica a valle, ovvero gli elettrolitici, con l'accorgenza di tenere di valore maggiore quello di monte rispetto a quello di valle. Lo scopo è quello di impedire flussi di controcorrente in fase di spegnimento, cosa che viene ulteriormente salvaguardata mettendo un diodo in parallelo ai pin ingresso (catodo) e uscita (anodo) del regolatore LM7805.  Questo diodo andrà in conduzione solo se per qualche motivo la tensione di valle dovesse risultare maggiore di quella di monte di almeno il vaolre di giunzione V-gamma generalmente pari a 0,6 volt, salvaguardando la vita del regolatore stesso.

Buona norma è anche quella di porre tra i pin di ingresso e massa, e uscita e massa due piccoli condensatori ceramichi, a volte poliestere, del valore che non superi i 100 nano farads (per i poliestere), allo scopo di impedire che i regolatori entrino in autooscillazione a causa di qualche transitorio, e quindi di generare calore che a volte può risultare distruttivo.

schema elettrico della sezione di alimentazione della Micro-GT PIC verstile I.D.E.

possiamo notare dallo schema sovrastante l'alimentatore è formato da due stadi a due valori diversi. L'uscita finale è a livello TTL, ovvero +5V, ed alimenterà il PIC nella normale situazione di funzionamento, mentre quello più a monte, quindi più vicino al ponte diodi, (che per ragioni di libreria Eagle ho rappresentato con i soli "Pads") esegue un primo salto a dichiarati +12V, ma in pratica a 13,2V grazie alla presenza dei due diodi polarizzati direttamente e posti in serie al piedino centrale. Questa serie di regolatori presenta sul piedino di massa (appunto il centrale) un generatore di corrente costante pari a 4mA che sviluppando per ognino di essi la tensione di giunzione V-gamma, pari a 0,6V, permette all'uscita del regolatore da 12 di raggiungere la tensione di programmazione di 13,2 necessaria al PIC durante questa manovra.

Ovviamente la terza cosa che è d'obbligo per il funzionamento del PIC è il circuito di clock. Normalmente costituito da una configurazione a P-greco del quarzo (lato orrizontale) e due condensatori ceramici (lati verticali) con le seguenti generiche e sempre funzionanti combinazioni per il PIC di riferimento:

Questi sono i valori più comuni da usare per gli 877 e 876, che in pratica hanno l stessa achitettura interna, ovviamente se nelle vostre cassettiere avete quarzi di recupero, ad esempio da 8Mhz, eseguite la configurazione suddetta con due condensatori di valore intermedio, ad esempio 15pF e il tutto funzionerà comunque.

Attenzione, cambiare la velocità del clock, senza dichiarare nel software sorgente la cosa, potrebbe causare delle anomalie di funzionamento, specialmente quando si usa un tipo di programmazione, diciamo "didattica" in cui ci si appoggia alla routine di ritardo "delay.h" e "delay.c", che sono assolutamente da evitare nella programmazione professionale, come vedremo appena pubblicherò il tutorial "Let's GO PIC: Gli interrupt" che è ancora in fase di test dei sorgenti in esso contenuti.

schema di uno dei clock della Micro-GT PIC versatile I.D.E.

Dato che la scheda Micro-GT è in grado di operare con un elevato numero di microcontroller diversi, essa monta a bordo due quarzi, un 20Mhz, buono per il PIC di riferimento 16F877A e simili tra cui il 16F876A, e uno più lento da 4Mhz. Prima di usare la scheda è quindi necessario operare sugli opportuni jumper in modo da far giungere al processore il segnale di clock corretto sui pin di competenza in funzione del modello che si intende usare. Ovviamente si deve operare schemi alla mano scaricabili dal questo link: schema.

Si consiglia di stampare su foglio A3 perchè lo schema è molto compatto.

Per abilitare il 16F877A ponticellare JP8 e JP8 che avranno l'effetto di portare il segnale di clock ai pin 13 e 14 come previsto dalla documentazione tecnica di questo microcontrollore.

Per il momento teniamo ben presente che le routine delay hanno il grave difetto di tenere impegnato il microcontrollore in una perdita di tempo rendendolo praticamente cieco durante questo periodo agli eventi che si presentano in campo.

Per imparare a programmare può essere accettabile, per vendere un prodotto assolutamente no.     

La sezione display a 7 segmenti.

La Micro-GT PIC versatile IDE dispone di 4 digit a sette segmenti LED, di tipo a catodo comune, per scelta progettuale pilotati tramite un chip di decodifica BCD->7 segmenti, (trattasi di un CD4511 o un equivalente). 

scarica-pdf-CD4511-o-equivalente

Lo schema elettrico è il seguente:

Come possiamo notare il decodificatore potrà essere collegato direttamente al bus e al PORTB agendo sul dip switch SV26, a 8 linee, di cui le prima 4 (in basso) pilotano i catodi dei display agendo sulle basi dei BC337 dando il controllo di accensione/spegnimento dello specifico digit, mentre le successive 4 linee, RB4,RB5,RB6,RB7 pilotano gli ingressi del decoder fornedo il nibble (mezzo byte) che porta l'informazione di visualizzazione della cifra da 0 a 9 per digit.

Il dip switch S25, abbinato allo streep line SV21 porta il controllo tramite un eventuale cavetto flat a 4 linee, ad un port libero del micro, reltivamente all'accensione dei 4 punti digitali presenti nei 4 digit.

Ogni segmento o punto decimale risulta già limitato in corrente dalla specifica resistenza. 

L'aspetto del display montato a bordo è visibile nella foto successiva:

4 digit a sette segmenti della Micro-GT

Programmazione preliminare.

Introduciamo il concetto di variabile. Nelle precedenti pubblicazioni del tutorial "Let's GO PIC!!!" si era sempre operato direttamente nei registri di I/O del microcontroller con l'effetto immediato di lettura o scrittura di bit allo scopo di acquisire segnali da pulsanti, o generalmente da un bordo macchina a livello TTL (sono segnali logici di livello 0-5V), oppure di agire su un bordo macchina sempre con segnali di tipo TTL. Se fossimo poi interessati ad usare concretamente quel segnale su delle elettrovalvole o relè dovremo pilotare degli opportuni transistor, ed ovviamente la scheda definitiva dovrà essere optoisolata.

Una variabile è identificata da un nome e da un tipo.
Il nome identifica la variabile a cui ci si riferisce nella memoria del PIC mentre il tipo associa una "misura" e un formato alla stessa area.

Affinchè due variabili possano operare nel medesimo calcolo devono essere tra loro di tipo compatibile. Nella tabella sono riportati i tipi di dato riconosciuti dal C16, nella prima colonna il costrutto Ansi C con cui si richiamano, nella seconda l'estensione in bit, nella terza il tipo aritmetico, ovvero come verranno trattati dall'algebra.

Negli esempi che seguono useremo variabili di tipo unsigned char che come è chiaro dalla tabella sovrastante hanno estensione 8 bit, quindi il valore massimo esprimibile sarà 255, che data la presenza dello zero si estende a 256 valori possibili.

Impostiamo un semplice ma elegante esercizio software che utilizzi il display LED della Micro-GT, o comunque un display di qualche demoboard.

Creiamo un primordiale calcolatore, che esegue per il momento solo la somma di due addendi ciascuno composto di due Bit. 

Micro-GT calcolator.
Bene, diamoci da fare.

Esercizio: Si crei un sistema software e hardware che implementi, in prima istanza, un sommatore a due bit di due variabili positive minori o uguali a 9. Il risultato viene visualizzato in un display a 7 segmenti. Se la cifra eccede il valore 9 viene segnalato un errore accendendo il segmento centrale (il g) del display. Ad esempio 8+3 = " - "

soluzione:  La  prima cosa da sviluppare è uno schema elettrico di massima, quindi la scelta del microcontroller da usare. Per questioni pratiche, ovvero ne abbiamo in casa ed è quello che si usa come riferimento per i tutorial "Let's GO PIC!!!" impieghiamo un 16F877A, benchè enormemente sovradimensionato rispetto al compito che stiamo andando ad assegnarli.

Dopo avere disegnato lo schema alla lavagna, si integra l'esercizio di programmazione con un breve esercizio di disegno CAD, realizzandolo con Eagle. (per la procedura dettagliata e sufficiente leggere i tutorial già pubblicati su qesto tema).

Si ottiene quanto visibile nella foto:

 

Lo schema si commenta in davvero due parole, infatti è composto dalle parti essenziali di funzionamento circuitale di qualsiasi PIC, ovvero un pullup sul pin MCLR negato che permette al microcontroller di fare girare il programma senza resettarsi a causa di segnali spuri elettromagnetici che arriverebbe via etere nel caso non si fosse messa R12.

Ovviamente serve il clock, con una configurazione classicissima, tra i pin 13 e 14 del modello di controllore scelto, cioè i segnali osc1 e osc2.

Non può ovviamente mancare il circuito di alimentazione qui ridotto al minimo, ovvero il regolatore di tensione da 5V con una essenziale spia led per l'accensione, con la sua brava resistenza di valore non critico, ad esempio i classici 330 ohm. Data che questa sezione è così scarna è evidente che viene alimentata con una tensione continua già bel livellata di valore minimo di 7 volt dato che quel tipo di regolatori di tensione presentano un dropout (caduta tra ingresso e uscita) di circa 2 volt.

Il PORTB è direttamente collegato al display dato che è in grado di pilotare agevolmente fino a 20 milliampere, non dimentichiamo però le resistenze di limitazione, anche in questo caso di valore un po' giostrabile attorno ai 330 ohm, in effetti cambia poco se le metto da 220 o da 560 o addirittura le classiche 1000 ohm. insomma è un esercizio, quindi se solo prestate un po di attenzione a non bruciare il PORT, metteteci pure quello che avete di scorta nei vostri cassetti, farà solo un po più o meno luce.

Attenzione al fatto che questa prima versione non ha il decodificatore BCD/7 segmenti, quindi sarà un ottimo esercizio software realizzare tale decodifica in C16.

Lanciata la procedura di sbroglio automatico e rinforzate un po' le piste si ottiene il PCB della figura sottostante:

 

calcolator(1).rar

 

Vi sconsiglio di realizzarlo davvero, dato che è solo un semplice esercizio di scarsa utilità pratica anche se di grande contenuto didattico. Non spendetici soldi, usate una breadboard, oppure fatevi spedire da me una Micro-GT PIC versatile IDE che poi vi sarà utile pur una moltitudine di altri esercizi e anche lavori reali in campo professionale. 

E' sempre una buona regola fare è pensare ad un Hardware che sia quello definitivo (quello da realizzare e vendere) ma simulabile con il sistema di sviluppo, la Micro-GT o qualche analoga demoboard in modo di avere una simulazione realistica del funzionamento del sistema.

Torniamo, ora che abbiamo a disposizione un hardware, allo sviluppo del software.

Consideriamo la seguente prima bozza del programma ed analizziamone il funzionamento, Questa prima versione funziona con forzamento dei valori, ovvero delle costanti vengono assegnate alle due variabili, successivamente si esegue la somma e riposto il risultato nella variabile "sum". Il contenuto della variabile sum viene filtrato da una decodifica software, costituita da un insieme di costrutti "if" che mappano il contenuto binario BCD nel corrispetivo codice a 7 segmenti che accende correttamente le linee del display. In praticha nel sorgente vedrete delle linee di codice che simulano il funzionamento del chip CD4511:

/*********************************************
* Lezione 10: calcolatrice di base        *
*                                                          *  
*                                                         *
*          26/Ottobre/2010                      *
*                                                         *
*   Esegue la somma di due variabili    *
*   acquisite su due bit su deepswitch  *
*   VAR_A RA0,RA1                            *
*   VAR_B RA2,RA3                            *
*   SUM in binario su PORTB               *
* 1 digit 7 segmenti diretto al PORTB  *
*                                                         *
*  eseguito da ad.noctis as Marco G   *
*********************************************/
 
#include <pic.h>    //parentesi angolari perche' si trova in cartella include
#include "delay.h"  //apici se inserito nella cartella del progetto
                    //se mettiamo le delay in include vanno incluse tra < >

void main(){
    TRISA=0xFF;

    TRISB=0x00;

    unsigned char VAR_A;
    unsigned char swap_A;
    unsigned char VAR_B;
    unsigned char swap_B;
    unsigned char SUM;
         while(1){
         swap_A=3;
         swap_B=2;
         VAR_A=swap_A;
         VAR_B=swap_B; 
           SUM=VAR_A+VAR_B;
           if (SUM==0b00000000) PORTB=0b10111111; //inizia la rete logica combinatoria di decodifica
           if (SUM==0b00000001) PORTB=0b10000110;
           if (SUM==0b00000010) PORTB=0b11011011;
           if (SUM==0b00000011) PORTB=0b11001111;
           if (SUM==0b00000100) PORTB=0b11100110;
           if (SUM==0b00000101) PORTB=0b11101101;

           if (SUM==0b00000111) PORTB=0b10000111;
           if (SUM==0b00001000) PORTB=0b11111111;
           if (SUM==0b00001001) PORTB=0b11101111;
           if (SUM>9) PORTB=0b11000000; //condizione che segnala overflow, acende segmento G

           }

}

scarica la bozza di programma funzionante -> calcolatore_1.rar

In questa prima bozza troverete il progetto MP-LAb completo, quindi come indicato chiaramente nel primo episodio di "Let's GO PIC!!!", scompattate la cartella all'interno della cartella "PICPROJECT" che dovreste avere già preparato nelle lezioni precedenti. Sempre secondo i suggerimenti che avrete trovato nel primo episodio di questa serie di tutorial dovreste avere istallato nel vostro PC un software che si chiama "RealPIC simulator", se non lo avete ancora fatto, fatelo adesso. E' scaricabile da internet nella versione free. 

Cliccate sull'icona con l'aspetto visibile nella foto sovrastante, se il vostro sistema è predisposto come spiegato nel primo tutorial lets_go_PIC.html allora in automatico vi comparirà un display rosso con acceso il numero "5" ovvero l'attuale somma eseguita alla riga di programma SUM=VAR_A+VAR_B;

Se mandando in esecuzione il programma sul simulatore comparirà "0" significa semplicemente che l'ultima compilazione è stata eseguita quando alle variabili erano state assegnate le costanti 0 e 0 che danno come somma appunto 0.

Assegnati manualmente i valori costanti 3 e 2 alle variabili, ricompiliamo, il sistema deve rispondere piu o meno così:

Ora ricarichiamo il file .hex sul simulatore RealPIC simulator, e mandiamolo in esecuzione:

Ottimo !!!, questo significa che pur non avendo ancora il controllo dell'input, il programma sta gestendo correttamente le variabili, e altrettanto correttamente ne esegue la somma. Il display ci sta facendo vedere infatti swap_A che vale 3 più swap_B che vale 2, il cui contenuto viene passato alle variabile di addendo nelle due righe successive, e ne viene eseguita la somma alla terza riga dopo l'assegnazione delle costanti.

Dall'analisi di questa riga:  if (SUM==0b00000000) PORTB=0b10111111; si deduce che il contenuto della variabile sum, che in binario nell'esempio corrisponde a 8 bit nulli corrispondenti a uno zero decimale, vengono decodificati nell'accensione (posizione degli 1 con il meno significativo a destra) di tutti i segmenti tranne il settimo che corrisponde per standard al segmento centrale chiamato sempre "G".

Prima di proseguire, rendendo il nostro primordiale calcolatore iterattivo, ovvero in grado di acquisire i valori numerici sotto forma binaria dai 2 dip switch, facciamo assieme qualche esercizio di ricompilazione e verifica sul simulatore:

Esercizi proposti:

1) eseguire la somma delle due costanti 4 e 3 (deve comparire 7)

2) eseguire la somma di 1 e 2 (deve comparire 3)

3) eseguire la somma di 7 e 3 (deve comparire "-" che segnala un errore di overflow).

4) aggiungere al sorgente l'impostazione del registro "opportuno" per rendere acquisibile il PORTC come input.

5) aggiungere l'acqusizione continua dal PORTA della variabile che conterrà il primo addendo e sommarla a una costante manuale lasciata sulla seconda variabile.

6) aggiungere l'acquisizione continua dal PORTC della seconda variabile e verificare runtime la correttezza della somma. impostare quindi sul Realpic simulator i quattro bistabili di input abbinati correttamente ai pin del 16F876, in maniera bistabile e di tipo normaly 0 -> pressed 1.

nota aggiuntiva: Nel Real Pic simulator è opportuno settare il diplay in modalità realtime (ovvero acquisizione continua, pin enable Vdd, assegnazione edi segmenti in senso orario con A=PORTB -> RB0 e i successivi  next follow down.   (a volte il real pic simulator fa i capricci, insistete un po e il display si setterà corettamente).

 

Segue la realizzazione del programma con la decodifica eseguita hardware dal CD4511 installato a bordo della vostra Micro-GT PIC IDE.  Vedremo anche come inviare i valori delle due varibile binarie di addendo sia dai pulsanti onboard, che dai dip switch, che da fonti interfacciabili esterne tramite cavi flat operanti quindi in modalità freeport della Micro-GT.

 

 

/*********************************************
* Lezione 10 bis: calcolatrice di base   *
*            versione runtime                    *  
*                                                         *
*          26/Ottobre/2010                      *
*                                                         *
*   Esegue la somma di due variabili    *
*   acquisite su due bit su dip switch  *

*   VAR_A RA0,RA1                            *
*   VAR_B RC0,RC1                            *
*   SUM in binario su PORTB               *
* 1 digit 7 segmenti diretto al PORTB  *
*                                                         *
*  eseguito da ad.noctis as Marco G   *
*********************************************/
 
#include <pic.h>    //parentesi angolari perche' si trova in cartella include
#include "delay.h"  //apici se inserito nella cartella del progetto
                              //se mettiamo le delay in include vanno incluse tra < >

void main(){
    TRISA=0xFF; //definiamo il PORTA come input

    TRISC=0xFF;  //definiamo il PORTC come input

    TRISB=0x00; //definiamo il PORTB come output

    unsigned char VAR_A;  //definiamo VAR_A come intero a 8 bit senza segno
    unsigned char swap_A;
    unsigned char VAR_B;
    unsigned char swap_B;
    unsigned char SUM; //variabile destinata a contenere la somma e inviata al diplay
         while(1){   //ciclo infinito di acquisizione e decodifica dei dati letti e elaborati
         swap_A=PORTA;
         swap_B=PORTC;
         VAR_A=swap_A; //questi due passaggio servono solo per maneggiare un pò le variabili per esercizio
         VAR_B=swap_B; 
           SUM=VAR_A+VAR_B;
           if (SUM==0b00000000) PORTB=0b10111111; //inizia la rete logica combinatoria di decodifica
           if (SUM==0b00000001) PORTB=0b10000110; //Tutti questi if possono essere tolti, escluso l'ultimo
           if (SUM==0b00000010) PORTB=0b11011011; // se il sistema possiede un decodificatore BCD/7 seg

           if (SUM==0b00000011) PORTB=0b11001111; // di tipo Hardware, come ad esempio la Micro-GT
           if (SUM==0b00000100) PORTB=0b11100110; //Qui presento la versione software perchè così
           if (SUM==0b00000101) PORTB=0b11101101; //i numeri abbinati a SUM sono visualizzabili in Real PIC simulator
           if (SUM==0b00000111) PORTB=0b10000111;
           if (SUM==0b00001000) PORTB=0b11111111;
           if (SUM==0b00001001) PORTB=0b11101111;
           if (SUM>9) PORTB=0b11000000; //condizione che segnala overflow, acende segmento G

           }

}

 Procediamo compilando questo sorgente e caricando il file .hex ottenuto nel simulatore Realpic simulator. Nell'interfaccia "visual" aggiungiamo i 4 pulsanti che abbineremo a RA0, RA1 e RC0, RC1.

Disponiamoli nell'area della finestra in maniera "intuitiva" per impartire comandi binari, ovvero su due colonne, in cui la prima dall'alto è RA1 e sotto RA0 e analogamente sulla colonna di destra RC1 e RC0.  disposti in questa maniera ci verrà mentalmente più semplice inserire i numeri bnari perchè vengono rispettati i pesi, il più alto in alto e il più basso sotto.

Clicchiamo sui quadratini bianchi e impostiamo normal -> 0,  pressed ->1.

Notiamo che cliccando con il tasto destro l'azione è bistabile, ovvero esegue la simulazione realistica del dip switch (rimane in posizione).

Un altro esercizio svolto.

Senza dilungarsi inutilmente, visto che i contenuti tecnici sono analoghi a quanto sopra, posto questo secondo esercizio di cui lo schema elettrico è rappresentato nella foto presa dalla lavagna durante una delle mie lezioni.

 

Le due resistenze ai pulsanti e quela al master clear sono di valore 10K. In questo schema le si voleva evidenziare il comportamento di pulsanti NC e NA collegati rispettivamente a pulldown e pullup. A titolo di esercizio provate a fare da soli il ragionamento sul segnale abbinato all'azione sul pulsante che giunge a pin del PORTA. 

Successivamente modifichiamo gli input in modo che ci siano almeno 4 ingressi forniti tramite pulsante al PORTA. Vogliamo fare comparire sul display il nuero corrispondente alpulsante premuto, ad esempio premo il primo compare 1 e così via.

Il sorgente C è scaricabile da questo link select_number.zip .

La versione con il CD4511.

 Usiamo la porta seriale.

 Nelle prossime righe vedremo una struttura di base, che con piccoli riadattamenti potrà svolgere moltissime applicazioni, che mette in comunicazione il microcontrollore PIC con il personal computer attraverso il protocollo seriale EIA RS232C. Per il momento inizializziamo l'UART e le routine di comunicazione per l'invio di una stringa composta da 6 caratteri con il formato:

@ = Apertura della stringa

A = Carattere della tabella ASCII

1 = Valore numerico

2 = Valore numerico

3 = Valore numerico

ret = invio che chiude la stringa

Il codice ASCII.

Con la sigla ASCII si intende American Standard Code for information interchange, ovvero lo standard americano per lo scambio di informazioni.

Tutti i caratteri, stampabili o non, sono raccolti in maniera ordinata dentro alla tabella denominata ASCII e assunta come standard che esiste nella versione standard  e nella versione estesa a 256 caratteri.

I caratteri non stampabili hanno significato di azioni, come ad esempio emetti un bip, vai a capo , cancella il precedente, ecc.

Facciamo subito una prova, seguite questi passi:

 In questa maniera il computer è in grado di manipolare i caratteri.

Se nel nostro PC è istallato il sistema operativo XP allora su programmi, accessori, comunicazioni dovreste trovare una piccola applicazione che si chiama Hyperterminal.

Il principale scopo di questa applicazione è quello di istaurare delle comunicazioni con le periferiche hardware del PC, e nel nostro caso è di interesse la COM1, ovvero la vecchia seriale RS-232 (assicuriamoci che sia presente nella macchina in uso, tenendo presente che su alcuni nuovi PC c'è sulla scheda madre ma a volte non è riportata tramite il cavetto flat sugli slot posteriori del case, in questo caso cercate la scatola della scheda madre e verificate se avete ancora il libretto e l'optional costituito appunto da una pezzetto di cavo flat da una parte terminato con un conettore per streep maschio e dall'altro lato con una astina metallica e il conettore cannon DB9 (sempre maschio dalla parte del PC).  Istallatelo nel vostro PC.  QUASI sempre funziona anche con i convertitori USB-RS232, dipende da alcune questioni tecniche su cui non mi divago.

Uso di HyperTerminal.

Hyperterminal è una console di “echo” di ciò che avviene nelle porte di comunicazione del PC.

Principalmente è un software di comunicazione utilizzato per connettersi ad altri computer ad esempio tramite modem seriale, oppure con collegamenti RS-232 con i quali effettuare il telnet, noi lo useremo per conetterci ala scheda Micro-GT PIC versatile IDE, tramite la sua porta seriale commutata tramite gli opportuni jumper in modalità "supervisione". Al fine di utilizzare HyperTerminal per collegarsi a un PC esterno, l'utente dovrà conoscere i dettagli circa il computer a cui desidera connettersi, ad esempio il numero telefonico di chiamata se via banda fonica (modalità obsoleta ma che può ancora funzionare usando dei vecchi modem analogici di recupero o l'indirizzo IP se via canale dati.

Ad HyperTerminal di windows si può accedere, come già accennato, nella seguente maniera:

 

Al primo avvio dell’applicazione verrà chiesto di configurare la chiamata identificando l’utente sia locale "informazioni del tipo dove siamo" che remoto, ovvero il numero a cui ci vogliamo allacciare. Dovremo fornire informazioni del tipo nazione da chiamare, prefisso, il modo in cui si desidera collegare (modem / TCP), inoltre dovremo indicare se il telefono da cui chiamiamo utilizza la selezione a toni o genera il numero ad impulsi, ovvero nella vecchia maniera. Quindi fare clic su OK.

Giunti alla schermata "Nuova connessione" si apre una finestra, che permette di scegliere un nome e un'icona per la nuova sessione di HyperTerminal. Effettuati questi passaggi il sistema di comunicazione è configurato per utilizzare le linee del telefono, difatti agendo sulla icona con quella forma, sulla barra degli strumenti HyperTerminal si potrà collegare o scollegare una chiamata a un altro computer.

HyperTerminal può essere utilizzato per monitorare lo stato del modem collegato al PC anche se alla data odierna è una tecnologia obsoleta. I dettagli di ogni connessione effettuata utilizzando HyperTerminal sono registrati in un file di log. La lettura di questo file può essere un modo per risolvere questioni di connessione modem.

Ora va impostato il protocollo di comunicazione, ovvero le "regole" con cui il trasmettitore e ricevitore si accordano per sincronizzare e capire il flusso di dati.

 

Una volta eseguite queste impostazioni si apre un piccolo terminale di testo in cui ciò che è scritto con l'input standard del PC (la tastiera) viene inviato alla porta seriale usando il protocolo dichiarato sopra. Se la scheda a microcontrollore è in attesa di ricevere questi dati tramite un programma impostato con il medesimo protocollo, che tra breve presento si avrà un echo tangibile della ricezione.

Ecco come sono ordinati i caratteri nella tabella ASCII standard e nella tabella ASCII estesa:

 

Tabella ASCII standard (128 caratteri)

Le prossime due tabelle rappresentano il codice ASCII esteso, ed è quello che preferibilmente dovrà essere preso in considerazioni dai lettori della serie di tutorial "Let's GO !!! PIC".

Osserviamo che il primo carattere della terza colonna è il nostro inizio stringa '@', esso verrà inviato nel programma in C16 tramite la sua posizione nella tabella ASCII. Dato che il PIC si inizializza per default su modalità esadecimale dovremmo inviare il numero hex 40.

 Cavo seriale adatto al progetto.

 Il cavo seriale più adatto è il medesimo che si impiega nella fase di programmazione della Micro-GT PIC, ovvero semplicemente un cavo passante pin to pin, a volte detto "prolunga seriale".

 

 

 

Nota bene: non si dovranno usare i cavi chiamati "null modem" perchè non funzioneranno, dato che effettuano un incrocio lungo il percorso tra il pin 2 (TX) e il pin 3 (RX). Tale incrocio è già realizzato all'interno dela scheda Micro_GT PIC o di qualsiasi scheda a microcontrollore presentata tra i miei progetti, che impieghi il traslatore di livello Max232.

La comunicazione funzionerà bene anche effettuando il collegamento con un cavo che abbia solo i pin 2(TX), 3(RX) e 5(massa), ma comunque passanti, ovvero non incrociati.

                 

Nella figura è riportata la piedinatura del conettore Cannon DB9 femmina, dovremmo fare attenzione alla piedinatura del connettore maschio perchè risulta simmetrica.

La comunicazione seriale EIA-RS232C è un protocollo molto vecchio ma comunque ben testato e sempre funzionale, nonchè facile da usare. Una trattazione approfondita in questo articolo risulterebbe troppo prolisso quindi rimando i lettori a questo link, in cui troverete tutto quello che c'è da sapere in proposito.

http://it.wikipedia.org/wiki/EIA_RS-232

Sfogliando la pagina troverete un diagramma corsa tempo che mette in evidenza i livelli di tensione usati dai livelli logici 1 e 0 trasmessi.  Innanzi tutto notiamo che viaggiano in logica invertita, ma la cosa più importante da capire è che le tensioni che rappresentano questa informazione sono duali e tipicamente poste a livello +12 e -12 volt.

E' noto che il microcontrollore funziona in logica TTL e quindi queste tensioni potrebbero risultare distruttive.

Ci viene incontro la casa costrutricce MAXIM che da molti anni produce l'integrato MAX232, uno dei più not, economici, semplici da usare e funzionali, integrati che assolvono ilcompito di interfaccia 232 e quindi di traslatore e invertitore di livello.

L'interfacciamento eseguito è RS232 -> TTL, ovvero +/-12V> +5/0V.

Questo circuito integrato potrebbe spingere la velocità di comunicazione anche a 1Mbit/s su un cavo lungo fino a 11 metri, ma in realtà noi setetremo il parametro di baudrate a 2400 bit/s oppure a 9600 bit/s, come mostrato qualche riga sopra durante il settaggio di HyperTerminal (non ha molto senso spingere troppo in su le velocità su queste prove di laboratorio).  

 

Il MAX232 dispone di 2 canali per la comunicazione RS-232 bidirezionale, come è possibile vedere osservando la piedinatura. Inoltre ha il pregio di richiedere solo i +5Vcc anche per supportare, in trasmissione, lo standard RS-232. Ciò è possibile, grazie a due stadi convertitori DC-DC, ovvero un elevatore di tensione a capacità, da +5Vcc a +12Vcc; cui segue uno stadio invertitore di polarità, sempre a capacità, da +12Vcc a -12Vcc. Queste tensioni, poi sono pure rese disponili per altri impieghi, ai seguenti piedini: pin 2: +12Vcc, pin 6: -12Vcc. E i condensatori presenti collegati al circuito integrato permettono il regolare funzionamento degli stadi convertitori DC-DC, come è possibile vedere osservando lo schema applicativo, si nota ad esempio che l’elettrolitico al piedino 6 ha il positivo a massa dovendo gestire una tensione negativa internamente prodotta.

La piedinatura del MAX232 è la seguente: 

piedinatura del C.I. MAX232 della MAXIM

Nello schema sottostante una applicazione tipica del MAX232. Si presti attenzione al condensatore C4 la cui polarità è coretta con il positivo verso massa.  Questo può risultare strano ma in realtà dobbiamo ricordarci che esternamente, nel cavo vioaggiano segnali bipolari che in qualche modo sono gestiti da questo integrato per ottenere una tensione singola.

La scheda Micro-GT PIC versatile IDE è munita di una porta di comunicazione seriale di tipo Cannon DB9 femmina (quindi è un lato terminale), in grado di funzionare in due distinte maniere.

  1. modalità programmazione
  2. modalità supervisione

Si passa da una all'altra modalità agendo su degli appositi jumper di chiara funzionalità, schemi alla mano scaricabili  da qui.

Quando la scheda è commutata in maniera "supervisione" è possibile scambiare dati con l'UART interno del microcontrollore, nel caso più semplice e valido didatticamente, possiamo inviare dei caratteri tramite la tastiera del PC da visualizzare in un display.  

 Il programma di comunicazione in seriale.

Eccoci giunti al punto più importante del nostro tutorial, ovvero come instaurare una comunicazione runtime con il PIC e inviargli caratteri che possa poi trasformare in comandi per una eventuale automazione.

Procediamo in questa maniera:

  1. osserviamo la tastiera del PC, la prima riga sono i numeri da 1 a 0
  2. osserviamo la tabella ASCII, i numeri sono gli hex da 30 a 39
  3. scarichiamo il pdf del PIC di riferimento il 16F877 (analogo 876).

 Il PIC 16F877 e il 16F876 dispongono di due moduli interni seriali, il USART (Universal Synchronous Asynchronous Receiver Transmitter, noto anche come SCI, serial comunication interface), e un secondo modulo denominato semplicemente "porta seriale sincrona".   Nello schema a blocchi dell'immagine che segue ho evindenziato in giallo questi moduli.

 

 Si noti che l'immagine sovrastante è relativa al modello 876, ma nel modello di riferimento 877 i due moduli di comunicazione seriale si trovano collegati al bus esattamente nello stasso modo e nella stessa maniera.

          

Come possiamo vedere dal pinout, l'USART è accessibile ai pin 18 e 17 del PIC 16F876 mentre si trova al 26 e 25 del 16F877, per questo motivo il sistema di sviluppo Micro-GT prevede dei jumper (chiaramente indicati nelle serigrafie) che spostano il punto di accesso RX e TX del MAX232 verso il PIC a seconda del modello che viene alloggiato nel comodo zoccolo textool.

pinout del PIC16F877A (l'USART è ai pin 26 e 25)

 

Nella prossima foto vediamo un controllo realizzato per piccoli compiti di automazione che monta a bordo un pic 16F876A, un MAX232 per la comunicazione seriale, Le caratteristiche tecniche sono:

 

Schema del Micro-GT P876 -> Micro-GT_P876_schema.gif

Nella prossima immagime vediamo il PCB del Micro-GT P876, chi fosse interessato ad avere uno o più esemplari di questo piccolo controllo, solo il PCB oppure montato e collaudato, mi contatti via email ad.noctis@gmail.com E' un ottimo sistema da studio, buono per piccole automazioni non di applicazione industriale dato che gli ingressi e le uscite non sono optoisolate.

PLC_PIC876_max232_6Novembre.zip

 

Dal link sovrastante è possibile scaricare il file FidoCad per autocostruirsi il "controllo",  Quando gli hobbisti richiedono un esemplare del sistema di sviluppo Micro-GT PIC versatile IDE di solito viene abbinato o al PCB professionale dell'orologio o a questi controlli.

Torniamo al nostro Tutorial sulle comunicazioni seriali, si potrebbe inviare a 4 delle 6 uscite disponibili il Nibble (mezzo byte ovvero 4 bit) da decoficare tramite il CD4511 per accendere il digit.

Con le due uscite rimanenti possiamo multiplexare i catodi comuni di due DIGIT avendo cosi la possibilità di visualizzare numeri da 0 a 99.  

 
/******************************************************************
 *                    Let's GO !!! PIC                                                           *
 *                    capitolo quarto                                                           *
 *                    14 dicenbre 2010                                                      *
 *   USO DELLA PORTA SERIALE PER IL DISPLAY 7-SEG     *
 *      RS232 Acquisizione seriale dati numerici                         *
 * con XP usare hyperterminal e inviare ASCIIn cifre                *
 *        @P123 ret  spegne LED di test                                         *
 *        @Q123 ret  riaccende LED di test                                     *
 *             attenzione:P e Q maiscoli                                              *
 *Versione senza CD4511 (uscitte dirette ai segmenti)          *
 ****************************************************************/

#include "pic.h"
#include "delay.h"
unsigned char C1,C2,C3,C4,Valore,Flags;

extern void Par_ser(void); //predichiarazione della funzione o prototipo
         //utile quando il corpo della funzione si trova sotto la funzione main
         //o sotto la chiamata  
   
main(void){
TRISA = 0x00;     // tutte uscite per evitare interferenze
TRISB = 0x00;      // tutte uscite
TRISC = 0xf8;  // bit 6-7 Seriale
TRISD = 0x00;       // tutte uscite
PORTA = 0x01;  // azzera i pin del PORT A ma accende il primo LED port A
PORTB = 0x00;     // azzera i pin del PORT B
PORTC = 0x00;       // azzera i pin del PORT C
PORTD = 0x01;  // D0 si attiva alla prima scansione
ADCON1= 0x87;  // PORTA all digital mode

//Inizializzazione uart
TXSTA= 0x20;  // TX abilitato
RCSTA= 0X90;  // Registro RX USART
BRGH = 1;   // USART High velocity
SPBRG= 25;   // Baud Rate Generator (25=9600 baud)

//Inizializzazione TIMER1
T1CON   = 0;  // TIMER 1 resettato
T1CKPS1 = 0,T1CKPS0=0; // TIMER1 prescaler = 1
T1OSCEN = 0;  // TIMER1 external oscillator disable
TMR1CS  = 0;  // TIMER1 internal clock (fosc/4)
TMR1ON  = 0;  // TIMER1 in STOP

//Inizializzazione interrupt
INTCON = 0;  // Interrupt disabilitato
PIE1   = 0;  // Interrupt di periferica disabilitati
GIE    = 1;  // Global Interrupt Enable
PEIE   = 1;  // Periferal Interrupt Enable
RCIE   = 1;  // USART Receive Interrupt Enable

}

void interrupt SerChar(void)    //prototipo ricezione
{
  if (RCREG==0x40 | Valore > 6)  //se arriva la chiocciola dimensiona la stringa
   {
   C1=0,C2=0,C3=0,C4=0;  //azzero la stringa
   Valore=0,Flags=0;
   }
  if (Valore==1) C1=RCREG; //ricezione della stringa comandi
  if (Valore==2) C2=RCREG;
  if (Valore==3) C3=RCREG;
  if (Valore==4) C4=RCREG;
  if ((Valore==5 )&& (RCREG==0x0d)) Flags=1; // <CR> terminatore di stringa
  Valore++;
 if (Flags==1) Par_ser(); //lancia analisi della stringa ricevuta
}

void
Par_ser(void)         // Analisi comandi
{
 Flags=0;
 switch (C1)
  {
  case 0x41:    //carattere A
   PORTD = 0x2; //carattere A attiva D1
   break;
   case 0x51: //carattere Q maiscolo accende LED test seriale
   PORTD = 0x01;
   break;
   case 0x50: //carattere P maiscolo spegne LED test seriale
   PORTD = 0x00;
   break;
   case 0x30: //carattere numero 0
   PORTB=0b10111111;
   break; 
   case 0x31: //carattere numero 1
   PORTB=0b10000110;
   break;
   case 0x32: //carattere numero 2
   PORTB=0b11011011;
   break;
   case 0x33: //carattere numero 3
   PORTB=0b11001111;
   break;
   case 0x34: //carattere numero 4
   PORTB=0b11100110;
   break;
   case 0x35: //carattere numero 5
   PORTB=0b11101101;
   break;
   case 0x36: //carattere numero 6
   PORTB=0b10000111;
   break;
   case 0x37: //carattere numero 7
   PORTB=0b10000111;
   break;
   case 0x38: //carattere numero 8
   PORTB=0b11111111;
   break;
   case 0x39: //carattere numero 9
   PORTB=0b11101111;
   break; 
  }
}

Da questo link puoi scaricare il progetto zippato da MPLab (tastino verde vicino al compilatore in alto al centro)

test_com.zip

 il programma postato sopra è in realtà progettato per poter accendere il digit quando questo è direttamente collegato tramite le resistenze di limitazione ai pin del PORTB del MicroPic.  Si vede dallo schema elettrico del "Micro-GT Calcolator" postato a circa un terzo dall'inizio dell'articolo che le line RBx vanno direttamente ai segmenti del display. Questo permette una simulazione diretta con il software di riferimento "Realpic simulator".

Il nostro obbiettivo è però quello di vederlo funzionare sul sistema di sviluppo "Micro-GT PIC" che fa da piattaforma per la serie di tutorial "Let's Go!!! PIC", e di cui ne sono state distribuite un centinaio di esemplari.

Bisogna effettuare dei settaggi preliminari tramite i jumper in modo che il sistema possa convagliare i dati emessi nei vari BUS verso il modulo di interesse. Per fare questo, schema elettrico alla mano osserviamo il lato destro dello zoccolo Textool. Dato il nostro processore di riferimento  è il 40 pin 16F877A, sappiamo guardando il pinout che il PORTB, dove il nostro programma invia i dati, si trova negli ultimi 8 pin (da 33 a 40).

L'immagine mostra una piccola parte dello schema che focalizza la situazione che vogliamo ricreare.

instradamento dati specifico della Micro-GT per accendere il Display 7 seg.

Procediamo come segue:

 Dopo queste impostazioni l'hardware è pronto a ricevere dati e a inviarli al modulo di decodifica. Ci rendiamo subito conto che il programma fornito sopra non svolge la funzione richiesta pur essendo corretto sintatticamente.

Prima di procedere alla lettura, prendetevi qualche minuto per pensare e cercate una motivazione per conto vostro.

 Ottimizziamo il programma per la Micro-GT.

I più esperti di voi avranno già capito, dall'osservazione dell'Hardware quali sono le modifiche software necessarie per il corretto funzionamento. Chi non ha visto la soluzione non si preoccupi più di tanto, ora ragioniamo assieme e troviamo una soluzione semplice e intuitiva, anche se sicuramente non la più elegante.

Identifichiamo il problema: Il bus è compostao da un byte, ma il dato utile è composto di due "NIBBLE" (nome assegnato a 4 bit) la cui somma formano il byte in questione.

Dall'osservazione dell'hardware si ha che la parte bassa (RB0-RB3), cerchiati in rosa nello schema precedente, pilotano i BJT (i transistor BC337) collegati ai catodi comuni dei display, e polarizzati in zona saturazione.

Si ricorda che un transistor di segnale posto in zona saturazione simula un interruttore chiuso (minima Vce, tendente a zero), mentre quando posto in interdizione simula un interruttore aperto (massima Vce pari a Vcc).

Sono presenti 4 transistor, uno per digit, quindi afinchè il numero posto sul bus a cui è parallelato il digit accenda i segmenti, è necessario abilitare il digit stesso pilotando la base del corrispondente digit.

A causa di un problema di sbroglio del PCB i display da sinistra verso destra sono numerati  DIS4, DIS1, DIS2,DIS3.  

 

Ai programmatori esperti la disposizione dei digit non crea alcuna difficoltà ma al principinte può causare qualche difficoltà software.

In sostanza, ammetendo che per il momento vogliamo accendere solo il primo Digit più a sinistra che corrisponde al Digit 4, dobbiamo:

Procediamo alla modifica del programma precedente:

Pendiamo in considerazione il seguente case dello switch software

 case 0x30: //carattere numero 0
   PORTB=0b10111111;
   break;

 Modifichiamolo così:

 case 0x30: //carattere numero 0
   PORTB=0b00000001;
break;

 

Osserviamo che dei primi 4 bit solo RB0 è  a 1 logico, abiltando i catodi comuni del digit più a destra. Se gli abilitiamo tutti e quattro l'effetto sarebbe quello di ripetere lo stesso numero su tutti i digit dato che il valore da visualizzare è inviato su un bus comune, ma è bene evitare assolutamente questa situazione dato che di norma i display sono collegati con la tecnica del multiplexing, ovvero a turno , per non sovracaricare le uscite del CD4511 a cui sono conessi i segmenti. La tecnica in questione è molto più ampia di semplice accenno, ma ora non è il momento di approfondire.

Ecco il programma modificato per eseguire la decodifica hardware contestualmente all'abilitazione del primo digit. 

 


/******************************************************************
 *                    Let's GO !!! PIC                                                           *
 *                    capitolo quarto                                                           *
 *                    17 dicenbre 2010                                                      *
 *   USO DELLA PORTA SERIALE PER IL DISPLAY 7-SEG     *
 *      RS232 Acquisizione seriale dati numerici                         *
 * con XP usare hyperterminal e inviare ASCIIn cifre                *
 *        @P123 ret  spegne LED di test                                         *
 *        @Q123 ret  riaccende LED di test                                    *
 *             attenzione:P e Q maiscoli                                             *
 *  Versione con CD4511 ottimizzata per Micro-GT IDE          *
 ****************************************************************/

#include "pic.h"
#include "delay.h"
unsigned char C1,C2,C3,C4,Valore,Flags;

extern void Par_ser(void); //predichiarazione della funzione o prototipo
         //utile quando il corpo della funzione si trova sotto la funzione main
         //o sotto la chiamata  
   
main(void){
TRISA = 0x00;     // tutte uscite per evitare interferenze
TRISB = 0x00;      // tutte uscite
TRISC = 0xf8;  // bit 6-7 Seriale
TRISD = 0x00;       // tutte uscite
PORTA = 0x01;  // azzera i pin del PORT A ma accende il primo LED port A
PORTB = 0x00;     // azzera i pin del PORT B
PORTC = 0x00;       // azzera i pin del PORT C
PORTD = 0x01;  // D0 si attiva alla prima scansione
ADCON1= 0x87;  // PORTA all digital mode

//Inizializzazione uart
TXSTA= 0x20;  // TX abilitato
RCSTA= 0X90;  // Registro RX USART
BRGH = 1;   // USART High velocity
SPBRG= 25;   // Baud Rate Generator (25=9600 baud)

//Inizializzazione TIMER1
T1CON   = 0;  // TIMER 1 resettato
T1CKPS1 = 0,T1CKPS0=0; // TIMER1 prescaler = 1
T1OSCEN = 0;  // TIMER1 external oscillator disable
TMR1CS  = 0;  // TIMER1 internal clock (fosc/4)
TMR1ON  = 0;  // TIMER1 in STOP

//Inizializzazione interrupt
INTCON = 0;  // Interrupt disabilitato
PIE1   = 0;  // Interrupt di periferica disabilitati
GIE    = 1;  // Global Interrupt Enable
PEIE   = 1;  // Periferal Interrupt Enable
RCIE   = 1;  // USART Receive Interrupt Enable

}

void interrupt SerChar(void)    //prototipo ricezione
{
  if (RCREG==0x40 | Valore > 6)  //se arriva la chiocciola dimensiona la stringa
   {
   C1=0,C2=0,C3=0,C4=0;  //azzero la stringa
   Valore=0,Flags=0;
   }
  if (Valore==1) C1=RCREG; //ricezione della stringa comandi
  if (Valore==2) C2=RCREG;
  if (Valore==3) C3=RCREG;
  if (Valore==4) C4=RCREG;
  if ((Valore==5 )&& (RCREG==0x0d)) Flags=1; // <CR> terminatore di stringa
  Valore++;
 if (Flags==1) Par_ser(); //lancia analisi della stringa ricevuta
}

void
Par_ser(void)         // Analisi comandi
{
 Flags=0;
 switch (C1)
  {
  case 0x41:    //carattere A
   PORTD = 0x2; //carattere A attiva D1
   break;
   case 0x51: //carattere Q maiscolo accende LED test seriale
   PORTD = 0x01;
   break;
   case 0x50: //carattere P maiscolo spegne LED test seriale
   PORTD = 0x00;
   break;
   case 0x30: //carattere numero 0
   PORTB=0b00000001;
   break;
   case 0x31: //carattere numero 1
   PORTB=0b00010001;
   break;
   case 0x32: //carattere numero 2
   PORTB=0b00100001;
   break;
   case 0x33: //carattere numero 3
   PORTB=0b00110001;
   break;
   case 0x34: //carattere numero 4
   PORTB=0b01000001;
   break;
   case 0x35: //carattere numero 5
   PORTB=0b01010001;
   break;
   case 0x36: //carattere numero 6
   PORTB=0b01100001;
   break;
   case 0x37: //carattere numero 7
   PORTB=0b01110001;
   break;
   case 0x38: //carattere numero 8
   PORTB=0b10000001;
   break;
   case 0x39: //carattere numero 9
   PORTB=0b10010001;
   break; 
  }
}

 

Dal sottostante link potrai scaricare tutto il progetto MpLab comprendente il sorgente in C il file .hex.

 test_com4511.zip

Prima di concludere fornisco una serie di interessanti esercizi che potrete svolgere sull abase quanto sopra:

  1. spostare la visualizzazione su un digit diverso da lprimo a sinistra.
  2. fare scorrere la visualizzazioe del numero sui 4 digit disponibili (supercar)
  3. implemenatre il calcolator proprosto sopra utilizzando tutti e 4 i digit (questo è un po più complesso)
  4. realizzare un orologio (senza real time clock) di tipo minuti e secondi, usare 4 bit del port A della Micro-GT per effettuare il settaggio.
  5. Altri proposti da voi.

 Chi di voi volesse mettermi al corrente degli esercizi svolti o dei propi risultati raggiunti seguendo i tutorial "Let's Go PIC!!!" potrà inviarmi programmi foto, richiesta di informazioni sulla Micro-GT PIC  o semplicemnte commenti anche alla mia mail personale ad.noctis@gmail.com

 Ecco la scheda Micro-GT PIC versatile IDE, chi fosse interessato può richiedermene un esemplare tramite messaggio privato, la riceverà in pochi giorni via posta.

Micro-GT PIC versatile IDE Versione completa.

In qualche caso potrà essere possibile avere un esemplare parzialmente montato (modello base) già in grado di flaschare i PIC, di comunicare via RS232 anche nella modalità supervisone e di disporre di 8 ingressi commutabili tramite juper in modalità NC o NA a gruppi di 4, e 8 uscite LED collegate al PORTB dell'eventuale PIC a 28 o 40 pin, monterà lo zoccolo textool nel limite di quelli che dispongo ancora a magazzino. Cavetto ICSP.

Micro-GT PIC versione base (espandibile in un secondo momento).

 

Auguro a tutti pace salute e serenità

Marco Gottardo as Ad.noctis 

Licenza Creative Commons
This opera is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 2.5 Italy License.