Un tutorial sui display a 7 segmenti di Simone Salvan, allievo del prof Marco Gottardo.

Display a 7 segmenti
Micro-GT con PIC16F877A

Terza lezione

Mi chiamo Simone Salvan e mi occupo di manutenzione di apparati elettromedicali installati presso vari ospedali del triveneto. Molti apparati ospedalieri sono controllati da PLC, per cui ho deciso di iscrivermi a uno dei corsi serali che si svolgono in una piccola scuola di Padova. Il centro culturale ZIP (zona industriale di Padova). A questo corso ho conosciuto il prof. Marco Gottardo, utente di grix, noto come ad.noctis. Tra le proposte formative, Gottardo mi fa notare anche un corso di microcontrollori PIC, a cui ho aderito con entusiasmo dato che molti dei dispositivi ospedalieri funzionano anche con questi dispositivi.

In questo articolo vorrei condividere le mie esperienze e i miei progressi nel mondo dei PIC.

Simone.

Accensione del Display a sette segmenti.

La frequenza al corso di PIC prevede, benché' non sia obbligatorio, di dotarsi di materiale didattico consigliato. Questo è:

1. Un computer portatile in grado di fare girare MPLAB, chi ne è sprovvisto usa i PC della scuola, ma poi si trova male a casa nel fare gli esercizi. Tutto sommato non è un problema perché al giorno d'oggi quasi tutti abbiamo un computer portatile in famiglia.
2. Il libro che ha scritto il prof, che si trova in internet e si intitola come il corso online "Let's GO PIC!!!", ma è molto più completo. Contiene tantissimi schemi, e altrettanti esercizi svolti e perfino tre tesine, un ascensore, un apri cancello e una macchinetta del caffè con display e caldaia. Purtroppo questo libro è un po’ costoso, ma è molto più esteso del corso online.
3. In alternativa al libro grosso, il prof consiglia un pdf, che ha messo sempre sul sito lulu.com, che si intitola "Microcontrollori partenza immediata" di Marco Gottardo, ve la cavate con 3 o 4 euro e copre sicuramente le prime tre lezioni.
4. Un sistema di sviluppo Hardware. Quello consigliato è la Micro-GT versatile IDE, con cui si coprono tutte le prove dell'intero corso, quindi il motore DC, il motore passo passo, i vari display anche quelli grafici. Siccome questa scheda può risultare un po' costosa (100€) è possibile frequentare usando una versione ridotta, la Micro-GT mini, a cui si possono applicare tante altre piccole schede, originali oppure auto costruite, chiamate minishield. Io posseggo entrambi le versioni.

La lezione a cui mi riferisco è la terza, ed essendo lezioni di 3 ore ciascuna abbiamo fatto solo 9 ore, tuttavia ho già acceso il display apprendendo la teoria del codice BCD, la conversione hardware in modalità sette segmenti, l'installazione e la compilazione con MPLAB e i rudimenti del C.

Nozioni di base.

Per usare il display a bordo della scheda di sviluppo bisogna decidere a priori alcune cose:

1. il tipo di display, ad anodo comune oppure a catodo comune.
2. usare il bus preimpostato nella scheda oppure usare la modalità freeport.
3. usare o no il decoder BCD/sette segmenti che è integrato nella scheda.
4. avere un lavoro da svolgere, una sorta di commessa, da cui sviluppare il programma.

Noi useremo il display a catodo comune, con i catodi intercettati prima della massa da dei transistor BC337, e quindi quattro segnali saranno generati dal PIC solo per abilitare l'accensione del display.

Le sette linee, che corrispondono ai sette segmenti dei display non sono generate dal PIC direttamente, ma da un circuito integrato pilotato da esso. Una specie di decoder che prende 4 linee di uscita del processore e le converte nelle sette linee necessarie e correttamente configurate.

Ci viene spiegato che il codice BCD è una sorta di sottoinsieme del codice binario ridotto ai soli primi 4 bit, solitamente indicati con b₃,b₂,b₁,b₀ posti come intestazione delle colonne di una tabella. Dato che i possibili stati di una variabile binaria sono 2 (0 oppure 1) e che le variabili in esame sono 4, le possibili combinazione di queste sono "possibili stati elevato al numero delle variabili" quindi in totale sono 16.

Dato che la numerazione parte da zero, il massimo valore esprimibile è il 15.

Infatti 2³+2²+2¹+2⁰=15

Subito si capisce che ci sono più combinazioni di quelle che ci servono dato che su una singola cifra LED, chiamata DIGIT, posso rappresentare i numeri da 0 a 9.

Per costruire il codice BCD facciamo così:

Scriviamo le intestazioni delle colonne come detto sopra, ovvero la sequenza "b₃ b₂ b₁ b₀".

Consideriamo la colonna più a destra, e scendiamo in verticale, per 16 posizioni, alternando 0 e 1 a partire da zero.

Si ottiene:

b3	b2	b1	b0
			0
			1
			0
			1
			0
			1
			0
			1
			0
			1
			0
			1
			0
			1
			0
			1

La prima colonna a destra ha quindi una periodicità di riga pari a 1.

Le colonne successive, spostandosi verso sinistra, si costruiscono abbinando la periodicità 2 - 4 - 8 che corrisponde a cambiare stato ogni 2 righe, ogni 4 righe e ogni 8 righe, fermo restando che la prima riga sara' sempre costituita da zeri. quindi si avrà:

Per la periodicità "2" il cambio di stato ogni due righe nella colonna di b1.

b3	b2	b1	b0
		0
		0
		1
		1
		0
		0
		1
		1
		0
		0
		1
		1
		0
		0
		1
		1

Per la periodicità "4" il cambio di stato ogni quattro righe nella colonna di b2.

b3	b2	b1	b0
	0
	0
	0
	0
	1
	1
	1
	1
	0
	0
	0
	0
	1
	1
	1
	1

Per la periodicità "8" il cambio di stato ogni otto righe nella colonna di b3.

b3	b2	b1	b0
0
0
0
0
0
0
0
0
1
1
1
1
1
1
1
1

La matrice completa, in cui si rappresentano tutte le colonne, è anche detto codice BCD, oppure codice 8421 ridotto alle prime 10 combinazioni.

b3	b2	b1	b0
0	0	0	0
0	0	0	1
0	0	1	0
0	0	1	1
0	1	0	0
0	1	0	1
0	1	1	0
0	1	1	1
1	0	0	0
1	0	0	1
1	0	1	0
1	0	1	1
1	1	0	0
1	1	0	1
1	1	1	0
1	1	1	1

La sopra riportata è l'input atteso dal circuito integrato CD4511, ovvero il decoder BCD -> sette segmenti.

Lo schema di principio, fatto ad una velocità sorprendente dall'insegnante usando il paint, e proiettato sul muro della classe, è il sottostante. Le spiegazioni sono state fatte in tempo reale durante il disegno, che alla fine ci è stato fornito in formato bmp. Questo è stato allegato ai nostri appunti, in realtà poco diversi dall'articolo che state leggendo.

In linea di principio l'esercizio richiede la visualizzazione di un numero a due cifre sul display presente sulla Micro-GT versatile IDE.

Dato che questo programmer/demoboard dispone di 4 digit, abbiamo optato di allinearci a destra tenendo spente le rimanenti cifre.

La richiesta è quella di fare comparire il numero 12 sui due digit di destra, come mostrato nello schema di principio sovrastante.

Sembra semplice, ma in realtà dobbiamo capire alcuni concetti.

Osservando il Bus (insieme di linee parallele indicate con a,b,c,d,e,f,g, che corrispondono ai led dei segmenti del display), ci accorgiamo che vi transita sia la cifra 1 che la cifra 2, quindi queste non possono coesistere temporalmente parlando.

A gestire il traffico sul bus ci pensa il microcontroller, ma a consentire l'accensione dei display ci pensano i due transistor BC337 che lavorando in saturazione/interdizione sono in pratica degli interruttori controllati dai segnali presenti su ulteriori due linee del Microcontroller.

In definitiva, il PORTB è diviso in due, la parte bassa in cui è presente il numero BCD da inviare al decoder CD4511 e la parte alta che invece multiplexa il bus, consentendo ad un solo Display alla volta di visualizzare ciò che sta transitando sul bus.

I display utilizzati sono dei catodo comune del modello in foto:

Al suo interno vi sono sette, (più uno che accenderà il punto decimale), LED, collegati in questo modo:

Al pin numero 3 del display viene collegato il collettore del transistor BC337, che satura con soli 2mA.

Un rapido studio della maglia di base, alimentata a +Vdd = 5V permette il calcolo della resistenza RB che risulta pari a 2k2.

Grossomodo il calcolo della maglia è:

Ib*Rb+Vbe-Vdd=0 risolvendo questa equazione rispetto a Rb si ottiene Rb= (Vdd-Vbe)/Ib

Sostituendo i valori, Vdd=5, Vbe=0,6 Ib=2mA si ottiene 2k2 ohm [(rosso, rosso,rosso, oro) 1/4W]

Schema reale del programmer demoboard.

La Micro-GT versatile IDE possiede una quantità molto elevata di dipswitch, strip line, punti di connessione, ecc.

Dobbiamo quindi vedere lo schema per poter definire dove e come inviare i segnali tramite il firmware che stiamo per sviluppare.

Decidiamo di non usare il bus collegato internamente al fine di rendere compatibile il firmware che sviluppiamo anche per chi non possiede questo programmer, quindi tutte le linee del dipswitch S26, vanno aperte. Questo scollega completamente questa sezione della scheda dal micro dando la possibilità di usare la maniera "freeport", che comporta il collegamento di due cavetti flat a 4 conduttori rispettivamente su:

• SV19 -> per il codice BCD (pin1->A) (pin2 ->B) (pin3->C) (pin4->D)
• SV20 -> per abilitare i catodi comuni (pin1->consente accensione display1) (pin2 ->consenti accensione display2)

Al momento non siamo interessati all'utilizzo dei punti decimali quindi SV21 può rimanere scollegato.

Nella foto vediamo la posizione degli stripline maschi SV19 e SV20.

Le serigrafie ci ricordano la loro funzionalità. Da qui partiremo con dei cavetti piatti, terminati su strip line femmina in entrambi i lati per innestarci rispettivamente SV19 -> parte bassa del PORTB, e SV20 ->parte alte del PORTB.

Rimane quindi da identificare la posizione del PORTB sulla demoboard.

A tale scopo visualizziamo il layout componenti.

La fila centrale dei LED visualizza lo stato del PORTB, quindi si consiglia di abilitarla, almeno in fase di debug, perchè ci aiuta a capire se il firmware è corretto e magari la mancata accensione di qualche segmento è dovuta a un problema hardware o di collegamento dei cavetti flat, oppure dell'efficienza del circuito integrato CD4511, posto nello zoccolo IC1.

Se, ad esempio, abbiamo recuperato questo integrato, potrebbe essere bruciato, ma la mancanza dell'eco LED non ci da questa informazione in maniera immediata facendoci perdere del tempo prezioso.

Lo schema elettrico completo della demoboard è scaricabile liberamente dal sito del prof. Gottardo e vi sarà indispensabile durante lo sviluppo dei vari software. Il link è -> Demoboard/programmer Micro-GT IDE

Lo sviluppo del software.

Per lo sviluppo del software, ci viene imposto lo stile di programmazione dell'insegnate, che prevede:

1. Alta modularità, quindi la suddivisione in più file ".h" o ".c" del programma, ad esempio i settaggi vanno posti in un modulo esterno, standardizzato nei corsi di questa scuola in settaggi.h che conterrà la funzione settaggi() in cui si eseguono le impostazione dei registri TRIS,PORT,ADCON, ecc.
2. Intestazione chiara del modulo principale, che contiene la funzione main(). Viene eseguita con una cornicetta a commento che conterrà il nome dell'autore, la versione del firmware, il titolo, le piattaforma di sviluppo hardware e software e ovviamente la data.
3. All'interno della funzione main, che per sua natura cicla in maniera infinita, viene creato un ciclo interno, anche esso infinito, il cui corpo è più piccolo di quello del main. questo serve per eseguire delle impostazioni solo al primo ciclo del programma, ad esempio il richiamo della funzione settaggi.

Con queste premesse, possiamo dire Il codice si sviluppa a partire da uno scheletro comune, che si evolverà man mano che si avanza con le lezioni del corso e che ci permette di risparmiare un sacco di tempo all'inizio di un nuovo progetto.

Il progetto, come spiegato nel e-book "Micro PIC partenza immediata", si crea svolgendo i sette passi fondamentali del wizard integrato in MPLAB.

L'aspetto finale del progetto è questo:

Come prossima vedere si compone di 5 moduli, di cui due ti tipo source, salvati con estensione .C e due ti tipo header salvati con estensione .h, durante lo sviluppo del codice è sempre possibile aggiungere altri moduli, o toglierli.

L'aggiunta di un nuovo modulo avviene dal menù "project" di MPLAB alla voce "add file to project".

Agendo sul quadratino nero con dentro un puntino rosso, che si trova nella barra degli strumenti di MPLAB, avviene la compilazione.

Il risultato è questo.

Questa manovra crea il file ".hex" che poi sarà riversata nell'area flasch del PIC tramite la tecnica ICSP, per la quale il sistema di sviluppo dispone di un cavetto colorato a 5 poli, da porre in questa maniera:

I cavetti rosso e arancione, che portano dall'ICSP le tensioni di alimentazione del PIC a 5 v e il riferimento alla massa non sono necessari perché il 16F877A presente sullo zoccolo textool risulta già internamente collegato tramite le piste della scheda. La tensione Vpp=13,2V, sul filo marrone, è generata dal regolatore IC5, che vediamo in basso a sinistra sopra al connettore X1. Questo è sul regolatore a 12V quindi la tensione viene alzata di 1,2V grazie alla presenza dei due diodi D3 e D2, in serie, presenti al pin centrale del 7812 e con il catodo verso massa.

Se il trasferimento, che a scuola usualmente facciamo usando il programma PICPROG2009, non dovesse andare a buon fine, oppure il software non riconosce la scheda, potrebbe essere necessario aprire momentaneamente i jumper JP8 e JP9, che fermano il quarzo XTAL 2.

Alcuni degli esemplari di Micro-GT che abbiamo in laboratorio funzionano tramite la tecnica LVP, low voltage programming, che richiede il precaricamento di un firmware chiamato bootloader. Questo si mette in ascolto sulla porta seriale nei primi 200 millisecondi dopo l'accensione e se trova un flusso, creato da un programma istallato nel PC nella seriale, converte l'azione del PIC da esecuzione a programmazione.

Il trasferimento è davvero molto rapido.

Le schede che funzionano in questa maniera sono prive dell'integrato IC4, il CD4069, che basta rimuovere dallo zoccolo. Il consenso al caricamento avviene premendo il pulsante di reset mentre il programma "pic downloader" è in "searcing for bootloader", ovvero ha già preso il file .hex e lo sta proponendo alla porta seriale.

scarica il PIC downloader

scarica bootloader per 16F877A 20MHz 38400bps

Approfondimenti in merito alla programmazione LVP con bootloader sono sul libro "Let's GO PIC!!! the book" a cui è dedicato un intero capitolo.

Scaricate da qua il programma completo e provate a compilare: ->download esercizio due digit

A questo punto dovreste essere in grado di compilare un programma con MPLAB, ma nel caso ci fossero problemi guardate il capitolo 1 del corso Let's GO PIC, che vi guida passo passo, o se avete il libro, guardate l'apposito capitolo.

Comunque non dimenticate di selezionare il compilatore HITEC per il quale ho sviluppato questo esercizio.

Il digramma di flusso ci aiuta notevolmente nella fase di sviluppo software. I flowchart sono direttamente applicabili solo quando il programma è suddiviso in parti sufficientemente piccole, ecco perché' l'insegnate ci fa dividere il tutto in una quantità elevata di piccole funzioni.

Vediamo il software nel dettaglio.

Mostriamo per prima il modulo che contiene il main. Questo è salvato con nome duedigit.c

/**************************************************
* programma multiplexaggio su 2 display *
* firmware version:1.0 *
* autore: Simone Salvan *
* data:15/01/2013 *
* interfaccia CD4511 *
* MCU: 16F877A *
* Piattaforma hardware: Micro-GT IDE *
* Piattaforma software: MPLAB v8.60 *
* linee: A->RB0 *
* B->RB1 *
* C->RB2 *
* D->RB3 *
************************************************/

#define _LEGACY_HEADERS // permette di riconoscere i fuse ai nuovi compilatori

#include <pic.h>
#include "delay.h"
#include "settaggi.h"

__CONFIG (HS & WDTEN & PWRTDIS & BORDIS & LVPDIS & DUNPROT & WRTEN &

DEBUGDIS & UNPROTECT); //impostazione dei fuse, abilitiamo solo il timer watchdog

#define A RB0
#define B RB1
#define C RB2
#define D RB3

#define display1 RB7
#define display2 RB6

void settaggi(); //predichiarazione di una funzione esterna (si trova nel modulo settaggi.h

void main(){
settaggi();
int conta;
conta=2;
while(1){
PORTB=conta;
display1=1;
display2=0;
DelayMs(10);
conta=conta-1;
PORTB=conta;
display1=0;
display2=1;
DelayMs(10);
conta=2;

CLRWDT(); //resetta il watch dog timer, se ci dimentichiamo il programma si blocca
}
}

----------------------------------------------------------------------------

Vediamo il contenuto del file settaggi.h

void settaggi(){
TRISB=0b00000000;
PORTB=0;
}

--------------------------------------------------------------------------.

Questo piccolo programma, sembra banale, ma in realta', ci viene spiegato, e la base da cui partiremo per sviluppare un orologio digitale da visualizzare sui 4 digit integrati sulla scheda di sviluppo Micro-GT.

La tecnica di controllo in multiplexing dei digit non e' sufficiente per fare l'orologio, perche' dovremmo prima imparare a generare la base tempi stabile e sufficientemente precisa.

Questa verra' creata agendo su quella parte hardware interna del PIC chiamata TMR0 e necessita della conoscenza della gestione dei segnali di interrupt, piuttosto prematuri per una terza lezione a cui siamo giunti.

Il prossimo step sara' quello di prendere il controllo della cifra visualizzata, attualmente il numero 12, con due pulsanti, scelti tra quelli integrati nella demoboard. Lo scopo e' quello di avvicinarsi al concetto di preset dell'ora visualizzata, quindi la regolazione aumentando manualmente le ore o i minuti.

La piccola scuola dispone di molte postazioni Micro-GT, tuttavia gli allievi preferiscono aquistare il proprio esemplare per potersi esercitare a casa. Nella foto vediamo la mia scheda di sviluppo, la Micro-GT IDE assemblata in versione ridotta, inserita in una scatola assieme ad un alimentatore recuperato da un vecchio apparato ospedaliero. Nella foto non è ancora visibile ma ora c'è un plexyglass che impedisce di toccare le parti sotto tensione di rete. Cosa da non trascurare per la sicurezza elettrica.

Questa foto mostra la presenza del cavetto ICSP infatti in questo momento la scheda è in programmazione.

Sullo zoccolo textool il mitico 16F877A, tuttavia, si potrebbe sostituire con un più performante 18F4550, ma poco adatto a chi fa i primi passi perchè concettualmente più complesso. In realtà, nel textool possiamo mettere tantissimi microcontrollori, benchè a scuola ci insegnino solo 16F876A, 16F877A, e cenni ai quasi equivalenti pin to pin 18F2550 e 18F4550.

I due processori della serie 18F sono molto interessanti perchè rendono la scheda controllabile via USB, senza modifiche hardware, a parte qualche accorgimento sui bus. Le routine software sono standard, liberamente utilizzabili, ma aimè un pò complesse per chi comincia.

La scatola di derivazione, funge da valigetta e mi è molto comoda per il trasporto. Ora, la scheda che vediamo sopra, è stata completata con i display che ho pensato di montare su uno zoccolo a 40 pin per renderli estraibili e quindi poterli usare anche nei vari minishield per fare esperimenti diversi. Possiedo anche un secondo esemplare, assemblato in maniera completa, che vediamo nella prossima foto.

Tuttavia, è possibile montare solo le sezioni che interessano ammortizzando notevolmente la spesa o spalmandola nei tempi necessari all'apprendimento, ad esempio se il motore passo passo lo sviluppiamo tra 2 mesi, potremmo non montare il chip L298, e tutto l' hardware che lo circonda. Insomma possiamo aspettare il prossimo stipendio prima di fare altri acquisti di componenti.

Dato che lo stampato costa solo 15€ è possibile, partire a costo ridottissimo. Ad esempio, se volessimo fare solo le prime prove con I/O digitale si potrebbe assemblare come nella prossima foto:

Anche lo zoccolo textool potrebbe essere opzionale se decidiamo si specializzarci solo in quei PIC a 40 pim che possono essere alloggiati in un normale zoccolo, ad esempio il 16F877A oppure il 18F4550, e molti altri.

Assemblata la scheda in questa maniera è possibile dimezzare il costo del sistema di sviluppo, ma in certe condizioni, e studiando gli schemi elettrici è possibile risparmiare ulteriormente.

Queste condizioni particolari di utilizzo, ci vengono segnalate dallo stesso insegnate, che ha disegnato la scheda.

Ad esempio, se disponiamo di un dispositivo di programmazione prodotto dalla Microchip, è possibile rendere compatibile la Micro-GT IDE direttamente con MPLAB. questi è il pickit3, oppure la versione precedente PICKIT2.

In queste condizioni è possibile non assemblare IC4 e IC2, i tre led DVPP, DPGC, DPGD, i transistor Q6 e Q7 e tutte le resistenze che hanno a che fare con questa area programmer.

A questo punto possiamo entrare in scheda come si vede in questa foto, che ho copiato dal libro "Let's GO PIC the book".

In questo caso, dopo avere compilato il programma, non sarà necessario andare a cercare il file .hex che è stato generato, ma semplicemente andare su "programmer" nella barra degli strumenti di MPLAB, selezionare PICKIT3, e dare il comando di scrittura. Il tutta tramite la porta USB dei notebook.

Il cavetto da costruire è questo in cui si raccomanda di rispettare i colori.

1. marrone
2. rosso
3. arancio
4. giallo
5. verde

La parte a sinistra, i maschi, si infilano direttamente nel PICKIT3, mentre i terminali femmina di destra si infilano negli strip della scheda.

In questa maniera:

anche questa foto la ho copiata dal libro con il permesso dell'insegnante.

L'insegnate consiglia di assemblare comunque la porta seriale perchè sarà oggetto di molte prove che si fanno a lezione, infatti è previsto lo studio di sistemi di interfacciamento a PC, con programmi eseguiti in visual basic 6 o in visual studio .net per fare delle "supervisioni" o una specie di sistemini "SCADA" che useranno l'RS232.

Vediamo un filmato di test di accensione del display, e' una specie di demo per vedere se il bus e' settato giusto e se l'hardware e' operativo

Bibliografia: Micro PIC partenza immediata ebook dicembre 2012 disponibile su www.lulu.com

Let's GO PIC!!! the book settembre 2012 disponibile su www.lulu.com

Appunti dalle lezioni serali del centro culturale ZIP di Padova

Note: Questo articolo e' stato tratto dalle lezione di Microcontrollori PIC di martedi' 15 gennaio 2013. L'insegnate mi ha concesso l'autorizzazione verbale alla divulgazione.

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