segnalazione

di Roberto Vallini
In questo articolo illustrerò una mia creazione speciale, derivata da una “Sfida auto-costruttiva”, al limite del mio ingegno. Ovvero, un pannello muti-funzione, con multi-segnalazione “Customizzabile”. Ho immaginato l’esigenza di avere un dispositivo versatile, “Open-to-All”. Un device, il mio, che può essere utilizzato per qualunque realizzazione, senza limiti. Offrendo, nel progetto, le varie opzioni di segnalazione e di pilotaggio. In sintesi una “Piattaforma” che si presta alle più svariate applicazioni, senza trovarsi, come sovente succede, di fronte ad un progetto che fa, “Solo quello e niente altro che quello”. Più di una volta, ho visto dei progetti validi, ma erano “closed” , sia per l’hardware che per il software. Anche solo un’esigenza aggiuntiva, avrebbe dovuto stravolgere buona parte dell’oggetto. L’inserimento di un operazionale, o un’induttanza, richiedono rimaneggiamenti che possono pesare sul retrofitting. Sostituendo o aggiungendo componenti si possono generare correnti di ritorno, ritardi di esecuzione e tutta una serie di malfunzionamenti, i quali, rischiano di compromettere un buon lavoro.
[iscritti]

La sfida con la giusta misura

Sempre più, i progetti di elettronica si dirigono verso nuove tecnologie, ed è giusto che sia così, però, c’è un però… Perdere il contatto con gli integrati, le resistenze, i dispositivi base, i quali hanno fatto la storia dell’elettronica, comporta due mancanze. La prima è che ci si dirige verso progetti ambiziosi, usufruendo di tecnologie non sempre comprensibili dal vasto pubblico dei lettori (certo, le indicazioni sono dettagliate, ma vengono, a volte, “digerite”, senza averle seriamente comprese). Questo comporta una disaffezione, una mancata affiliazione verso il prodotto.

La seconda è che, di didattico, rimane ben poco: se si comprendono i concetti, bene, viceversa, si prova la sensazione di essere “tagliato fuori”. Sovente ho sentito la frase: ”Di quelle cose ho capito poco”. Conosco poi una miriade di colleghi, tra la mia città ed il Web, i quali, dopo aver dato una lettura, rimangono comunque, saldamente ancorati alle loro conoscenze di elettronica discreta e digitale di base, creando delle release stupende, utili e più semplici. Un inciso; mentre progettavo, ho chiesto un parere in un forum, uno dei tanti che frequento, avevo un dubbio sulle connessioni. Ebbene, una delle tante risposte di un giovane è stata “Ma perché non compri questa shield e scarichi la libreria, così fai più in fretta?”. Penso non ci siano commenti, se non che occorre la giusta misura tra le tecnologie di avanguardia, l’elettronica di base, e la didattica. La visualizzazione può avvenire nelle seguenti maniere: 1)  manuale, 2) con processore tipo Arduino o altro, purché dotato di I/O digitali che generino o accettino una tensione di 5 Volt, 3) con processore e registri a scorrimento SIPO. 4) con processore ed integrati multiplexanti o demultiplexanti, come l’HC74138 o HC74238 e altri che possano soddisfare la filosofia “Open” del progetto. Tutto quanto accennato deve essere associato, e lo vedremo più avanti negli esempi pratici, da un hardware, giustamente dosato, il quale permetta, intuitivamente, di “partire” con i propri progetti. In sintesi uno “Starter kit” con tanto di componenti, istruzioni e progetti.

La genesi auto-costruttiva e le vecchie logiche

Occorre sottolineare che all’origine del progetto, vi è una predisposizione all’auto-costruzione, caratteristica la mia, che emerge da ogni creazione. Scendendo nei particolari, la scheda, proviene da un pannello di controllo incroci video della RAI (Radio Televisione Italiana). Sovente, visito degli installatori, che hanno materiale da smaltire, e in questo caso, mi sono trovato di fronte a una vera miniera d’oro (chi non ha la “vena auto-costruttiva” difficilmente può comprendere). Un pannello lungo 60 cm con led, pulsanti, e sette display… me lo porto in laboratorio.

In Figura 1 si può vedere il pannello originario. La prima sorpresa, non bella, è stata che, gli integrati tra cui una EPROM, avevano il codice cancellato, per questioni di copyright. La difficoltà maggiore è stata, innanzitutto capire cosa avevo davanti, quali tipi di integrati fossero, come era stato concepito il pinout. Ad un primo esame, ho pensato ad una EPROM con in cascata dei “latch”, per memorizzare le varie cifre e/o lettere per i singoli display, usati poi in strana configurazione multiplexing. Ormai, siamo tutti troppo abituati alle MCU da 20, 50, 200 MHz, ma nei vecchi sistemi “lenti” si tendeva a delegare, il piu possibile, del lavoro alle “logiche”, perché i microprocessori antenati, ad 1 o 2 MHz erano già “impacciati” per conto loro a fare tutto il resto. Poi, ho dovuto sbrogliare, con la matita, la miriade di piste, per giungere alla comprensione di quale funzionalità avesse il circuito. Di conseguenza, cosa salvare, e come tagliare, per poter configurare il circuito, evitando di dover costruire completamente il circuito stampato. Il lavoro è stato impegnativo, dovendo rispolverare tutte le cognizioni di elettronica integrata, capire le piste a quali pin conducessero e cosa farne di essi. Un lavoro immenso di retrofit, testando, con ponticelli volanti, breadboard, multimetri e oscilloscopio, le reazioni dei display. Quindi, è avvenuto il taglio di quello che era inutile, e la messa in sicurezza delle piste utili, fresando e forando, con un trapano di precisione, i passaggi che potevano creare dei corto-circuiti. Saldando successivamente i fori di passaggio cavi, i pin-header, e gli hole di fissaggio.

Certo una scelta radicale la mia, ma ne vado fiero. In un’epoca dove, è sempre più difficile trovare qualcosa di innovativo, se non revisioni, dei miglioramenti di qualcosa di già esistente. In figura 2a e 2b si possono vedere quattro fasi critiche del lavoro.

La “Sentenza”: struttura della Board Multifunzione

Osservandola nella “figura n. 3” si vede una scheda-pannello, con sette indicatori (Seven Segment Display), del tipo TFK-639 a catodo comune, sono messi uno accanto all’altro. Il datasheet sette led, che moltiplicato 7, dà il risultato di ben 49 led da controllare. Si sono quindi resi necessari degli array di resistenze in shoket SIL tipo 4S-B, “come si vede in figura 4”, da 1kΩ . Per comodità di inserimento, “nel mio schema in figura 5”, è stato inserito il tipo RN. Le reti resistive sono gruppi di resistori, normalmente di uguale valore, inseriti nel medesimo contenitore tipo SIL o DIL. I display sono pilotati dal “driver-decoder” HC4511.

La true table ed il link dell’integrato in oggetto sono visibili in figura 6. Si aggiungono sette pulsanti, con contatto N/A, i quali, se premuti, danno in uscita una tensione stabile di 5 Volt, e sono “drenati a GND”, con una resistenza di Pull- Up di 10kΩ. L’alimentazione, creata, dopo successive prove, è stabilizzata dal circuito CR2, “visibile in figura 4/a” dove, con l’integrato 7805CS, predisposto nella configurazione a 3 condensatori, fornisce una tensione continua di 5 Volt. Il circuito di ingresso, ha una morsettiera a due poli, rispettivamente Vcc e GND, con due pin di uscita, verso la scheda. Il range di tensione applicabile, può variare da un minimo di 5 ad un massimo di 17 volt. In figura 3/a compare la tabella componenti della scheda di alimentazione.

La configurazione degli I/O

Per poter rendere più snella la circuiteria, e di conseguenza l’avvicinamento alla segnalazione, ho optato per la funzione “Blankingh” degli integrati 4511, di cui parlerò nell’approfondimento 2 che prevede di parallelizzare le decodifiche (DA, DB, DC , DD), con quattro pin-header maschio. Gli enable (abilitazioni), sono collegati a dei pin-header di uscita, anch’essi maschio. Sia nelle codifiche che negli Enable, sono stati inseriti dei cavetti “dupont” con colorazione appropriata, “come si può vedere dalla tabella di figura 7” dove compare anche il pin-Out del processore usato che sarà oggetto dell’approfondimento 2. Ho anticipato, in figura 6, la tabella colori dei cavi in uscita e in ingresso.

Funzione del 4511 o effetto Blanking

Iniziamo con la considerazione che gli integrati 4511, sono composti da tre stadi, corrispondenti ai pin 3, LT. che assolve la funzione di driver di smistamento verso le uscite. Nella maggior parte delle applicazioni viene posto saldamente a VCC, al pin 4, BI, che è il decoder che “legge” i bit inviati dalle sette linee di ingresso, anch’ esso viene posto a VCC. Gli ingressi LE, corrispondenti ai pin 5 dell’integrato 4511, come detto in precedenza, sono stati scelti, evidentemente, per rendere il pilotaggio il più snello possibile.

Prima di raggiungere il Decoder (come si vede dal data sheet) in figura 7/a, ciascuna delle 7 linee d’ingresso attraversa un flip-flop di tipo D-Latch.  Le sue 7 partizioni sono attivate dalla linea di sincronismo (LE, Latch Enable), che li controlla contemporaneamente. Quando LE è a livello 0, fissato al negativo dell’alimentazione, manualmente,o attraverso un “LOW SIGNAL”, proveniente da una board del tipo Arduino Uno, o da un’integrato intermedio, come il 74HC238, i 4 bit del Codice BCD applicato in ingresso, passano inalterati oltre la memoria, che risulta essere “trasparente”, da qui il termine “Blanking”. Nell’istante in cui LE passa da un livello basso a uno alto (cioè sul suo fronte di salita) le uscite D-Latch si attivano sul codice binario presente in DA, DB, DC, DD.

Comparirà quindi sul display, una memorizzazione numerica, per tutto il tempo nel quale la linea LE è tenuta a livello 1, fino a quando verrà riportata a 0. Riassumendo, in termini pratici, la routine per visualizzare un numero assegnato su di un display, occorre, nell’ordine: spegnere tutto attivando la funzione di Blanking attraverso i quattro ingressi BCD (DD, DA, DB, DC), impostare sia il numero da visualizzare, che i display da attivare, attraverso i livelli dei rispettivi EL (EL1, EL2, EL3, EL4,EL5, EL6, EL7), riattivare la visualizzazione, rimuovendo la digitazione di spegnimento.

Davide e Golia

In questa prima parte, mi sono lanciato in una sfida ancora più ardua. Ho voluto, sempre nell’ottica dell’apprendimento didattico, inserire una board Arduino Nano, la quale si pone come “master” della scheda-pannello. Una enormità di collegamenti, display ed integrati, pilotati dal più piccolo “essere” della famiglia Arduino. Dalle specifiche tecniche si può leggere che la massima corrente sopportabile per I/O Pin è di 40mA. Misurando con un amperometro di precisione, nel momento in cui tutti i display visualizzano il numero 8, ovvero quello che ha tutti i sette led accesi, risulta un assorbimento totale di 87,62 mA. Da questa misurazione si deducono due cose. La prima, che, gli integrati di decodifica, riescono a lavorare, senza aumento di temperatura e nessuna alterazione dei segnali, (attraverso gli array di resistenze SIL da 1K). La seconda considerazione logica, è che c’è una corrente massima di 87,62 mA, ripartita in 55,75 mA relativa ai 7 pin, che sono deputati ad abilitare gli Enable (EL1….EL7), e 31,86 mA per i quattro pin deputati alla decodifica BCD. Il totale da 11. Questi dati ci dicono che possiamo tranquillamente usare il nostro microprocessore, senza aspettarci sgradevoli sorprese.

Completamento dell’installazione

Giunto al completamento della modifica, ed alla implementazione del circuito, e fatte le prove di corretto funzionamento, mi trovavo di fronte alla mia scheda, collegata temporaneamente con bread-board e cavetti vari. Ho optato per un vero e proprio “kit”, il quale mi desse la possibilità di alloggiare tutti i componenti ed attuare i collegamenti, nella maniera più compatta possibile. Anche qui tutto rigorosamente fatto con l’inventiva. Come si vede in figura 9, mi sono dotato di pannelli. Il compensato è costituito da fogli di legno le cui fibre sono orientate perpendicolarmente l’una dall’altra, ciò produce un pannello stabile, e cavetti “Doupont” di vario tipo. La scheda, con relativo pannello forato per passaggio cavi, è stata piazzata in verticale, incastrandosi sul case, dove nel lato posteriore, sono stati alloggiati i componenti e collegati. Nota importante: la scheda-pannnello, può essere rimossa con tutti i cavi, per alloggiarla su eventuali altri supporti.

Una programmazione non semplice

Come spiegato nei capitoli precedenti, volendo mantenere la configurazione originaria del circuito, quindi con tutti e 7 i driver decoder 4511, aventi i pin di codifica in comune/parallelo (DA-DB-DC-DD), mentre i pin di enable (EL1, EL2, El3, EL4, EL5, EL6, EL7, EL7) lasciati liberi, la prima programmazione è stata ardua. Forse la parte più istruttiva ed interessante del progetto. Quindi, attraverso il commento dei vari listati, si può comprendere come l’ingegno e le conoscenze vadano applicate a “devices” non presenti sul Web, dove lo sforzo maggiore è  quello di scaricare il driver giusto, per la shield appropriata. Quindi illustrerò una serie di possibili comandi, funzioni e variabili, utili all’apprendimento del linguaggio “C” avanzato.

Primo programma : Dichiarazione di variabili, funzioni, comandi “Elementare”

In questa demo attiverò tutti e sette i display, con un settaggio ed un programma di tipo elementare. Questa  applicazione l’ho immaginata per creare un contasecondi. Ho deciso di attivare tutti i sette display, con lo scopo di far comprendere all’utente come avviene la funzione di Blankingh e di visualizzazione. Nello sketch sono evidenziati le varie fasi di abilitazione e visualizzazione. Il settaggio avviene, ponendo DD= HIGH, DC =HIGH, DB= LOW, DA 0= LOW (Blank). Nel medesimo tempo, che ho ridotto a 100 millisecondi, avviene l’abilitazione degli ENABLE che, nel caso specifico vanno da EL1 A EL7 e sono tenuti TUTTI a LOW, cioè tutti ABILITATI. Dopo tale fase, avviene la visualizzazione vera e propria, che ho stimato in 900 mS, per recuperare il ritardo di settaggio. Quindi avviene il conteggio da 1 a 0 (10) , che cronometro alla mano, corrisponde ad un conteggio di secondi.

Secondo programma: Creazione di un “Array” di pin e di valori “Evoluto”

In questo programma creerò un “Array”. Un array é un insieme di valori a cui si accede con un indice. Può essere richiamato con il nome dell’array e l’indice numerico che corrisponde al numero d’ordine del valore nell’array. Un array deve essere dichiarato ed eventualmente si possono assegnare i valori, prima di utilizzarlo, Quindi l’array è una serie organizzata di oggetti dello stesso tipo (campo di esistenza). Il numero degli elementi contenuti nell’array viene detto dimensione dell’array. Dire che la collezione di oggetti è organizzata, vuol dire che si potrà identificare in modo univoco gli elementi dell’array. L’identificazione di un elemento dell’array viene fatta mediante un indice. In un array di dimensione N il valore dell’indice andrà da 0 a N-1. Con questo programma siamo scesi da circa 240 linee di codice a 136.

Terzo programma: Creazione di vettore “Void Blanking()” – “Avanzato”

Void è il TIPO di dato che ritorna in una funzione, non è una funzione .Si può avere “int miaFunzione()”, ed in tal caso la funzione ritorna un intero, si può avere “long miaFunzione()” ed in tal caso la funzione ritorna un long, oppure avere, “void miaFunzione()” ed in tal caso dalla funzione non ritorna nulla. Una funzione si può mettere dove meglio si crede: prima della funzione setup() (che è void setup() perché non ritorna nulla), dopo la funzione loop() (che è anche essa void ), o metterla in mezzo tra le due. Ciascuna funzione è un blocco indipendente dalle altre. Buona cosa sarebbe metterla prima di dove viene richiamata.

Conclusioni

Questa prima parte si conclude qui, lo scopo didattico penso di averlo raggiunto ed ho alzato ancora alta la bandiera della auto-costruzione. Sono partito da un dispositivo ormai inservibile, di cui non esistevano ne’ manuali ne’ datasheet e anche gli integrati erano stati resi illeggibili. Quindi con tanta pazienza ho sfogliato libri e fatto prove estreme, le quali potevano distruggere il tutto. Prima sfida vinta. Ho modificato al limite il circuito, rendendolo nuovamente utile a qualcosa, quindi se vogliamo la mia è stata anche una sfida “ambientalista”. Nello smaltimento è finito nemmeno il 50% del vecchio dispositivo. Buttare vecchi circuiti significa anche inquinare, soprattutto se non sono a normativa RHOS. Seconda sfida vinta. Quindi ho preso una piccola MCU, grande quanto un pollice di una mano, nata da qualche anno e faticando non poco ho creato una sinergia tra il Presente/Futuro ed il Passato Remoto. Terza sfida Vinta. Infine, con una configurazione circuitale difficile e sconosciuta nel mondo web, trito e ritrito delle Shield for Arduino e ho sperimentato tre programmi, con lo scopo di mostrare come si possa programmare in “C”, partendo dalla base elementare, fino a quella più avanzata. In questa release, così ampia, pur avendo predisposto l’abilitazione di 7 pulsanti, e di tre led di segnalazione, essi non sono stati attivati. Questo al fine di dare un supporto di comando, per future idee di chi ha realizzato questo articolo e auspicabilmente di chi lo legge. Per questa volta non chiedetemi di più, spero che i lettori più attenti comprendano le difficoltà che ho dovuto superare e mi spronino a progetti futuri.

Elenco componenti scheda segnalazione

R1- R14   Network Resistor  1KΩ 1/4 W SIL Type
IC1-IC7   74HC4511
R15-R22   Resistenza 10 KΩ
P1-P7     Pulsante N.A.
Elenco componenti modulo di stabilizzazione Vcc
C1        100μF
C2        100μF
PC3       100nF
IC8       7508LM
M1        Morsettiera pcb 2,5”

Elenco componenti

PA1    Pannello in legno  compensato 26x18x1
PA2    Pannello in legno compensato 26x16x1
GU     Guida di fissaggio in Alluminio 26cm
CAV    Cavetti Dupont MM-MF-FF
BAT    Batteria tampone 6V-1,5Ah
OCK    Occhielli di fissaggio  per tubi rigidi 4pz
UE1    Circuito Equipotenziale Vcc – GND
UE2    Circuito Interfaccia pila- alimentazione

Contasecondi 1
Mode(2,OUTPUT);
pin
void setup()
{
pinMode(2,OUTPUT);//dichiaro il pin DA//
pinMode(3,OUTPUT);//dichiaro il pin DB//
pinMode(4,OUTPUT);//dichiaro il pin DC //  
pinMode(5,OUTPUT);//dichiaro il pin DD//
pinMode(6,OUTPUT);//EL1//Dichiarazione dei pin EL//  
pinMode(7,OUTPUT);//EL2//
pinMode(8,OUTPUT);//EL3//  
pinMode(9,OUTPUT);//El4//
pinMode(10,OUTPUT);//El5//
pinMode(11,OUTPUT);//EL6//
pinMode(12,OUTPUT);//EL7//
}
void loop()
{
digitalWrite(2,HIGH);//D//BLANKINGH - 1 //
digitalWrite(3,HIGH);//C//Il Blankingh, ovvero l'oscuramento//
digitalWrite(4,LOW);//B//dove i dati possano passare inalterati//
digitalWrite(5,LOW);//A// attraverso la memoria
//ABILITAZIONE-EL//
digitalWrite(6, LOW);//EL1//
digitalWrite(7,LOW);//EL2//
digitalWrite(8,LOW);//EL3//
digitalWrite(9,LOW);//EL4//
digitalWrite(10,LOW);//EL5//
digitalWrite(11,LOW);//EL6//
digitalWrite(12,LOW);//EL7//
delay(100);//istante in cui i dati del codice BCD vengono//
//settatti per a visualizzazione del numero 1//
//VISUALIZZAZIONE NUMERO 1 //
digitalWrite(2,LOW); //1//D//
digitalWrite(3,LOW);//C//
digitalWrite(4,LOW);//B//
digitalWrite(5,HIGH);//A//
//Tutti gli EL BASSI quindi DISPLAY ATTIVO//
digitalWrite(6, LOW);//EL1//
digitalWrite(7,LOW);//EL2//
digitalWrite(8,LOW);//EL3//
digitalWrite(9,LOW);//EL4//
digitalWrite(10,LOW);//EL5//
digitalWrite(11,LOW);//EL6//
digitalWrite(12,LOW);//EL7//
delay(900);//STOP VISUALIZZAZIONE-1//
//Identica routine per settare il numero 2//
digitalWrite(2,HIGH);//D//BLANKINGH - 2 //
digitalWrite(3,HIGH);//C//
digitalWrite(4,LOW);//B//
digitalWrite(5,LOW);//A//
//ABILITAZIONE-NUMERO 2//
digitalWrite(6, LOW);//EL1//
digitalWrite(7,LOW);//EL2//
digitalWrite(8,LOW);//EL3//
digitalWrite(9,LOW);//EL4//
digitalWrite(10,LOW);//EL5//
digitalWrite(11,LOW);//EL6//
digitalWrite(12,LOW);//EL7//
delay(100);//SPENTO//
digitalWrite(2,LOW);//2//VISUALIZZAZIONE-2-//
digitalWrite(3,LOW);
digitalWrite(4,HIGH);
digitalWrite(5,LOW);
digitalWrite(6, LOW);//EL1//
digitalWrite(7,LOW);//EL2//
digitalWrite(8,LOW);//EL3//
digitalWrite(9,LOW);//EL4//
digitalWrite(10,LOW);//EL5//
digitalWrite(11,LOW);//EL6//
digitalWrite(12,LOW);//EL7//
delay(900);//STOP VISUALIZZAZIONE//
digitalWrite(2,HIGH);//D//BLANKINGH - 3 //
digitalWrite(3,HIGH);//C//
digitalWrite(4,LOW);//B//
digitalWrite(5,LOW);//A//
digitalWrite(6, LOW);//EL1//
digitalWrite(7,LOW);//EL2//
digitalWrite(8,LOW);//EL3//
digitalWrite(9,LOW);//EL4//
digitalWrite(10,LOW);//EL5//
digitalWrite(11,LOW);//EL6//
digitalWrite(12,LOW);//EL7//
delay(100);
//VISUALIZZIONE NUMERO 3 //
digitalWrite(2,LOW);//3//
digitalWrite(3,LOW);
digitalWrite(4,HIGH);
digitalWrite(5,HIGH);
digitalWrite(6, LOW);//EL1//
digitalWrite(7,LOW);//EL2//
digitalWrite(8,LOW);//EL3//
digitalWrite(9,LOW);//EL4//
digitalWrite(10,LOW);//EL5//
digitalWrite(11,LOW);//EL6//
digitalWrite(12,LOW);//EL7//
delay(900);
//STOP VISUALIZZAZIONE-3-//
digitalWrite(2,HIGH);//D//BLANKINGH - 4 //
digitalWrite(3,HIGH);//C//
digitalWrite(4,LOW);//B//
digitalWrite(5,LOW);//A//
digitalWrite(6, LOW);//EL1//
digitalWrite(7,LOW);//EL2//
digitalWrite(8,LOW);//EL3//
digitalWrite(9,LOW);//EL4//
digitalWrite(10,LOW);//EL5//
digitalWrite(11,LOW);//EL6//
digitalWrite(12,LOW);//EL7//
delay(100);
//VISUALIZZZIONE NUMERO 4//
digitalWrite(2,LOW);//4//
digitalWrite(3,HIGH);
digitalWrite(4,LOW);
digitalWrite(5,LOW);
digitalWrite(6, LOW);//EL1//
digitalWrite(7,LOW);//EL2//
digitalWrite(8,LOW);//EL3//
digitalWrite(9,LOW);//EL4//
digitalWrite(10,LOW);//EL5//
digitalWrite(11,LOW);//EL6//
digitalWrite(12,LOW);//EL7//
delay(900);
//STOP NUMERO 4 //
digitalWrite(2,HIGH);//D//BLANKINGH - 5 //
digitalWrite(3,HIGH);//C//
digitalWrite(4,LOW);//B//
digitalWrite(5,LOW);//A//
digitalWrite(6, LOW);//EL1//
digitalWrite(7,LOW);//EL2//
digitalWrite(8,LOW);//EL3//
digitalWrite(9,LOW);//EL4//
digitalWrite(10,LOW);//EL5//
digitalWrite(11,LOW);//EL6//
digitalWrite(12,LOW);//EL7//
delay(100);
//VISUALIZZAZIONE NUMERO 5 //  
digitalWrite(2,LOW);//5//
digitalWrite(3,HIGH);
digitalWrite(4,LOW);
digitalWrite(5,HIGH);
digitalWrite(6, LOW);//EL1//
digitalWrite(7,LOW);//EL2//
digitalWrite(8,LOW);//EL3//
digitalWrite(9,LOW);//EL4//
digitalWrite(10,LOW);//EL5//
digitalWrite(11,LOW);//EL6//
digitalWrite(12,LOW);//EL7//
delay (900);//QUI IL CODICE SI RIPETE IN MANIERA EGUALE PER TUTTI I 10 NUMERI, PER ESIGENZE DI SPAZIO DI// //IMPAGINAZIONE  E' STATO TAGLIATO//
//STOP VISUALIZZAZIONE NUMERO 5//
//CONTINUAZIONE COME SOPRA//
//Sketch creato da ROBERTO VALLINI in data 16-11-8//
const int K_NUM_PIN = 11; // definisce una costante per il numero di pin
byte PinMy[K_NUM_PIN] = {2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}; //Creo un Array per i pin di input//
const int K_ATTESA = 900;
void setup()
{ delay(1000);
  //Serial.begin(9600);
  for (int i = 0; i < K_NUM_PIN; i++)
  { pinMode ( PinMy[i], OUTPUT);
  }
}
void loop()
{                         //D BLANKING - 1 ABILITAZIONE-EL
  delay(100);             //SPENTO
  MostraCifra(1);
  Blanking();
  delay(K_ATTESA);        //STOP VISUALIZZAZIONE-1
                          //D - BLANKING - 2 ABILITAZIONE-EL
  delay(100);             //SPENTO
  MostraCifra(2);
  Blanking();
  delay(K_ATTESA);        //STOP VISUALIZZAZIONE-2
                          //D - BLANKING - 3 ABILITAZIONE-EL ABILITAZIONE-NUMERO 3
  delay(100);             //SPENTO
  MostraCifra(3);
  Blanking();
  delay(K_ATTESA);        //STOP VISUALIZZAZIONE-3
                          //D - BLANKING - 4 ABILITAZIONE-EL ABILITAZIONE-NUMERO 4
  delay(100);             //SPENTO
  MostraCifra(4);
  Blanking();
  delay(K_ATTESA);        //STOP VISUALIZZAZIONE-4
                          //D - BLANKING - 5 ABILITAZIONE-EL ABILITAZIONE-NUMERO 5
  delay(100);             //SPENTO
  MostraCifra(5);
  Blanking();
  delay (K_ATTESA);       //STOP VISUALIZZAZIONE-5
                          //D - BLANKING - 6 ABILITAZIONE-EL ABILITAZIONE-NUMERO 6
  delay(100);             //SPENTO
  MostraCifra(6);
  Blanking();
  delay(K_ATTESA);        //STOP VISUALIZZAZIONE-6
                          //D - BLANKING - 7 ABILITAZIONE-EL ABILITAZIONE-NUMERO 7
  delay(100);             //SPENTO
  MostraCifra(7);
  Blanking();
  delay(K_ATTESA);        //STOP VISUALIZZAZIONE 7
                          //D - BLANKINGH - 8 ABILITAZIONE-EL ABILITAZIONE-NUMERO 8
  delay(100);             //SPENTO
  MostraCifra(8);
  Blanking();
  delay(K_ATTESA);        //STOP VISUALIZZIONE 8
                          //D - BLANKINGH - 9 ABILITAZIONE-EL ABILITAZIONE-NUMERO 9
  delay(100);             //SPENTO
  MostraCifra(9);
  Blanking();
  delay(K_ATTESA);
                          //D - BLANKINGH - 10 ABILITAZIONE-EL ABILITAZIONE-NUMERO 10(0)
  delay(100);             //SPENTO
  MostraCifra(0);
  Blanking();
 
  delay(1000);
}
void MostraCifra(byte cifra)  // 0-9
{ switch (cifra)
  { case 0: //VISUALIZZAZIONE NUMERO 10(0)
      digitalWrite(PinMy[0], LOW); //D
      digitalWrite(PinMy[1], LOW);
      digitalWrite(PinMy[2], LOW);
      digitalWrite(PinMy[3], LOW);
      break;
    case 1: //VISUALIZZAZIONE NUMERO 1
      digitalWrite(PinMy[0], LOW);  //D
      digitalWrite(PinMy[1], LOW);  //C
      digitalWrite(PinMy[2], LOW);  //B
      digitalWrite(PinMy[3], HIGH); //A
      break;
    case 2: //VISUALIZZAZIONE NUMERO 2
      digitalWrite(PinMy[0], LOW); //D  
      digitalWrite(PinMy[1], LOW);
      digitalWrite(PinMy[2], HIGH);
      digitalWrite(PinMy[3], LOW);
      break;
    case 3: //VISUALIZZAZIONE NUMERO 3
      digitalWrite(PinMy[0], LOW); //D  
      digitalWrite(PinMy[1], LOW);
      digitalWrite(PinMy[2], HIGH);
      digitalWrite(PinMy[3], HIGH);
      break;
    case 4: //VISUALIZZAZIONE NUMERO 4
      digitalWrite(PinMy[0], LOW); //D
      digitalWrite(PinMy[1], HIGH);
      digitalWrite(PinMy[2], LOW);
      digitalWrite(PinMy[3], LOW);
      break;
    case 5: //VISUALIZZAZIONE NUMERO 5
      digitalWrite(PinMy[0], LOW); //D
      digitalWrite(PinMy[1], HIGH);
      digitalWrite(PinMy[2], LOW);
      digitalWrite(PinMy[3], HIGH);
      break;
    case 6:
      digitalWrite(PinMy[0], LOW); //D  //VISUALIZZAZIONE NUMERO 6
      digitalWrite(PinMy[1], HIGH);
      digitalWrite(PinMy[2], HIGH);
      digitalWrite(PinMy[3], LOW);
      break;
    case 7:
      digitalWrite(PinMy[0], LOW); //D  //VISUALIZZAZIONE NUMERO 7
      digitalWrite(PinMy[1], HIGH);
      digitalWrite(PinMy[2], HIGH);
      digitalWrite(PinMy[3], HIGH);
      break;
    case 8:
      digitalWrite(PinMy[0], HIGH); //D  //VISUALIZZAZIONE NUMERO 8
      digitalWrite(PinMy[1], LOW);
      digitalWrite(PinMy[2], LOW);
      digitalWrite(PinMy[3], LOW);
      break;
    case 9:
      digitalWrite(PinMy[0], HIGH); //D  //VISUALIZZAZIONE NUMERO 9
      digitalWrite(PinMy[1], LOW);
      digitalWrite(PinMy[2], LOW);
      digitalWrite(PinMy[3], HIGH);
      break;
  }
}
void Blanking()
{ for ( int i = 4; i < K_NUM_PIN; i++) // cella 4 contiene pin 6
    digitalWrite(PinMy[i], LOW);// EL cella 4 a 11 ovvero pin 6 a 12
} 
GIOVANNI DI MARIA