I.I.S. "PRIMO LEVI" - Torino
AREA DI PROGETTO
Progettazione e realizzazione di un sistema
informatizzato per la gestione funzionale di un
magazzino con l'utilizzo di codici a barre e Arduino
Esecutori:
Giuseppe CROCE
Federico LORELLO
5°BN
5°BN
Coordinatori:
Prof. Mario MEZZO
Prof. Francesco CORMAGGI
Prof. Giorgio CARPIGNANO
Anno scolastico 2013/14
Indice
1
Introduzione ............................................................................................. 6
1.1
Il concetto di magazzino ................................................................ 6
1.2
Lo stoccaggio della merce ............................................................. 7
2
Caratteristiche dei codici a barre ........................................................... 8
2.1
Cosa sono i codice a barre ............................................................. 8
2.2
Perché utilizzare i codici a barre .................................................... 8
2.3
Gli standard più diffusi .................................................................. 9
2.3.1 Codice EAN.................................................................... 10
2.3.2 Codice UPC .................................................................... 10
2.4
La stampa ..................................................................................... 11
2.5
Tecnologie di lettori ..................................................................... 11
2.5.1 Scanner a laser ................................................................ 12
2.6
Trasmissione dati ......................................................................... 13
2.7
RFID, tecnologie a confronto ...................................................... 13
2.7.1 Importanza e diffusione .................................................. 13
2.7.2 Descrizione fisica ........................................................... 14
2.7.3 Tag .................................................................................. 16
2.7.3.1 Modalità read-only e read/write ...................... 18
2.7.3.2 Vantaggi rispetto a codici a barre .................... 18
2.7.4 Applicazioni RFID ......................................................... 19
2.7.4.1 Logistica magazzini ......................................... 19
2.7.4.2 Antitaccheggio ................................................. 19
3
Generalità sulle reti ............................................................................... 20
3.1
Classificazioni .............................................................................. 20
3.2
Il wireless ..................................................................................... 22
3.2.1 Caratteristiche tecniche e architettura ............................ 23
3.2.2 Le classi .......................................................................... 24
3.2.3 Tecniche di trasmissione Spread Spectrum .................... 24
3.2.3.1 Descrizione ...................................................... 25
3.2.3.2 Frequency hopping .......................................... 26
3.2.3.3 Direct sequence ............................................... 27
4
Progettazione e realizzazione del prototipo ........................................ 28
4.1
Caratteristiche per gli utenti finali ............................................... 28
4.2
Funzioni principali del sistema .................................................... 28
4.3
Caratteristiche dell'hardware........................................................ 29
4.4
Componenti .................................................................................. 30
pag. 3
4.4.1
4.5
4.6
4.7
4.8
5
Arduino ........................................................................... 31
4.4.1.1 Introduzione alla scheda .................................. 31
4.4.1.2 Caratteristiche tecniche di Arduino Yun ......... 32
4.4.1.3 Alimentazione.................................................. 34
4.4.1.4 Input e Output .................................................. 35
4.4.1.5 Bridge .............................................................. 35
4.4.2 Scanner di codici a barre ................................................ 36
4.4.2.1 Il protocollo PS2 .............................................. 36
4.4.3 Tastiera ........................................................................... 39
4.4.3.1 Tastiera a matrice ............................................ 39
4.4.4 Display LCD ................................................................... 40
4.4.5 Batteria da 9V ................................................................. 40
Progettazione dello schema elettrico ........................................... 41
4.5.1 Circuito di alimentazione ............................................... 41
4.5.2 Connessione con l'LCD .................................................. 42
4.5.3 Tastiera analogica ........................................................... 43
4.5.4 Trigger per il tastierino ................................................... 45
4.5.5 Interfacciamento con il connettore PS2 .......................... 46
Realizzazione pratica della scheda elettrica ................................. 47
4.6.1 Design ............................................................................. 47
4.6.2 Costruzione del PCB ...................................................... 48
Sviluppo del software .................................................................. 49
4.7.1 Casi d'uso ........................................................................ 49
4.7.1.1 Identificazione merci ....................................... 50
4.7.1.2 Carico merci .................................................... 50
4.7.1.3 Scarico merci ................................................... 51
4.7.2 Database ......................................................................... 51
4.7.2.1 Cos'é un database ............................................. 51
4.7.2.2 Scelta del tipo di database ............................... 52
4.7.2.3 SQLite.............................................................. 52
4.7.2.4 Tabelle SQL e Query ....................................... 53
4.7.3 L'architettura del web server .......................................... 55
4.7.3.1 Interfaccia web ................................................ 56
4.7.4 Sketch Arduino ............................................................... 59
4.7.4.1 Comunicare con il database ............................. 60
4.7.4.2 Riconoscimento del tasto ................................. 61
Tabella riassuntiva dei costi finali ............................................... 63
Conclusioni
........................................................................................ 64
Appendice A - Schema circuitale ......................................................... 65
pag. 4
Appendice B - Circuito stampato ......................................................... 66
B.1.
PCB................................................................................. 66
B.2.
Lato componenti ............................................................. 67
B.3.
Lato saldature ................................................................. 68
Appendice C - Fotografie ...................................................................... 69
C.1.
Visione dall'alto .............................................................. 69
C.2.
Visione di lato................................................................. 70
C.3.
Visione da dietro............................................................. 70
Appendice D - Sketch ............................................................................ 71
Sitografia ................................................................................................ 82
pag. 5
Scanner Barcode
pag. 6
Capitolo 1
Introduzione
Il progetto è stato svolto durante l'anno scolastico con l'obbiettivo di realizzare
l'hardware e il software necessario a fornire un sistema informatizzato per la
gestione delle giacenze di un magazzino, delle operazioni di carico e di scarico
delle merci mediante l'utilizzo dei codici a barre per identificare i prodotti.
Le aziende che scelgono di non affidarsi a queste tecnologie si rimettono
solitamente alle conoscenze che il magazziniere possiede dello stato del
magazzino, il quale basa i propri controlli su riscontri puramente visivi e che
quindi può incorrere nell'errore umano. Il sistema in esame si propone di
automatizzare le operazioni di carico e di scarico delle merci, eliminando le
problematiche che possono sorgere nelle fasi di consegna e spedizione.
In un mercato sempre più competitivo diventa della massima importanza gestire
il magazzino in modo rapido e preciso. I codici a barre applicati sui prodotti e
sulle merci in giacenza aiutano in questo compito. La possibilità di fare un
inventario di magazzino passa attraverso una operazione fondamentale: tutto il
materiale posto a magazzino deve portare un'etichetta con codice a barre in
grado di identificarlo.
1.1 Il concetto di magazzino
Da sempre il magazzino è parte integrante di tutte le realtà aziendali e viene
considerato uno dei punti vitali dell'impresa a cui il management dedica
particolare attenzione vista la funzione essenziale che espleta all'interno
dell'azienda ed in tutto il processo produttivo.
Il termine "magazzino" si riferisce ad un locale adibito al deposito e alla
conservazione delle merci. Da un punto di vista economico-aziendale questa
definizione risulta riduttiva poiché con lo stesso termine si fa riferimento ad una
struttura logistica in grado di ricevere merci, custodirle, conservarle e di renderle
disponibili per lo smaltimento e la consegna. Il ruolo assolto dal magazzino va
quindi ben oltre a quello di mero deposito merci. Esso garantisce la continuità
del processo produttivo e la tempestività nel soddisfacimento dei bisogni della
clientela. Grazie all'utilizzo di un magazzino si può provvedere agli
approvvigionamenti secondo i ritmi giudicati più opportuni e nei tempi in cui i
prezzi si ritengono più convenienti.
pag. 7
1.2
Lo stoccaggio della merce
Un magazzino risulta efficiente quando è possibile reperire in tempi abbastanza
brevi tutti i prodotti richiesti. È essenziale che ogni addetto al magazzino debba
conoscere quali prodotti siano in stoccaggio e in quale quantità. In tal senso gli
indici delle scorte forniscono dati importantissimi su cu il management può
basare l'intera strategia aziendale. Un livello di scorte eccessivo o insufficiente
può generare nei casi più gravi il fallimento dell'azienda, o, nei casi blandi il
ritardo nelle consegne, il sottoutilizzo delle risorse, l'obsolescenza dei materiali
presenti nelle scorte.
Per una corretta gestione delle scorte non è sufficiente individuare il livello della
scorta minima di sicurezza per cui serve richiedere il riordino della merce, ma
bisogna tenere sotto controllo anche altri fattori, che seppur non vitali, servono
per una oculata gestione. Il parametro più utilizzato ed efficace per apprezzare la
velocità di circolazione delle merci è l'indice di rotazione delle scorte. Esso
indica il numero delle volte in cui avviene il completo rinnovo della merce in
stoccaggio in un determinato periodo di tempo ed è utile per individuare quali
articoli tendono a sostare troppo a lungo in magazzino. Una volta calcolato tale
indice bisogna interpretarlo tenendo conto delle caratteristiche svolte
dall'azienda e dei beni che essa tratta. Risulta intuibile che un magazzino di una
impresa che tratta prodotti deperibili (come la frutta) debba avere un indice di
rotazione più elevato di un'altra che tratta tutt'altra categoria di prodotti. Un
elevato indice di rotazione indica che le scorte sono rimaste in magazzino per un
periodo limitato e l'impresa è così riuscita a rientrare dell'investimento
impiegato per l'acquisto. Al contrario una lenta rotazione significa che le risorse
investite sono rimaste immobilizzate a lungo, creando tensione finanziaria.
Il calcolo dell'indice di rotazione può essere effettuato in base al rapporto tra le
quantità vendute (o utilizzate) in un determinato periodo di tempo e la quantità
delle scorte medie registratasi nello stesso periodo.
Figura 1.1. Formula per calcolare la velocità di rinnovo di singole merci.
La scorta media si può calcolare in due modi: dividendo per 13 la somma del
numero delle scorte iniziali con quelle rilevate alla fine di ciascun mese solare,
oppure con la semisomma della quantità delle scorte esistenti all'inizio del
periodo che si vuole analizzare (Si) con quella in rimanenza alla fine del
medesimo (Sf).
Figura 1.2. Formula per calcolare la scorta media
pag. 8
Capitolo 2
Caratteristiche dei codici a barre
2.1 Cosa sono i codice a barre
I codici a barre sono stati introdotti negli anni 70 e la loro adozione è sempre più
ampia per i riconosciuti vantaggi che offre. Esprimono alcuni elementi dei
prodotti commerciali, come il prezzo e il codice di magazzino. Possono essere
definiti come una simbologia o un alfabeto per la codifica di informazioni in un
formato tale da poter essere acquisiti automaticamente da opportuni lettori.
Si presenta come una immagine composta da bande di linee verticali di spessore
variabile, leggibili attraverso un sensore e convertite in numeri da un apposito
lettore.
Figura 2.1. Esempio di codice a barre
I codici a barre permettono quindi la memorizzazione di informazioni in
maniera non volatile su di un supporto, e la possibilità di recuperarle in seguito
con semplici apparati di lettura di tipo ottico.
2.2 Perché usare i codici a barre
Il computer è stato protagonista dello sviluppo tecnologico degli ultimi decenni
grazie alla sua capacità di elaborare enormi quantità di dati in tempi brevi. Tali
dati sono però forniti dal mondo esterno e le modalità di acquisizione
influiscono sulla rapidità e sulla correttezza delle operazioni.
Solitamente l'acquisizione dei dati avviene tramite l'operatore umano, mediante
l'uso di terminali. Da ciò derivano problemi quali la lentezza della digitazione
dei dati e l'alta probabilità di errore dovuta alla digitazione degli stessi. Per
questo si è reso necessario un sistema di codifica adatto ai sistemi automatici di
rilevamento. La tecnologia dei codici a barre è una di queste.
pag. 9
I codici a barre si sono imposti nel tempo come la tecnologia vincente nel
settore dell'Identificazione Automatica e per tale motivo ha trovato impiego in
tutti i principali settori dell'industria e del commercio. Un sistema di
identificazione basato su codici a barre deve tenere conto di quattro
caratteristiche fondamentali:
o Automazione – mediante l'utilizzo di lettori, decodificatori e scanner
industriali. Essi danno la possibilità di leggere il codice a barre in modo
automatico e senza la presenza dell'operatore. Ciò permette la
costruzione di linee automatiche o robotizzate.
o Attendibilità – i codici a barre si sono rivelati uno dei sistemi più
attendibili grazie all'uso di due parametri: una cifra di controllo e un
numero fisso di cifre.
o Precisione – da studi e ricerche presso Università americane si è
constatato che si può verificare un errore di lettura ogni 4.4 milioni di
caratteri.
o Velocità – l'acquisizione dei dati avviene più velocemente di quella fatta
manualmente.
Grazie ai codici a barre è possibile identificare e inventariare merci di qualsiasi
genere tramite il semplice passaggio di dispositivi ottici.
2.3 Gli standard più diffusi
La standardizzazione dei codici a barre è stata e continua ad essere essenziale
per la crescita e la diffusione di questa tecnologia, consentendo ai fornitori di
produrre etichette, stampanti, scanner, unità di controllo ed interi sistemi che
possono interagire tra di loro in un ambiente aperto.
Le diverse logiche di codifiche dettate da diverse esigenze applicative ha portato
alla creazione di diversi tipi di codici a barre, alcuni ampiamente diffusi, altri
limitati a precisi settori, altri ancora solo per determinati paesi. Agli inizi sono
state proposte diverse tecniche di codifica, alcune sono quasi completamente
sparite dall'uso pratico, mentre altre si sono evolute nel tempo. Attualmente solo
una decina di codifiche sono usate.
A seconda della codifica utilizzata i codici a barre possono codificare solo dati
numerici, oppure tutto o parte dell'insieme di caratteri ASCII.
In genere sotto i codici a barre sono presenti anche i caratteri che essi
rappresentano, rendendo possibile all'operatore umano la lettura senza scanner
ottici.
pag. 10
2.3.1
Codice EAN
È il codice più utilizzato per la codifica dei prodotti. Ne esistono due versioni:
EAN-13 e EAN-8, entrambe rappresentano un codice esclusivamente numerico
a lunghezza fissa: 13 caratteri per il primo e 8 per il secondo. Il formato è
leggibile in entrambe le direzioni, ed è compatibile con il sistema UPC. È usato
per la marcatura dei prodotti destinati alla vendita al dettaglio.
Figura 2.2. Esempio di codice EAN-13
È un codice estremamente affidabile e segue il seguente schema: le prime due
cifre identificano il paese dove è stata richiesta la codifica (ad esempio 80 è
riservato all'Italia), le successive cinque cifre identificano il produttore
(nell'esempio di figura 2.4 sono le cifre "12345"), mentre le ulteriori cinque cifre
identificano il prodotto all'interno dell'azienda (nell'esempio sono "67890").
L'ultima cifra è il codice di controllo che viene calcolato automaticamente
mediante l'algoritmo del codice stesso.
2.3.2 Codice UPC
Compatibile con il codice EAN, rappresenta il codice numerico di ogni articolo
soggetto alle norme UPC (Universal Product Code) in uso negli Stati Uniti.
Un codice UPC è un numero di 12 cifre.
Figura 2.3. Esempio di codice UPC
pag. 11
2.4
La stampa
I codici a barre possono essere prodotti in molti modi: con stampanti laser o a
getto d'inchiostro, per marcatura diretta, o più semplicemente prestampando
delle etichette da incollare successivamente al prodotto portatore.
È di fondamentale importanza una stampa precisa, perché da essa dipende il
successo della lettura del codice a barre.
Esistono alcune regole generali da rispettare durante la stampa, al fine di non
avere problemi durante la lettura. Le dimensioni ideali di riferimento sono
basate su rapporti proporzionali ben definiti (fattori di ingrandimento). Per ogni
fattore di ingrandimento esistono tolleranze accettabili. Le dimensioni minime
suggerite per l'EAN-13 sono di 29.8mm per 20.7mm. È indispensabile non usare
colori ombreggianti e materiali riflettenti (come l'alluminio). Occorre poi
stampare il codice all'interno dei margini: se decentrata ne potrebbe conseguire
una perdita di informazioni.
Figura 2.4. Applicazione non corretta del barcode.
2.5 Tecnologie di lettori
Dopo che il codice a barre è stato stampato si presenta la necessità di leggerlo
con sistemi automatici. I dispositivi destinati allo scopo sono denominati lettori
o scanner, e ne esistono di sofisticati e avanzati. Che siano portatili, con
memoria o wireless, avranno il semplice compito di leggere il codice e di
trasformarlo in un numero. È necessario che i lettori siano in grado di
decodificare correttamente e velocemente i codici applicati sugli oggetti,
considerando che un errore di identificazione potrebbe creare situazioni
problematiche.
pag. 12
2.5.1 Scanner a laser
Nella forma più semplice il dispositivo si presenta come una pistola che
l'operatore punta e allinea sul codice a barre che intende leggere. Alla pressione
del grilletto lo scanner emette un raggio laser che, opportunamente deflesso,
percorre tutta l'ampiezza del codice e ne permette la lettura. Gli scanner laser
effettuano molte letture per migliorare l'affidabilità del sistema e ridurre così la
possibilità di errori nella decodifica.
Figura 2.5. Modalità di lettura di uno scanner laser.
Il dispositivo è normalmente costituito da tre unità funzionali: una sorgente di
luce fissa (normalmente un diodo laser), un sistema ottico di prismi rotanti e/o a
specchio oscillante che servono a deflettere il fascio laser emesso dal diodo e un
fotorivelatore che raccoglie la luce riflessa e traduce l'intensità della stessa in un
segnale elettrico che può essere successivamente interpretato e tradotto.
Lo scanner laser converte quindi l'intensità luminosa in un segnale elettrico
avente fluttuazioni di ampiezza correlate alla riflettenza della superficie del
simbolo, e che quindi potrà essere elaborata per estrarre l'informazione
desiderata.
Figura 2.6. Segnale elettrico corrispondente ad un codice a barre.
pag. 13
2.6 Trasmissione dei dati
La scelta della porta di comunicazione per l'invio del codice scansionato tra il
dispositivo di lettura ed il terminale permette di stabilire in modo definitivo i
requisiti hardware che il progetto deve possedere. Sono disponibili diverse
interfacce e ciascuna possiede le proprie caratteristiche.
I moderni lettori di codici a barre sono normalmente disponibili con l'uscita
seriale RS232, l'uscita USB o con porta PS2 in modalità Emulazione di tastiera.
Ciascuna delle tre opzioni ha caratteristiche diverse e il software dipenderà da
quale interfaccia si adotta.
2.7 RFID, tecnologie a confronto
In telecomunicazioni ed elettronica con l'acronimo RFID, Radio Frequency
Identification, si intende una tecnologia per l'identificazione e/o la
memorizzazione dati automatica di oggetti, animali o persone (automatic
identifying and data capture, AIDC), basata sulla capacità di memorizzazione di
particolari dispositivi elettronici, detti tag o transponder.
I tag hanno la capacità di rispondere all'interrogazione a distanza da parte di
appositi apparati fissi o portatili, chiamati per semplicità lettori a radiofrequenza
(in realtà sono anche scrittori), comunicando le informazioni che essi stessi
contengono. In un certo senso possono quindi essere assimilati a sistemi di
lettura e/o scrittura senza fili, con svariate applicazioni.
2.7.1 Importanza e diffusione
La tecnologia RFID prende origine dalla seconda guerra mondiale e si sviluppa
a partire dagli anni Sessanta come derivazione a scopi civili del sistema militare
a radiofrequenza di Identification Friend or Foe, ma la sua diffusione è avvenuta
principalmente dagli anni Novanta in poi.
I transponder IFF inventati in Gran Bretagna nel 1939, basati su una tecnologia
analoga, vennero ampiamente utilizzati dagli alleati durante la seconda guerra
mondiale per identificare gli aerei individuando i mezzi amici e i nemici.
I transponder vengono impiegati ancora oggi sui velivoli, sia per scopi militari
che commerciali. Il primo brevetto in cui figura la sigla RFID è stato depositato
da Charles Walton nel 1983, brevetto USA 4.384.288, ma in realtà la tecnologia
è stata depositata nell’agosto del 1973 con il brevetto USA 3.752.960, e da
allora ne sono stati registrati quasi altri 4000 (al 2011).
pag. 14
2.7.2 Descrizione fisica
Un sistema RFID è costituito da tre elementi fondamentali:
o Un apparecchio di lettura e/o scrittura (lettore).
o Una o più etichette RFID (o tag o transponder)
o Un sistema informativo di gestione dati, per il trasferimento dati da e
verso i lettori.
L'etichetta RFID può essere attiva, passiva, semi-passiva o semi-attiva.
La RFID attiva dispone di:
o Una batteria per alimentarla.
o Una o più antenne per inviare il segnale di lettura e ricevere le risposte
anche su frequenze diverse.
o Uno o più transponder/tag RFID. Questi tipi di etichette possono
contenere dei sensori. In genere hanno distanze operative maggiori dei
tag passivi ed arrivano al massimo a 200 metri.
La RFID passiva contiene semplicemente un microchip con un identificativo
univoco ed eventuale memoria, privo di alimentazione elettrica, un'antenna ed
un materiale che fa da supporto fisico chiamato "substrato" e che viene eccitato
o scritto al passaggio di un lettore che emette un segnale radio a frequenze basse
o medie o di alcuni gigahertz (sotto le diverse bande usate). La radiofrequenza
attiva il microchip e gli fornisce l'energia necessaria a rispondere al lettore,
ritrasmettendogli un segnale contenente le informazioni memorizzate nel chip. Il
lettore, come abbiamo già detto, può anche scrivere dati sul tag.
La RFID semi-passiva è dotata di batteria; questa è usata solo per alimentare il
microchip o apparati ausiliari (sensori), ma non per alimentare un trasmettitore,
in quanto in trasmissione si comporta come un'etichetta RFID passiva.
La RFID semi-attiva, infine, è dotata di batteria che alimenta il chip ed il
trasmettitore; per risparmiare energia, l'etichetta RFID è disattivata e viene
attivata tramite un ricevitore con la tecnologia dei tag passivi, quindi in assenza
di interrogazioni il tag può operare per tempi lunghi.
L'elemento principale che caratterizza un sistema RFID è l'etichetta RFID o
transponder o tag ed è costituito da:
o Un microchip che contiene dati in una memoria (tra cui un numero
Univoco universale scritto nel silicio).
o Un’antenna.
pag. 15
o Un supporto fisico che tiene insieme il chip e l'antenna chiamato
"substrato" e che può essere in Mylar, film plastico (PET, PVC, ecc.),
carta o altri materiali.
o In rari casi viene usata una batteria.
Quando l'antenna riceve un segnale, lo trasforma in energia elettrica secondo il
principio dell'induzione; questa va ad alimentare il microchip. Il chip così
attivato trasmette i dati in esso contenuti tramite l'antenna (circuito di
trasmissione del segnale) all'apparato che riceve i dati. In sintesi, un tag RFID è
in grado di ricevere e di trasmettere via radiofrequenza le informazioni
contenute nel chip ad un transceiver RFID.
Il lettore emette un campo elettromagnetico/elettrico che tramite il processo
della induzione genera nell'antenna del tag una corrente che alimenta il chip. Il
chip così alimentato comunica tutte le sue informazioni che vengono irradiate
tramite l'antenna verso il Lettore; quest’ultimo può anche scrivere i dati sul tag.
RFID Technology
• RFID = Radio Frequency IDentification
Antenna
Power &
Commands
Data
01010110
10101011
RFID Reader
Figura 2.7. Tecnologia RFID.
RFID Tag
pag. 16
2.7.3 Tag
L'elemento che caratterizza un sistema RFID è il transponder o tag. Il tag è un
dispositivo elettronico composto da un chip ed un'antenna RF montati su un
"substrato" che ha anche il compito di sostenerli. Il chip, della grandezza di
pochi millimetri, è costituito da una memoria non volatile ed un codice in genere
univoco, che viene trasmesso tramite l'antenna RF (la spira risonante o circuito
di trasmissione del segnale wireless) all'apparato lettore, il quale leggerà i dati
ricevuti o li aggiornerà.
Nei tag passivi, il lettore emette un campo elettromagnetico o elettrico - a
seconda delle frequenze - che tramite induzione genera nell'avvolgimento
elicoidale del tag una tensione che a sua volta alimenta il chip. Il chip così
attivato comunica tutte le sue informazioni irradiandole tramite l'avvolgimento
verso il Lettore. I tag attivi invece sono alimentati da una piccola batteria interna
(RFID attivi).
Gli RFID si possono realizzare in tantissimi formati: inseriti in etichette simili a
quelle utilizzate nei capi di abbigliamento, oppure sotto forma di adesivi da
applicare sulle confezioni di cartone dei prodotti, o all'interno di tessere formato
carta di credito.
Per estrarre le informazioni contenute nell'etichetta è necessario un lettore fisso
o portatile. Il vantaggio offerto da questo tipo di tecnologia rispetto ai sistemi di
identificazione attualmente più utilizzati (come i codici a barre e lettori a banda
magnetica), è che il lettore non deve necessariamente avere la visibilità ottica
dell'etichetta; inoltre il funzionamento è estremamente veloce, in quanto la
lettura avviene in circa 1 decimo di secondo.
Esistono numerosi tipi di tag RFID, alcuni dei quali normati da standard ISO e
bande di frequenza operative ben definite, di cui le principali sono quelle
indicate sotto:
o 125/134 kHz – LF, Low Frequencies, valida in tutto il mondo.
o 13,56 MHz – HF, High Frequencies, valida in tutto il mondo.
o 433 MHz – UHF, Ultra High Frequencies bassa, solo per tag Attivi, solo
in Europa.
o 860-960 MHz – UHF, Ultra High Frequencies media, a seconda dei
continenti che hanno potenze massime e bande di frequenza diverse.
o 2,4 GHz – UHF Alta, principalmente per attivi, anche se esistono anche
tag passivi, in tutto il mondo.
pag. 17
o 5,8 GHz – SHF Super High Frequencies, solo tag attivi, esempio è il tag
attivo "Telepass" molto diffuso nelle auto in Italia per l'accesso
automatico alle Autostrade a pagamento.
o > 5,8 GHz – UWB Ultra Wide Band (3.1 GHz-10.6 GHz), solo tag attivi.
I tag 125 kHz e 13,56 MHz sono previsti dalle norme ISO come passivi quindi
senza batterie, mentre tra i tag RFID UHF e Ultrawide Band ne esistono di
attivi, semi-attivi e di passivi. I tag attivi sono alimentati da batterie; i tag
semiattivi sono alimentati da batterie solo per mantenere attiva la parte circuitale
interna, mentre per l'irradiazione utilizzano una parte dell'energia ricevuta
dall'onda radio che trasmette e informazioni. Infine i tag passivi non hanno una
fonte di alimentazione interna, ma traggono l'energia dall'onda radio inviata dal
lettore che li interroga per attivarsi e ritrasmettere i dati.
RFID Tag Features
LF
125 kHz
HF
13,56 MHz
UHF
850-950 MHz
MW
2.54 GHz
Read range
(passive tag)
0.5 m
1 – 1.5 m
3m
5 – 10 m
Data rate
scarce
good
high
very high
good
fair
scarce
poor
very large
large
medium
small
access control,
animal tracking
access control,
object tracking
pallet and container
tracking, electronic
fee collection
supply chain,
electronic fee
collection
Read capability
metals/liquids
Size
Typical
applications
Figura 2.8. Tipi di tag RFID.
pag. 18
2.7.3.1 Modalità read-only e read/write
La modalità read-only consente di utilizzare la tecnologia RFID in sostituzione
del codice a barre sfruttando i seguenti vantaggi:
o Affidabilità della lettura.
o Eliminazione della necessità di "vedere" l'etichetta (le etichette radio
possono essere contenute all'interno dei prodotti ed essere lette anche in
più esemplari contemporaneamente).
o Capacità di lavorare in ambienti contaminati e sporchi.
o Capacità di resistere, con opportune protezioni, all'aggressione di agenti
chimici e ambientali e di poter operare immerso in un fluido dentro
l'oggetto che si vuole identificare, oppure all'interno di un altro
contenitore (purché non completamente metallico).
o Possibilità di leggere, nello stesso contenitore, il codice di decine o
centinaia di etichette in un lasso temporale di pochi secondi, e di
trasmetterlo al sistema informativo di gestione.
I tag dotati di memorie non volatili (qualche kilobyte) possono contenere
informazioni molto articolate sull'oggetto cui sono associate.
La modalità read/write permette non solo una trasmissione di informazioni ma
un loro aggiornamento sul chip. Il tag diventa un sistema di identificazione che
può tenere traccia della storia di un prodotto fin dalla fase di lavorazione ed
essere poi utilizzata in modo interattivo lungo tutta la filiera fino alla
distribuzione al dettaglio e in alcuni casi anche fino all’arrivo al consumatore.
2.7.3.2 Vantaggi rispetto a codici a barre e bande magnetiche
La tecnologia RFID presenta alcuni semplici vantaggi rispetto alle tradizionali
tecnologie dei codici a barre e delle bande magnetiche:
o L’oggetto non deve essere a contatto del lettore per essere
decodificato come le bande magnetiche.
o Non deve essere visibile per essere letto come per i codici a barre.
o Si possono anche aggiungere informazioni sui chip in funzione della
tipologia del chip: Read Only: si possono solo leggere le
informazioni contenute; Write Once, Read Many: si possono scrivere
nel chip le informazioni una sola volta, ma leggerle un numero
illimitato di volte; Read and Write: si possono leggere e memorizzare
informazioni per un numero limitato ma piuttosto grande di volte.
o L'identificazione e la verifica avvengono in 1/10 di secondo.
o La comunicazione può essere in chiaro o cifrata.
pag. 19
2.7.4 Applicazioni RFID
Le soluzioni su tag 13,56 MHz trovano applicazioni in:
o standard ISO 15693 fino ad 1m, per la tracciabilità (alimentare, di
prodotti vari, ecc).
o standard ISO 14443 (ad alta sicurezza), fino a 10 cm, per carte bancarie,
tessere, documenti di identità elettronici, titoli di viaggio elettronici,
sistemi di bigliettazione elettronica per metropolitane, treni, autobus,
moneta elettronica per macchine distributrici di prodotti alimentari, ecc.
o le soluzioni con tag UHF ISO 18000 fino a circa 10 m, sono dedicate alla
logistica d’azienda.
o le soluzioni con tag 2,4 GHz per la mobilità (Telepass) e per gli
interporti.
2.7.4.1 Logistica magazzini
Identificare ogni contenitore e ogni scaffale di magazzino con tag riduce gli
errori nei prelievi e fornisce una identificazione certa dell'item (in funzione delle
entità controllate si parla di Item Tagging, ovvero oggetto unico o Box
Tagging). Non è necessario aprire gli imballaggi per verificare il contenuto
cercando il codice a barre, così come non è più necessario effettuare il conteggio
manuale per la verifica dell'inventario fisico; con una serie di scansioni a
distanza è possibile identificare e verificare la presenza di specifici oggetti in
magazzino. Infatti, questo sistema permette di leggere contemporaneamente più
etichette (tag), in generale fino a 100. Questa tecnologia permette di conoscere
in tempo reale le giacenze di magazzino e di riordinare i capi esauriti con un
click.
2.7.4.2 Antitaccheggio
Il primo aiuto tecnologico, oggi largamente utilizzato su scala mondiale, è
arrivato dalla EAS (Electronic Article Surveillance). Mediante l'applicazione di
un piccolo tag chipless (senza chip) agli oggetti in vendita, un negozio può
rilevare un eventuale transito non autorizzato di un articolo attraverso un varco.
Il varco, composto da antenna, è collegato ad un dispositivo di segnalazione
acustica e visiva.
pag. 20
Capitolo 3
Generalità sulle reti
3.1 Classificazioni
Un insieme di computer messi in grado di comunicare e condividere risorse
hardware e software costituisce una rete dati.
Vi sono vari modi di classificazione di una rete, anche in dipendenza dell'area
geografica ricoperta; si utilizzano dunque i seguenti acronimi:
o PAN – Personal Area Network, sono essenzialmente reti di
piccole dimensioni (una stanza).
o LAN – Local Area Network, sono reti che possono coprire
un’area limitata, ad esempio una proprietà privata, come un
edificio, un complesso industriale, ecc.
o CAN – Campus Area Network, sono reti di dimensioni
maggiori di una LAN, che coprono un’area di qualche
edificio.
o MAN – Metropolitan Area Network, sono reti che collegano
più computer e/o delle LAN e possono ricoprire un'area
metropolitana.
o WAN – Wide Area Network, sono reti che coprono intere
regioni o nazioni.
o GAN – Global Area Network, sono realizzate dall’unione di
più reti WAN.
A seconda dell’architettura delle reti è possibile distinguere tra varie
topologie:
o A BUS: In questa configurazione vi è un solo cavo (bus) che
collega in parallelo tutti i terminali di una LAN. Dato che i
terminali ricevono lo stesso segnale, un’interruzione o un
cortocircuito in un punto qualsiasi del cavo coassiale provoca
l’interruzione di tutta la rete.
pag. 21
o AD ANELLO: questa topologia prevede un solo cavo come quella
a bus, ma i computer in questo caso sono connessi in serie,
formando così un percorso chiuso. La comunicazione tra i
terminali avviene in modo che una stazione riceve i dati da quella
precedente e li invia a quella successiva: se questa non è la
stazione terminale, la precedente provvederà ad inviarli alla
postazione seguente, finché il dato non avrà raggiunto il
destinatario finale.
o A STELLA: in questo tipo di rete vi è un computer centrale
(server) che ha il compito di smistare i dati ai vari client
interconnessi. Ciò può avvenire tramite un hub, operando solo a
livello fisico per rigenerare i dati, oppure operando sia a livello
fisico sia a livello data link, tramite uno switch, in grado di
analizzare e filtrare i frame in transito. Fisicamente tale rete
presenta tanti cavi quanti sono i client connessi al server centrale.
Questo collegamento garantisce buona affidabilità; infatti, se si
venisse a creare un’interruzione in un punto qualsiasi del cavo, ciò
non comprometterebbe la caduta della linea nelle altre stazioni. Per
questi motivi esso è utilizzato per il cablaggio delle reti LAN
Ethernet.
Figura 3.1. Tipologia di reti.
pag. 22
3.2 Il wireless
Il termine wireless (dall'inglese senza fili) indica una comunicazione tra
dispositivi elettronici che non fa uso di cavi. I sistemi tradizionali sono invece
detti wired in quanto si basano su connessioni cablate.
Generalmente il wireless utilizza onde radio a bassa potenza; tuttavia comprende
anche i dispositivi, meno diffusi, che sfruttano la radiazione infrarossa o il laser.
La comunicazione e i sistemi wireless trovano diretta applicazione nelle reti
wireless di telecomunicazioni fisse e mobili e in generale nelle
radiocomunicazioni. Esistono diversi gruppi di reti wireless, che si differenziano
tra loro non solo per la velocità di trasmissione dati, ma anche per l'uso per il
quale sono state create:
o PAN wireless: tecnologia ad onde radio che permette la
connessione tra portatili, PDA, cellulari, lettori MP3 e macchine
fotografiche, rendendo semplice la sincronizzazione di dati,
fotografie, musiche ed altri contenuti. Le PAN (Personal Area
Network) hanno un raggio d'azione tipicamente limitato a pochi
metri di distanza. Di questa categoria fa parte il Bluetooth.
o
LAN wireless: applicazione di maggior rilievo che consente la
connettività ad una LAN cablata, utilizzando dispositivi detti punti
d'accesso (o semplicemente AP). Il suo raggio di copertura in
campo aperto arriva fino a 400 metri.
o
MAN wireless: è un campo di applicazione del Broadband
Wireless o Wireless Local Loop che consente la distribuzione di
dati come internet, telefonia, ecc, su un agglomerato urbano.
o
WAN wireless: nella categoria delle Wide Area Network fa parte
il dominio che prevede la diffusione delle applicazioni previste sia
per le reti cablate (LAN) che per le MAN, ma con copertura totale,
anziché localizzata in prossimità dei punti d'accesso. A questa
categoria appartiene per esempio la telefonia GPRS, EDGE,
UMTS.
pag. 23
3.2.1 Caratteristiche tecniche e architettura
La rete Wi-Fi è una rete di telecomunicazioni paragonabile ad una rete a
copertura cellulare a piccola scala (locale); può essere interconnessa con la rete
Internet tramite dispositivi di ricetrasmissione radio quali gli access point (AP)
in sostituzione delle tradizionali stazioni radio base delle reti radiomobili
(modello di architettura client-server).
Dato che la potenza di trasmissione di un access point è limitata da normative di
sicurezza per il rischio elettromagnetico (100mW), per aumentarne il range di
connettività (100m circa) si usano generalmente più access point - e relative
celle di copertura - collegati tra loro tramite cablaggio in rete locale. In tal modo
si può coprire totalmente una determinata area.
La parte radio o interfaccia radio Access Point-Utente costituisce la rete di
accesso, mentre la LAN cablata che collega tutti gli access point è la rete di
trasporto.
Le celle di copertura degli AP sono spesso parzialmente sovrapposte per creare
un'area di copertura totale del segnale detta ESS (Extended Service Set) evitando
buchi di copertura.
La parte cablata è generalmente una rete Ethernet che può essere a bus condiviso
oppure commutata o switchata.
I singoli AP hanno funzionalità di bridge ed hanno il compito di inviare in
broadcast l'SSID che identifica le reti che stanno servendo, alle stazioni
ricetrasmittenti wireless nel loro raggio di copertura.
L'insieme delle stazioni servite dagli AP è detto BSS (Basic Service Set).
La rete totale così ottenuta può essere interallacciata alla rete Internet tramite un
router usufruendo dei servizi di internetworking.
Si possono avere architetture completamente wireless senza alcun access point
(modello di architettura peer-to-peer) con ciascuna stazione base che
riceve/trasmette direttamente da o verso altre stazioni (IBSS Indipendent Basic
Service Set o rete ad-hoc mobile).
Le reti Wi-Fi sono infrastrutture relativamente poco costose e a rapida
attivazione e permettono di realizzare sistemi flessibili per la trasmissione di dati
usando frequenze radio, estendendo o collegando reti esistenti o creandone di
nuove.
pag. 24
3.2.2 Le classi
Esistono varie classi del wireless con prestazioni diverse (come specificato
meglio nei dettagli dello standard IEEE802.11). Le principali sono:
o Classe b a 11 Mb/s; opera a 2,4 GHz.
o Classe g a 54 Mb/s; opera a 2,4 GHz.
o Classe n a 300Mb/s; frequenze operative 2,4/5 GHz (dual band).
Figura 3.2. Rappresentazione grafica dei canali WiFi nella banda di 2.4 GHZ.
Le WLAN a standard IEEE 802.11b e 802.11g dividono la banda totale
(83,5MHz) in 14 canali radio da 22 MHz ciascuno. I canali adiacenti si
sovrappongono, perché le loro frequenze centrali sono separate solamente da 5
MHz. I due gruppi di canali 1, 6, 11 e 2, 7, 12 non si sovrappongono fra loro e
vengono utilizzati negli ambienti con altre reti wireless.
In Europa possono essere impiegati al massimo 13 canali. Gli unici canali
utilizzabili in tutto il mondo sono il 10 e l’11. Le WLAN operano in una banda
radio che non è soggetta a licenza (ISM), quindi chiunque la utilizzi non deve
recare disturbo ad altri e per tale motivo si devono utilizzare particolari tecniche
di trasmissione chiamate Spread Spectrum (spettro espanso).
3.2.3 Tecniche di trasmissione Spread Spectrum
Un po’ di storia
L'espansione di spettro mediante il salto di frequenza (frequency-hopping spread
spectrum) è stata inventata nel giugno 1901 da Nikola Tesla . L'idea gli venne
dopo aver presentato il primo sommergibile al mondo radiocomandato, nel 1898,
quando fu chiaro che i segnali radio che controllavano il battello dovevano
essere sicuri dall'essere “disturbati, intercettati o messi in interferenza in
qualsiasi modo”.
pag. 25
Questa tecnica fu poi brevettata nei primi anni '40 dall’attrice australiana Hedy
Lamarr. Prima di sfuggire al nazismo tedesco, l'attrice si sposò con il mercante
di armi austriaco Fritz Mandl, che le insegnò i segreti per bloccare i segnali radio
per il controllo dei siluri. Lamarr intuì che il controllo remoto radio dei siluri era
un’area fondamentale di ricerca per i venditori d’armi.
Quando scoprì che il marito vendeva armi ad Hitler, fuggì a Hollywood per
proseguire la sua carriera da attrice. Qui, nel tempo libero, inventò la tecnica del
frequency hopping per aiutare gli Alleati: il suo sistema utilizzava 88 frequenze
(corrispondenti al numero dei tasti del pianoforte). Insieme al compositore
George Antheil, ottenne il brevetto per la sua invenzione, ma non venne presa in
considerazione dalle forze armate statunitensi.
Le tecniche a salto di frequenza furono usate per la prima volta dalle navi
americane durante la Crisi missilistica cubana.
Ci vollero anni perché la tecnologia spread spectrum diventasse
commercialmente disponibile.
Al giorno d’oggi, le tecnologie spread spectrum sono utilizzate nei telefoni
mobili, nelle LAN wireless a banda larga e nei dispositivi su bande ISM senza
licenza. Hedy Lamarr morì nei primi anni 2000, quando il mercato LAN
wireless stava iniziando ad espandersi.
3.2.3.1 Descrizione
Con il termine Spread Spectrum si indica una tecnica di trasmissione digitale
che distribuisce lo spettro in potenza di un segnale contenente informazione su
una banda molto più larga rispetto a quella del segnale originario (R), in modo
tale che la potenza per unità di frequenza (Watt per Hz) del segnale inviato sul
canale sia molto piccola, paragonabile a quella del rumore bianco. In ricezione
si esegue il processo inverso, ovvero quello di despreading, moltiplicando il
segnale in ricezione per uno di despreading analogo a quello usato in
trasmissione; quindi il segnale in questione viene riportato nella sua originaria
banda stretta.
Lo scopo principale è migliorare il rapporto segnale/rumore eliminando il
maggior numero di interferenze in modo da consentire l'utilizzo contemporaneo
della stessa gamma di frequenze a più utenti; altro scopo è quello di
mimetizzare il segnale radio trasmesso abbassandone la potenza specifica e
portandolo come già detto a confondersi con il rumore radio di fondo, in modo
da sfuggire al rilevamento da parte delle stazioni di intercettazione radio.
pag. 26
Figura 3.3. Spread Spectrum e soppressione delle interferenze.
Principalmente si adottano due metodi per ottenere uno spettro diffuso: il
frequency hopping e il direct sequence.
3.2.3.2 Frequency hopping
Questo metodo lavora modulando il segnale su una portante che si sposta
“saltellando” di frequenza in frequenza più volte nel tempo, su di un’ampia
porzione di banda, secondo un ben definito pattern (hopping pattern).
Questa tecnica di modulazione ha il pregio di ridurre le interferenze poiché un
segnale interferente proveniente da un sistema a banda stretta causerà problemi
solo nel caso in cui stia avvenendo una trasmissione proprio a quella frequenza
ed in quel preciso momento. Caso tutto sommato relativamente poco frequente,
cosicché il sistema di modulazione risulta poco affetto da errori.
pag. 27
Figura 3.4. Andamento temporale di FSSS.
3.2.3.3 Direct sequence
Questa tecnica di modulazione, come la precedente, ha come scopo la diffusione
dello spettro del segnale. Lo scopo viene qui raggiunto combinando il segnale da
trasmettere con un segnale con un più alto bit rate, chiamato chipping code.
Il chipping code è composto da una serie di bit, chiamati chip, la cui
combinazione col segnale permette di ottenere il risultato desiderato, cioè uno
spettro diffuso.
Il meccanismo è abbastanza semplice: viene inizialmente assegnato un chipping
code per rappresentare rispettivamente lo zero e l’uno e quando si trasmette il
segnale in realtà viene inviato il codice corrispondente. Se per esempio
assegniamo allo ZERO il codice 11101011001 ed all’UNO il codice
00010100110,
la
trasmissione
della
sequenza
011
diviene
111010110010001010011000010100110; in questo modo il metodo DSSS per
ogni bit da spedire non fa altro che inviare una stringa di bit, corrispondente al
chipping code. Tipicamente il numero di chip varia tra 10 e 20; inoltre, tanto più
è elevato il loro numero nel chipping code, tanto più aumenta la resistenza del
segnale alle interferenze.
pag. 28
Capitolo 4
Progettazione e realizzazione del prototipo
4.1 Caratteristiche per gli utenti finali
Gli utenti che si interfacceranno e usufruiranno del sistema in esame
interagiranno con esso sfruttandone le funzionalità in base al ruolo ricoperto
nell'azienda. Nella progettazione si sono tenuti in considerazione le esigenze del
magazziniere e del responsabile azienda.
o Il magazziniere gestisce fisicamente la logistica del magazzino,
caricando e scaricando i prodotti. Sarà equipaggiato con un dispositivo
portatile per la lettura dei codici a barre, in modo da poter reperire le
informazioni desiderate in modo semplice. Il suo compito sarà di passare
in successione i prodotti in giacenza allo scopo di inventariarli: leggendo
il codice a barre ed introducendo sulla tastiera la quantità del prodotto.
o Il responsabile azienda come coordinatore dei diversi reparti ha anche la
responsabilità dell'operato svolto dai magazzinieri. Dovrà quindi avere a
disposizione strumenti necessari per il reperimento delle informazioni
riguardanti le giacenze in magazzino e per analizzare i dati riguardanti
l'andamento aziendale.
4.2 Funzioni principali del sistema
L'idea di base su cui si fonda il progetto è quello di sviluppare un dispositivo
portatile in grado di effettuare la lettura dei codici a barre che, con un apposito
software, sia in grado di gestire opportunamente i dati raccolti.
Originariamente il dispositivo doveva poter effettuare la lettura del codice a
barre e comunicare l'informazione ad un database esterno. Si è successivamente
preferito integrare il database nel dispositivo stesso e di lasciare la possibilità di
farlo comunicare con l'esterno come funzione opzionale. Questo gli consente di
non dipendere dalla connessione o dai cavi di rete per poter funzionare e ciò lo
rende realmente "portatile". Tale database sarà poi consultabile sia da un display
LCD integrato nel dispositivo che da una interfaccia web disponibile dopo
averlo connesso in rete.
pag. 29
Il dispositivo deve poter soddisfare efficacemente i seguenti compiti:
o Verifica degli articoli: si vuole dare la possibilità di interrogare il
database ricavandone così informazioni per effettuare molteplici
operazioni quali controlli da parte del magazziniere circa articoli
prelevati o riferiti ad un determinato ordine di spedizione, controlli degli
articoli in entrata ed in uscita dal magazzino, controlli giacenze da parte
del responsabile dell'azienda e controlli riguardanti lo stato dei diversi
articoli.
o Movimentazione merci: il sistema individua l'ingresso e l'uscita delle
merci durante la lettura del codice a barre effettuato da un
operatore/magazziniere. Tali informazioni saranno poi aggiunte o
andranno ad aggiornare l'inventario che verrà immediatamente reso
disponibile per la consultazione.
4.3
Caratteristiche dell'hardware
Nella progettazione dello schema circuitale del prototipo si è tenuto in
considerazione principalmente di tre proprietà caratterizzanti:
o Mobilità: è la prerogativa più importante tra quelle individuate. Essa si
riflette sulla necessità di dotare il dispositivo di una batteria per
l'alimentazione. Rimuovendo ogni vincolo legato alla staticità della
posizione si ottiene così una libertà assoluta rispetto alla dimensione
spaziale, rendendolo così utilizzabile ovunque.
o Modularità: lo schema del circuito di implementazione del dispositivo è
stato pensato prevedendo di realizzare un'espansione di una piattaforma
preesistente, così da consentire lo sviluppo di nuove funzionalità
attraverso l'aggiunta di moduli supplementari che, connettendosi a quello
base, permettono di sfruttare le proprietà di cui è portatrice. Ciò ha avuto
un impatto anche a livello economico non facendo lievitare
eccessivamente i costi e riducendo notevolmente la complessità del
lavoro.
o Flessibilità: il fatto che sia possibile utilizzarlo ovunque e di ampliarne le
funzionalità con moduli aggiuntivi lo rende flessibile. Questo comporta
che nella prospettiva di uno sviluppo futuro sarà possibile fornire nuovi
contributi al progetto.
L'hardware presentato è l'insieme dei componenti utilizzati nella realizzazione
del dispositivo e provvede a soddisfare le esigenze sopraelencate.
pag. 30
4.4
Componenti
Il processo di individuazione e selezione dei componenti da assemblare per
comporre il prototipo è stato influenzato dalla ricerca di particolari elementi
qualitativamente idonei e al contempo in grado di mantenere bassi i costi.
La soluzione prevista per questo progetto consiste nella realizzazione di uno
shield per Arduino YUN. Arduino ha una struttura modulare: sono infatti
disponibili in commercio numerose schede che integrano hardware per svariati
utilizzi ed è possibile collegarli semplicemente impilandoli l'uno all'altro. Nel
nostro caso non esisteva uno shield adatto alle nostre specifiche esigenze ed è
stato necessario realizzarne uno per implementare una interfaccia adatta a
connettere un lettore di codici a barre, un tastierino numerico e un display LCD.
Il prototipo deve inoltre essere equipaggiato con una batteria da 9V per
l'alimentazione esterna.
Figura 4.1. Blocchi fondamentali del sistema
pag. 31
4.4.1 Arduino
4.4.1.1
Introduzione alla scheda
Arduino è una scheda elettronica open source di dimensioni ridotte che fornisce
all'utente finale una piattaforma hardware e software per l'implementazione
semplificata dei prototipi. Il concetto open fa sì che le schede vengano
costantemente migliorate dalla grande comunità di sviluppatori che seguono il
progetto. Il basso costo è sicuramente uno dei fattori che ha reso questa scheda
un progetto di successo così come la ricca documentazione disponibile e la
facilità d'uso che l'ha resa accessibile a tutti.
Figura 4.2. Visione dall'alto delle schede Arduino UNO e Arduino YUN
Ad oggi sono disponibili 25 diversi modelli di schede elettroniche ufficiali e
riconosciute dal team Arduino, adattati per ogni esigenza. Quelle standard sono
Arduino UNO e Arduino YUN. Quest'ultima rappresenta il top della gamma.
Tutte queste schede condividono alcune specifiche comuni. Il cuore di tutte le
schede è un microcontrollore della ATMEL, di cui può variare il modello in
funzione della scheda utilizzata. Arduino può gestire segnali da molteplici
sensori e gestire attuatori di vario genere tramite ingressi e uscite digitali e
analogiche.
Figura 4.3. Interazione con il mondo reale
pag. 32
Arduino viene fornito di un semplice ambiente di sviluppo comune a tutte le
schede che consiste in un IDE cross platform, cioè disponibile in tutti i sistemi
operativi più diffusi e che rende facilmente programmabile il microcontrollore.
Infatti se prima dell'avvento di Arduino programmare un microcontrollore
significava scrivere codice Assembly o C, ora grazie al linguaggio di
programmazione utilizzato nell'IDE di Arduino, Wiring, un linguaggio simil-C,
anche chi non ha una conoscenza dell'elettronica avanzata può programmare un
microcontrollore. I programmi di Arduino sono chiamati sketch. Grazie ad essi
la scrittura dei comandi per le operazioni di input/output sono enormemente
semplificate.
4.4.1.2
Caratteristiche tecniche di Arduino YUN
In questa applicazione è stato scelto Arduino YUN. Il microcontrollore di cui è
dotato è l'ATmega32u4. Esso possiede 32Kb di memoria flash dove caricare il
programma (di cui 4Kb già utilizzati per il bootloader), 2.5Kb di SRAM
utilizzata per le variabili e 1Kb di EEPROM per salvare dati e parametri di
configurazioni utili per il nostro programma in modo permanente.
Arduino YUN si distingue dagli altri modelli perché può comunicare con la
distribuzione Linux basata su OpenWRT chiamata Linino, in grado di assicurare
tempi di startup rapidi, installata sul processore dell'Atheros AR9331 e offre
così un potente computer connesso con il microcontrollore di Arduino in grado
di fornire un web server e un database SQL dove immagazzinare i dati. È inoltre
completo di Ethernet, Wi-Fi, slot MicroSD e 20 pin I/O disponibili.
Figura 4.4. Disposizione dei componenti dell'Arduino YUN.
pag. 33
Caratteristiche tecniche del microcontrollore AVR Arduino
Microcontroller
ATmega32u4
Operating Voltage
5V
Input Voltage
5V
Digital I/O Pins
20
PWM Channels
7
Analog Input Channels
12
DC Current per I/O Pin
40 mA
DC Current for 3.3V Pin
50 mA
Flash Memory
32 Kb
SRAM
2.5 Kb
EEPROM
1 Kb
Clock Speed
16 MHz
Caratteristiche tecniche del microprocessore Linux
Processor
Atheros AR9331
Architecture
MIPS @400MHz
Operating Voltage
3.3V
Ethernet
IEEE 802.3 10/100/Mbit/s
Wi-Fi
IEEE 802.11b/g/n
USB Type-A
2.0 Host/Device
Card Reader
Micro-Sd only
RAM
64 MB DDR2
Flash Memory
16MB
PoE compatible 802.3af card
support
pag. 34
4.4.1.3
Alimentazione
Arduino YUN può essere alimentato con 5V da un connettore micro-USB o da
un'alimentazione esterna che può essere fornita da una batteria al pin Vin.
La scheda non dispone di un regolatore di tensione, per cui tensioni più alte
potrebbero danneggiarla.
4.4.1.4
Input e Output
I principali pin del microcontrollore sono disposti attraverso connettori posti ai
bordi della scheda. Si dispone in totale di 20 pin input/output digitali, di cui 7
possono essere utilizzati come output PWM e 12 come input analogici.
Ciascuno di questi pin può essere pilotato in maniera indipendente dal software.
La tensione di uscita di ogni output è di 5V ed è in grado di lavorare al massimo
con 40mA. Ogni pin ha inoltre la possibilità di abilitare internamente resistenze
di pull-up di 20/50kOhms (disconnesse di default).
Alcuni di questi pin hanno comportamenti specifici:
o I pin 0 (Rx) e 1 (Tx) possono essere utilizzati per la comunicazione
seriale.
o I pin 0, 1, 2, 3 e 7 possono essere configurati come trigger per eventi
esterni, come ad esempio il rilevamento di un fronte di salita o di discesa
di un segnale di ingresso.
o I pin 3, 5, 6, 9, 10, 11 e 13 possono essere configurati per generare
segnali PWM con risoluzione di 8 bit. Tramite un filtro RC è possibile
ottenere tensioni continue di valore variabile.
o Il pin 13 è connesso a un LED interno alla scheda, risulta utile in
situazioni di debug.
o I pin A0-A5 e A6-A11 (sui pin digitali 4, 6, 8, 9, 10 e 12) sono gli
ingressi analogici. Ognuno di questi pin possono essere utilizzati come
I/O digitali. Ogni ingresso analogico fornisce 10 bit di risoluzione (cioè
1024 valori differenti). Di default gli ingressi analogici hanno un range
che va da massa a 5V, anche se è possibile cambiare l'estremità superiore
con il pin AREF.
Non è possibile per l'Atheros AR9331 accedere direttamente ai pin I/O: tutte le
linee sono collegate al microcontrollore.
pag. 35
4.4.1.5
Bridge
Arduino YUN integra il microcontrollore ATmega32u4 e l'Atheros AR9331 in
cui "gira" Lenino, una distribuzione di Linux. Il "Bridge" è una libreria che
mette in comunicazione questi due componenti.
Figura 4.5. Comunicazione tra ATmega32U4 e Atheros AR9331.
Dalla figura 4.5 si nota come la microSD, l'interfaccia Wi-Fi e Ethernet non
siano direttamente connesse al microcontrollore; quest'ultimo non ha
direttamente accesso se non tramite il microprocessore. Il Bridge consente
quindi ad Arduino di interfacciarsi con queste periferiche.
pag. 36
4.4.2
Scanner di codici a barre
È stato scelto di utilizzare un lettore CCD, Charge-Coupled Device, della
Manhattan® (visibile in figura 4.6.) con connettore PS2 e modalità di
funzionamento ad emulazione di tastiera, visualizza cioè i dati come se fossero
inseriti da tastiera. Il lettore è leggero ed ergonomico. La lettura del codice
avviene con il semplice contatto tra l'ottica del lettore ed il codice a barre stesso.
Supporta le codifiche più popolari e la tensione di alimentazione è compatibile
con le caratteristiche elettriche di Arduino (5V) con un consumo elettrico pari a
130mA.
Figura 4.6. Lettore scanner codici a barre CCD - Manhattan®
4.4.2.1
Il protocollo PS2
Il PS2 è un protocollo seriale, sincrono e bidirezionale utilizzato al giorno d'oggi
per far comunicare tastiere e mouse con il computer.
Il lettore scelto per leggere i codici a barre ha in dotazione un connettore PS2
come quello presente in figura 4.7.
Figura 4.7. Porta PS2 a 6-pin Mini-DIN
pag. 37
Per semplicità nella trattazione si farà riferimento alla tastiera e ai suoi tasti per
indicare il "device" utilizzato, chiarendo che il funzionamento è analogo sia per
i mouse e, come nel caso in questione, sia al lettore di codici a barre. Inoltre ci si
riferirà ad Arduino con il termine più generale "host".
Tutta la comunicazione si basa su un bus formato da due linee bidirezionali: la
linea di clock e la linea dati. L'host ha sempre il controllo finale sul bus e può in
ogni momento inibire la comunicazione ponendo la linea di clock ad uno stato
logico basso.
Solo alla tastiera spetta il compito di generare il clock. I dati spediti dalla tastiera
sono letti dall'host sul fronte di discesa del clock, al contrario quelli trasmessi
dall'host alla tastiera sono letti sul fronte di salita. La frequenza del clock può
variare dai 10KHz ai 16.7KHz. Se assumiamo quindi il clock come un'onda
quadra e si calcola il periodo della stessa, ci si rende conto che il clock deve
rimanere alto per almeno 30 ÷ 50 μs.
Questi parametri sono cruciali per evitare conflitti nella trasmissione dati tra
l'host e la tastiera.
o
Modalità della comunicazione dati dall'host alla tastiera: quando l'host
vuole trasmettere dei dati deve innanzitutto inibire la comunicazione
mettendo a massa il clock per almeno 100 μs, quindi mettere a massa
anche la linea dati e rilasciare il clock. Questa sequenza fa capire alla
tastiera che sono in arrivo dei dati, e quest'ultima inizia a generare il
clock. Tutti i dati sono trasmessi in modo seriale un byte alla volta. Ogni
byte viene inserito in un frame di undici bit: uno di start (sempre posto a
0), otto bit di dati (ordinati dal meno significativo al più significativo),
un bit di parità e un bit di stop (sempre posto a 1).
Figura 4.8. Frame di undici bit dall'host alla tastiera.
Alla fine di questo frame l'host si aspetta un acknowledge bit da parte
della tastiera per verificare che il dato sia stato correttamente ricevuto da
quest'ultima, e quindi rilascia la linea dati. Se l'host non la rilascia dopo
l'undicesimo ciclo di clock la tastiera capisce che c'è stato un errore nella
comunicazione e continua a generare il clock finché la linea dati non
pag. 38
viene rilasciata dall'host.
o
Modalità della comunicazione dalla tastiera all'host: quando la tastiera
vuole inviare un dato, come prima cosa controlla lo stato della linea di
clock per verificare che sia in uno stato logico alto. Se non lo è significa
che l'host sta inibendo la comunicazione e la tastiera deve quindi
bufferizzare i dati da spedire finché la linea di clock non viene rilasciata
per almeno 50 μs, passati i quali può procedere all'invio. Per trasmettere
i dati la tastiera usa lo stesso formato di undici bit.
Figura 4.9. Frame di undici bit dalla tastiera all'host.
I codici inviati dalla tastiera vengono detti "scan codes" e indicano qual è tasto
che l'utente ha premuto, rilasciato o tenuto premuto. Quando si preme un tasto
viene generato un codice chiamato "make code", mentre quando il tasto viene
rilasciato viene generato un "break code". La tastiera supporta inoltre una
funzionalità di ripetizione tasti detta typematic con un delay pre-ripetizioni e una
velocità di ripetizione configurabili.
Il make code è composto da un byte con il codice del tasto che rappresenta,
mentre il break code è lo stesso byte preceduto però da un altro byte di valore
0xF0. Ad ogni tasto viene associato un'unica coppia make code e break code, in
modo che l'host può determinare esattamente cos'é successo e a quale tasto.
Bisogna inoltre avere presente che i codici inviati identificano i tasti della
tastiera e non i caratteri che essi rappresentano. Sarà quindi compito dell'host
tradurre gli scan code ricevuti in codici ASCII.
pag. 39
4.4.3 Tastiera
Il tastierino è una periferica di input, ed in questo progetto viene utilizzato per
introdurre dati numerici nel sistema. Per tali ragioni è stato scelto un tastierino a
matrice a 12 pulsanti, 4 righe e 3 colonne, che rappresenta i numeri da 0 a 9, più
due pulsanti utili all'utente per poter tornare indietro o confermare l'operazione
intrapresa.
Figura 4.10. Tastiera numerica 4x3
4.4.3.1
Tastiera a matrice
Nella configurazione a matrice si dispongono i tasti secondo N righe e M
colonne, in modo che la pressione di un tasto metta in comunicazione la relativa
riga con la corrispondente colonna.
Figura 4.11. Collegamenti interni di una tastiera a matrice.
pag. 40
Esistono vari sistemi per la lettura di una tastiera a matrice. Il più comune
consiste nell'inviare ciclicamente un particolare livello logico ad una colonna
per volta e controllare successivamente se lo stesso livello si presenta in una
delle righe. Quando una riga presenta quel livello logico, e sapendo qual è
l'unica colonna attiva in quel momento, si può dedurre quale tasto è stato
premuto. Questa continua operazione di lettura e verifica dei tasti prende il
nome di Scanning. Il principale vantaggio di questa tecnica consiste
nell'adoperare N + M linee di I/O per poter acquisire N x M tasti.
Nel caso particolare della tastiera a matrice presente in figura 4.11 i 12 pulsanti
possono essere gestiti con 7 linee di I/O.
4.4.4 Display LCD
Un'altra modalità per la visualizzazione dei dati è quella che dà l'opportunità a
qualsiasi utente di leggere le informazioni riguardo un prodotto direttamente dal
dispositivo. Esso è quindi dotato di un piccolo schermo a cristalli liquidi (LCD).
Figura 4.12. Display LCD 2x16.
4.4.5 Batteria da 9V
Il requisito minimo stabilito era di dotare il dispositivo di un'autonomia di
almeno un'ora. Per l'alimentazione esterna della scheda Arduino e dei circuiti
logici aggiuntivi è stata quindi scelta una batteria ricaricabile da 9V in grado di
erogare 500mAh. Arduino YUN con Wi-Fi abilitato consuma all'incirca 250mA;
l'LCD tra i 120mA e i 160mA; 130mA lo scanner. Si arriva così ad una media di
500mA, variabili a seconda dell'utilizzo più o meno frequente dello scanner.
Figura 4.13. Batteria da 9V ricaricabile.
pag. 41
4.5
Progettazione dello schema elettrico
4.5.1 Circuito di alimentazione
Uno dei principali aspetti da tenere in considerazione era di fornire ad Arduino
YUN un'alimentazione stabilizzata a 5V. Una soluzione economica per ottenere
un'alimentazione di qualità è stato l'impiego di un regolatore di tensione tipo
LM7805.
Figura 4.14. Stabilizzatore di tensione.
pag. 42
4.5.2 Connessione con l'LCD
L'LCD scelto è dotato di 16 pin e ha una interfaccia parallela, il che significa
che il microcontrollore deve gestire diversi pin contemporaneamente per
controllare il display. La tabella di figura 4.15 illustra le funzioni di ogni
piedino.
Figura 4.15. Funzioni dei singoli pin dell'LCD.
Si può notare come il numero di linee di controllo necessarie a pilotare il display
sia elevato. Per cui abbiamo scelto di utilizzare la modalità a 4 bit per ridurre il
totale di uscite digitali necessarie a sei (quattro per la trasmissione dati, più due
linee di controllo). La tipologia dei collegamenti è illustrata in figura 4.16.
pag. 43
Figura 4.16. Tipologia di collegamenti tra il display LCD e Arduino.
4.5.3 Tastiera analogica
Mentre si era partiti dall'idea di decodificare i tasti del tastierino a matrice
utilizzando il sistema di scanning illustrato nel capitolo 4.4.3.1, si è
successivamente preferito il controllo analogico.
Con questo sistema si utilizza un solo ingresso per decodificare i dodici tasti, a
differenza delle sette linee inizialmente previste. Il controllo è completamente
analogico e fa uso del convertitore A/D a 10 bit presente in Arduino.
Ogni pulsante del tastierino è collegato ad una diversa resistenza, di
conseguenza alla pressione di un tasto corrisponde un valore di tensione
caratteristico e ben distinto da quella degli altri tasti; questo permette di
identificarli univocamente. Il riconoscimento di ogni tasto viene fatto quindi in
base al livello di tensione convertito dal modulo A/D.
Il circuito con i valori delle resistenze scelte per questo progetto è presente in
figura 4.17.
pag. 44
Figura 4.17. Rete resistiva per un tastierino 4x3.
La massima tensione assunta è pari a 5V, ed essendo il convertitore a 10 bit la
conversione avviene mediante “quanti” di valore pari a:
Si è quindi proceduto a calcolare le tensioni teoriche e i valori in digitale ad essi
corrispondenti per verificare che tali valori siano il più possibile equidistanti tra
loro, consentendo una identificazione univoca. La tabella con i valori calcolati è
presente in figura 4.18.
pag. 45
Figura 4.18. Tabella con i valori di tensione corrispondenti a ogni tasto.
4.5.4 Trigger per il tastierino
L'operazione di conversione A/D di Arduino per poter decodificare un tasto è
particolarmente onerosa. Occorrono all'incirca 100μs per completare la lettura, e
il più delle volte solo per notificare l'assenza di tasti premuti.
Si è reso quindi quasi obbligatorio generare un evento per avvisare il
microcontrollore della pressione di un tasto, per poi solo in quell'occasione
effettuare la lettura del pin analogico per poterlo identificare dagli altri.
Dalla tabella di figura 4.18 si può constatare come il più piccolo valore di
tensione ottenibile dalla pressione di un pulsante sia di 248mV. Tenendo quindi
conto delle tolleranze delle resistenze, si è stabilito un valore di circa 150mV per
cui si considera premuto un qualsiasi tasto. Si utilizzerà quindi l'uscita di un
comparatore con questa tensione di riferimento per attivare un interrupt,
permettendo così ad Arduino di non dover convertire ripetutamente un canale
analogico anche in assenza di tasti premuti.
Il comparatore scelto in questa applicazione è l'LM311, un integrato molto
versabile che fornisce ottime prestazioni per quanto riguarda la precisione della
risposta. Può essere alimentato con 5V a singola alimentazione, e questo ha
consentito una notevole semplificazione dei circuiti di alimentazione.
pag. 46
Figura 4.19. Comparatore LM311.
4.5.5 Interfacciamento con connettore PS2
Per la comunicazione con la porta PS2 del lettore e Arduino è stato utilizzato un
adattatore seriale a 9 pin (DB9) come quello presente in figura 4.20.
Figura 4.20. Adattatore seriale DB9/PS2.
Figura 4.21. Pinout adattatore per PS2 a seriale DB9.
pag. 47
4.6
Realizzazione pratica della scheda elettrica
4.6.1 Design
L'orientamento seguito durante la fase di sbrogliatura del circuito è stato
fortemente influenzato dall'idea di realizzare un dispositivo dalla forma
compatta, maneggevole e funzionale. La disposizione dei componenti doveva
poter dare risalto all'LCD e avere un accesso ottimale per la digitazione sulla
tastiera. A partire da queste motivazioni si è giunti all'idea di realizzare quanto
presente in figura 4.22 e 4.23.
Figura 4.22. Prospettiva laterale
Figura 4.23. Prospettiva frontale
pag. 48
4.6.2 Costruzione del PCB
Il PCB, Printed Circuit Board, o Circuito Stampato, consiste in un insieme di
elementi elettronici ed elettrici collegati opportunamente tramite delle piste
conduttive. Un'opportuna foratura della basetta consente di inserire i reofori dei
componenti, fissandoli tramite saldature alle piste ed assicurando così un buon
aggancio e garantirne la stabilità meccanica. I componenti sono disposti solo su
una faccia della basetta, chiamato generalmente lato componenti, mentre l'altro
lato viene chiamato lato saldature.
Il disegno del circuito è stato fatto su computer usando il software Orcad.
Tramite esso è stato rappresentato lo schema elettrico del circuito dal punto di
vista funzionale. Gli schemi elettrici sono stati poi sbrogliati curando la
disposizione dei componenti secondo il design visto nel capitolo 4.6.1 e stampati
su fogli acetati trasparenti.
Lo shield è stato realizzato fisicamente su una basetta ramata a doppia faccia,
utilizzando un processo fotografico con bromografo a LED ultra-violetti.
Successivamente è stato necessario asportare il rame dalla superficie della
scheda, utilizzando l'acido cloruro ferrico. Il risultato è di queste operazioni è
presente in figura 4.24
Figura 4.24. Circuito stampato del prototipo.
pag. 49
4.7
Sviluppo del software
4.7.1 Casi d'uso
Per poter sviluppare un software di qualità che rispecchi le esigenze dell'utente
finale è necessario raccogliere i requisiti funzionali che si vogliono raggiungere
in maniera completa e non ambigua. Ciò viene fatto attraverso i casi d'uso.
Figura 4.25. Diagramma dei casi d'uso.
o Scarico merci: il magazziniere preleva i prodotti dal magazzino per
poterli poi spedire, vendere o utilizzare. Per effettuare questa operazione
legge il codice a barre del prodotto in questione e tramite tastiera digita
la quantità in uscita.
o Carico merci: il magazziniere provvede a ricevere e prelevare gli articoli
consegnati dal fornitore. Prima di mettere la merce in giacenza effettua
la lettura del codice a barre dei singoli prodotti e tramite l'aiuto della
tastiera ne specifica la quantità.
o Identificazione prodotto: tramite la lettura del codice a barre di un
articolo in magazzino l'operatore ottiene le informazioni ad esso
associate, come il nome e la quantità di prodotto in giacenza.
o Analisi di mercato: il responsabile dell'azienda usa i dati riguardanti i
prodotti in giacenza e la lista di movimenti dei prodotti per analizzare
l'andamento aziendale.
pag. 50
4.7.1.1
Identificazione merci
Figura 4.26. Diagramma di flusso delle operazioni di identificazione del prodotto.
4.7.1.2
Carico merci
Figura 4.27. Diagramma di flusso delle operazioni di carico merci.
pag. 51
4.7.1.3
Scarico merci
Figura 4.28. Diagramma di flusso delle operazioni di scarico merci.
4.7.2 Database
4.7.2.1
Cos'é un database
Un database può essere definito come un insieme di dati strettamente correlati,
memorizzati su un supporto di memoria di massa, che possono essere manipolati
dall'applicazione. È quindi una sorta di versione informatica di un archivio, un
luogo dedicato all'organizzazione e alla consultazione delle informazioni.
Per usare le informazioni contenute in un database occorre l'utilizzo di un
Database Management System (DBMS). Si tratta di una serie di programmi
software che consentono di immettere, selezionare e organizzare le informazioni
nel database. Esistono diverse modalità tramite le quali un DBMS può
implementare queste funzionalità, ma negli anni la tipologia che è risultata di
gran lunga più popolare è quella che si basa sul modello dati relazionale.
pag. 52
4.7.2.2
Scelta del tipo di database
Il primo importante passo per la realizzazione del sistema è stato quello di
scegliere l'RDBMS (Relational Database Management System) adatto al
compito che avrebbe dovuto svolgere. Si è quindi proceduto a stilare le
caratteristiche essenziali che il database avrebbe dovuto possedere.
o Leggerezza: requisito fondamentale poiché l'ambiente su cui viene fatto
girare ha risorse e spazio limitato.
o Buone performance: nel contesto in cui il database viene adoperato le
tabelle possono assumere dimensioni importanti. Deve quindi essere in
grado di rispondere alle query in tempi ragionevoli.
o Funzionalità SQL: si richiede al database di poter gestire della business
logic di elevata complessità. È quindi importante che disponga di un
ampio set di istruzioni SQL.
o Buona documentazione: essenziale per poter rispettare i termini di tempo
imposti per lo sviluppo.
Delineati i requisiti sopraelencati si è proceduto ad un'analisi comparativa delle
funzioni e delle performance di tre database relazionali: MySQL, PostgreSQL e
SQLite. Nonostante le prestazioni elevante, la possibilità di inserire grandi
quantità di dati e il disporre di una abbondante documentazione, abbiamo infine
escluso l'utilizzo di MySQL e PostgreSQL. Si è ritenuto che non fossero una
soluzione mirata alle esigenze del prototipo, in quanto le tante funzionalità
evolute che entrambi possiedono, come la gestione degli utenti, il sistema di
autenticazione e la gestione granulare dei permessi di accesso alle tabelle,
sarebbero state superflue e non richieste. Benché più limitato funzionalmente, la
scelta è quindi ricaduta su SQLite.
4.7.2.3
SQLite
SQLite è una semplicemente libreria OpenSource scritta in linguaggio C che
richiede solo pochi Kb per poter funzionare. Essa fornisce un database
relazionale sviluppato con lo scopo di fornire un sistema comodo di gestione
dati senza l'introduzione di risorse accessorie aggiuntive introdotte dai classici
DBMS. È famoso per la sua alta portabilità, la compattezza e la facilità d'uso. Il
sistema è il più performante fra tutti e poiché l’applicativo richiede frequenti
operazioni di SELECT, INSERT e UPDATE, ciò ha garantito efficienza e
affidabilità superiori alle altre soluzioni. La compattezza di SQLite permette una
pag. 53
installazione semplice e leggera, che viene integrata direttamente
nell'applicazione che ne fa uso, e adatta quindi al nostro ambiente di lavoro. Un
ulteriore vantaggio della sua adozione riguarda la sua struttura dati costituita da
un file di formato fisso e identico per tutte le piattaforme. Ciò consente al
database di poter essere spostato tra sistemi diversi con una semplice operazione
di copia.
4.7.2.4
Tabelle SQL e Query
L'obbiettivo era implementare una tabella che consentisse la visualizzazione di
una lista di prodotti e che nel contempo fosse in grado di operare efficacemente
la modifiche della quantità in giacenza dei prodotti stessi. Il parametro passato
dall'utente per poter identificare il prodotto è un codice a barre numerico. Da
queste considerazioni iniziali si è definita una tabella denominata "items", con i
seguenti campi:
o item_gtin (INT, NOT NULL, PRIMARY KEY)
o item_name (TEXT, NULL)
o item_quant (INT, NOT NULL, DEFAULT 0)
item_gtin è il campo destinato al codice a barre (definita come chiave primaria),
item_name è per il nome opzionale del prodotto e item_quant indica la quantità
in giacenza. Con una sola tabella tutte le operazioni per la selezione ed
estrazione dei dati sono immediate:
SELECT * FROM items WHERE item_gtin = '123';
così come l'inserimento e la modifica dei dati:
INSERT INTO items (item_gtin) VALUES ('123');
UPDATE items SET item_quant = item_quant + 2 WHERE item_gtin =
'123';
Tuttavia questa soluzione non ci ha soddisfatto particolarmente. L'intento era di
dare all'utente la possibilità di visualizzare tutte le operazioni legate alla
modifica delle quantità dei prodotti con un alto livello di granularità dei dati. È
stato quindi necessario spostare il dato relativo alla quantità dalla tabella items
in una nuova tabella. La tabella items è stata perciò ristrutturata in questo modo:
o item_id (INT, NOT NULL, PRIMARY KEY, AUTO_INCREMENT)
o item_gtin (INT, NOT NULL, UNIQUE KEY)
o item_name (TEXT, NULL)
pag. 54
Ed è stata creata una nuova tabella chiamata "stocks" per contenere le
movimentazioni dei prodotti e garantire così un alto livello di dettagli sulle
operazioni di carico e scarico merci. I campi scelti sono i seguenti:
o
o
o
o
o
stock_id (INT, NOT NULL, PRIMARY KEY, AUTO_INCREMENT)
stock_item_id (INT, NOT NULL)
stock_quant_in (INT, NOT NULL, DEFAULT 0)
stock_quant_out (INT, NOT NULL, DEFAULT 0)
stock_date (DATETIME, NOT NULL, DEFAULT CURRENT_TIME)
Il campo item_quant viene quindi sostituito da stock_quant_in e
stock_quant_out, due campi che specificano le quantità in entrata e in uscita dei
singoli movimenti, stavolta datati. Le due tabelle vengono associate con
stock_item_id come chiave esterna della chiave primaria dell'altra tabella, così
da vincolare la lista dei movimenti dei prodotti con i dati dei prodotti stessi.
Infine si sono aggiungi altri campi aggiuntivi e una tabella chiamata "category"
per poter ordinare i prodotti in categorie. Il risultato finale di questo lavoro è
presente in figura 4.29.
Figura 4.29. Schema del database.
pag. 55
L'architettura finale delle tabelle ha avuto come conseguenza un notevole
aumento di complessità nelle operazioni di recupero dati.
Ad esempio la query per recuperare i dati relativi ad un prodotto con la quantità
residua in magazzino è diventata:
SELECT
i.*,(SUM(s.stock_quant_in)-SUM(s.stock_quant_out))
stock
FROM items i
LEFT JOIN stocks s
ON i.item_id = s.stock_item_id
WHERE i.item_gtin = '123'
GROUP BY i.item_id;
AS
Ma con questa configurazione è divenuto possibile recuperare tutti i singoli
movimenti, rendendo l'estrazione dei dati una operazione molto più selettiva e
flessibile.
4.7.3 Architettura del web server
Il web server funge da intermediario tra l'utente e il database. Il suo compito è
quello di prelevare i dati, elaborarli e presentarli all'utente.
Arduino YUN ci è stato fornito con una versione pre-installata del web-server
uHTTPd, e poiché non ha avuto bisogno di configurazione ulteriore per poter
funzionare abbiamo optato per tenerlo come rimpiazzo del più comune Apache.
La scelta delle tecnologie da impiegare per la realizzazione del sito web è stata
fatta in accordo a esperienze pregresse avute con il linguaggio di
programmazione PHP, adatto a sviluppare robuste applicazioni web lato server.
Si è dunque proceduto a installare i pacchetti software aggiuntivi e le
dipendenze necessarie, scegliendo di includere anche il modulo CLI che
consente di lanciare script PHP da linea di comando e che ha permesso ad
Arduino, tramite il Bridge, di comunicare con il database stesso.
pag. 56
4.7.3.1
Interfaccia web
Nella realizzazione del sito web si è prestato attenzione al design dell'interfaccia
d'utente il quale doveva risultare semplice e accessibile. La divisione in
categorie ha reso i prodotti facilmente ricercabili. Oltretutto la presentazione dei
dati è stata studiata in modo tale da avere sempre una buona panoramica sulla
situazione delle giacenze. Tutti i dati vengono messi a disposizione
immediatamente, il che consente di seguire in tempo reale le operazioni di
carico/scarico merci intraprese dal magazziniere. L'utente interagisce con il
sistema tramite quattro schermate, corrispondenti alle quattro funzionalità
principali. Di seguito alcuni screenshot dell'interfaccia.
Figura 4.30. Sito web - Pagina principale.
pag. 57
Figura 4.31. Sito web - Pagina relativa ad una categoria di prodotti.
pag. 58
Figura 4.32. Sito web - Lista movimenti di un prodotto.
pag. 59
Figura 4.33. Sito web - Pagina per la modifica dei dati dei prodotti.
4.7.4 Sketch arduino
Il programma è un file in formato INO contenente due funzioni, la prima
denominata setup(), la quale comprende le operazioni che vengono compiute
una sola volta all'accensione del sistema, e la seconda detta loop(), che
raccoglie una serie di azioni da ripetere ciclicamente finché la scheda non viene
riavviata o spenta.
pag. 60
Figura 4.34. Ciclo di esecuzione Arduino
Il software che è stato sviluppato per permette il controllo del dispositivo tramite
una interfaccia visibile sul display LCD, dentro la quale è possibile "navigare"
tramite l'uso della tastiera.
4.7.4.1
Comunicare con il database
Grazie alla libreria Bridge, creata appositamente per delegare tutte le
connessioni network ed i processi delle comunicazioni HTTP alla macchina
Linux, è possibile lanciare programmi e script da linea di comando passando
loro dati sotto forma di parametri e poter leggere i risultati delle operazioni.
Questo è ciò che viene fatto sommariamente da Arduino per comunicare con la
base dati:
Process p;
p.begin(F("php-cli"));
p.addParameter(F("/mnt/sda1/www/bin/console"));
p.addParameter(F("get:item"));
p.addParameter(barcode);
p.run();
Process è una classe della libreria Bridge usata per comunicare con la console
di linux. php-cli è l'interprete che ci consente di eseguire lo script PHP (in
questo caso localizzato in mnt/sda1/www/bin/console), e che ha il compito
di comunicare con il database. Le operazioni che la pagina PHP deve eseguire
sono specificate attraverso l'aggiunta di un parametro alla linea di comando. In
pag. 61
questo caso get:item informa la pagina PHP che ha il compito di recuperare i
dati riguardante un codice a barre, inserito poi come secondo argomento, e di
stamparli a video per renderli disponibili ad Arduino.
4.7.4.2
Riconoscimento del tasto
Per poter decodificare un tasto della tastiera analogica bisogna per prima cosa
attivare l'interrupt sul piedino scelto per ricevere l'uscita del comparatore visto
nel capitolo 4.5.4.
Lo facciamo con questa istruzione:
attachInterrupt(1, interrupt_handler, FALLING);
Il primo argomento della funzione è il numero del pin, il secondo è un callback
ad una subroutine nel caso si verifichi l'evento, mentre il terzo descrive le
modalità per cui esso si verifica. Si è scelto FALLING perché il comparatore ha
in uscita una tensione alta, per poi commutare in caso di pulsante premuto. È
quindi necessario campionare l'ingresso dell'ADC solo nei momenti
immediatamente successivi a quando il comparatore passa da uno stato alto ad
uno basso ( sul fronte di discesa ).
Quando ciò accade il normale ciclo del programma viene interrotto per eseguire
questo programma:
void interrupt_handler()
{
static unsigned long last_interrupt_time = 0;
unsigned long interrupt_time = millis();
if (interrupt_time - last_interrupt_time > 250) {
scanKeys();
}
last_interrupt_time = interrupt_time;
}
La funzione scanKeys() è quella che si occupa di effettuare la lettura del pin
analogico.
Per riuscire a identificare il tasto premuto è stato scelto l'utilizzo di una tabella
con i valori dei singoli pulsanti (char). Ad ogni pulsante è stato associato un
range di valori accettabili (minimo e massimo) che il valore digitalizzato
dell'ingresso all'A/D deve possedere affinché si abbia una corrispondenza.
La tabella è strutturata come segue:
pag. 62
#define NUM_KEY 12
typedef struct KEYPAD_TABLE
{
char val_key;
int analog_min;
int analog_max;
} KEYPAD_TABLE;
static const KEYPAD_TABLE PROGMEM keypadData[NUM_KEY] =
{
{'1', 42, 50},
{'2', 76, 88},
{'3', 120, 126},
{'4', 180, 190}, {'5', 291, 298}, {'6', 390, 396},
{'7', 495, 526}, {'8', 640, 660}, {'9', 720, 748},
{'Y', 795, 818}, {'0', 850, 882}, {'N', 898, 918},
};
Ogni riga di questa tabella occupa 5 byte (un byte per il char e quattro byte per i
due int) e poiché la tabella ha 12 righe, le dimensioni totali sono di 60 byte. Si è
quindi preferito salvare la tabella nella memoria flash (usando PROGMEM) anziché
usare la SRAM.
scanKeys()
itererà la tabella in questo modo per identificare il tasto premuto:
analogValue = analogRead(A0);
for (int i=0; i<NUM_KEY; i++) {
if (
analogValue > pgm_read_word(&keypadData[i].analog_min)
&&
analogValue < pgm_read_word(&keypadData[i].analog_max)
) {
anyKeyIsPressed = true;
keypad_index = i;
break;
}
}
pag. 63
4.8
Tabella riassuntiva dei costi finali
Costi relativi ai componenti
Universal CCD Scanner PS2
€ 35.10
Arduino YUN
€ 52.00
MicroSD da 2GB
€ 4.95
Display LCD HD44780 16x2
€ 3.48
Tastierino 4x3
€ 5.00
LM7805
€ 0.23
LM311
€ 0.30
Adattatore DB9
€ 2.97
Costi di progettazione
Hardware: 35 ore
€ 35.00
Software: 50 ore
€ 40.00
Totale
179.03 €
pag. 64
Capitolo 5
Conclusioni
L'obbiettivo che ci siamo imposti all'inizio del progetto è stato quello di creare
un dispositivo capace di fornire ad una azienda di piccole dimensioni un sistema
essenziale di inventariato delle merci.
È stato stuzzicante prendere parte alla progettazione di un prototipo dal suo stato
embrionale. Essere messi di fronte a delle scelte progettuali ci ha costretto a
prendere decisioni studiate e ponderate che ci hanno aperto a soluzioni che
prima non conoscevamo. Il risultato finale del lavoro è una soluzione originale
che ci ha soddisfatto particolarmente. Tutto il software dedicato alla gestione dei
dati si trova nel dispositivo stesso: non c'è perciò la necessità di utilizzare
componenti esterni per poter funzionare.
Trattandosi di una implementazione prototipale, lo sviluppo del dispositivo ha
rappresentato la prima tra le numerose fasi che dovranno essere in seguito
realizzate per poter arrivare ad un ipotetico prodotto commerciale.
Ciò che ha reso il lavoro particolarmente interessante, oltre alla fase evolutiva di
progettazione che il prototipo ha vissuto già dai suoi primi giorni, è stato
l'utilizzo della neo-nata scheda Arduino YUN. La possibilità di poter sfruttare
una scheda che integra wifi, ethernet e l'ambiente Linux ci ha aperto a molte
opportunità affascinanti, che abbiamo cercato di sfruttare saggiamente.
In conclusione riteniamo che l'esperienza fatta con la progettazione e la
realizzazione di questa scheda ci ha permesso di approfondire e di toccare molti
argomenti rilevanti nelle discipline tecniche studiate quest'anno.
In sintonia con la filosofia open source dei componenti utilizzati in questo
progetto abbiamo voluto aprire i codici sorgenti del sito web, dello sketch e
degli schemi del circuito sbrogliato. Tutti i file sono disponibili all’indirizzo:
http://www.istitutoprimolevi.gov.it/magazzino/web/tesina.zip
pag. 65
Appendice A
Schema circuitale
pag. 66
Appendice B
Circuito stampato
B.1. PCB
pag. 67
B.2. Lato componenti
pag. 68
B.3. Lato saldature
pag. 69
Appendice C
Fotografie
C.1. Visione dall'alto
pag. 70
C.2. Visione di lato
C.3. Visione da dietro
pag. 71
Appendice D
Sketch
/**
* Area di progetto 2013/2014
*
I.I.S PRIMO LEVI
*
* by Lorello Federico - 5°BN
*/
#include
#include
#include
#include
#include
<Process.h>
<JsonParser.h>
<PS2Keyboard.h>
<LiquidCrystal.h>
<MenuBackend.h>
void setup()
{
menuSetup();
apiSetup();
scannerSetup();
keypadSetup();
}
void loop()
{
mainMenu();
}
struct item_t {
char* name;
long stock;
};
// Inizializza la libreria per la comunicazione con Linux
void apiSetup()
{
Bridge.begin();
}
// Configura manualmente l'orologio del sistema
int timerSetup(int year, int month, int day, int hours, int
minute)
{
Process p;
char command[20];
sprintf(command, "%d.%d.%d-%d:%d", year, month,day, hours,
minute);
pag. 72
p.begin(F("date"));
p.addParameter(F("-s"));
p.addParameter(command);
p.run();
if (p.exitValue() != 0) {
return 0;
}
return 1;
}
// Comunica con il database attraverso la console l'operazione
di carico e scarico.
// Restituisce 1 in caso di successo, 0 in caso di errore.
int addStock(char* barcode, int qIn, int qOut)
{
char param[16];
Process p;
p.begin(F("php-cli"));
p.addParameter(F("/mnt/sda1/www/bin/console"));
p.addParameter(F("add:stock"));
p.addParameter(barcode);
if (qIn > 0) {
sprintf(param, "--qIn=%d", qIn);
p.addParameter(param);
}
if (qOut > 0) {
sprintf(param, "--qOut=%d", qOut);
p.addParameter(param);
}
p.run();
if (p.exitValue() != 0) {
return 0;
}
return 1;
}
// Recupera le informazioni di un prodotto dal database
attraverso la console. I dati restituiti sono codificati in
JSON.
// Restituisce 1 in caso di successo, 0 in caso di oggetto non
trovato, o -1 se la funzione non riesce a decodificare il testo
recuperato dall'API.
int getItem(char* barcode, struct item_t* item)
{
Process p;
p.begin(F("php-cli"));
p.addParameter(F("/mnt/sda1/www/bin/console"));
pag. 73
p.addParameter(F("get:item"));
p.addParameter(barcode);
p.run();
if (p.exitValue() != 0) {
return 0;
}
char json[64]; int index = 0;
while (p.available() > 0) {
json[index++] = (char) p.read();
}
json[index] = '\0';
JsonParser<5> parser;
JsonHashTable hashTable = parser.parseHashTable(json);
if (!hashTable.success()) {
return -1;
}
(*item).name = hashTable.getString("name");
if (strcmp((*item).name,"null") == 0) {
(*item).name = "";
}
(*item).stock = hashTable.getLong("stock");
return 1;
}
// Da implementare..
void reboot()
{
// ??
}
// Inizializza LCD
LiquidCrystal lcd(13, 12, 11, 10, 9, 8);
// Inizializza menù
MenuBackend menu(menuUseEvent, menuChangeEvent);
MenuItem
MenuItem
MenuItem
MenuItem
miInfo("Info", 'I');
miCarica("Carica", 'C');
miScarica("Scarica", 'S');
miConfig("Config", 'Z');
// Inizializza menù e lcd
void menuSetup()
{
// inizializza lcd
lcd.begin(16, 2);
lcd.print(F("Caricamento..."));
pag. 74
// popola menù
menu.getRoot().add(miInfo).add(miCarica).add(miScarica).add(miCo
nfig);
}
// Questa funzione gestisce l'azione di selezione del menù
dall'utente.
void menuUseEvent(MenuUseEvent used)
{
if (used.item == miInfo) {
infoMenu();
} else if (used.item == miCarica) {
caricaMenu();
} else if (used.item == miScarica) {
scaricaMenu();
} else if (used.item == miConfig) {
configMenu();
}
}
void menuChangeEvent(MenuChangeEvent changed)
{
}
// Menù principale, permette di accedere ai vari sottomenù.
void mainMenu()
{
lcd.clear();
lcd.print(F("1.Info 2.Carica"));
lcd.setCursor(3, 1);
lcd.print(F("3.Scarica"));
waitForKey();
switch(getKey()) {
case '1':
menu.use('I');
break;
case '2':
menu.use('C');
break;
case '3':
menu.use('S');
break;
case '9':
menu.use('Z');
break;
}
}
pag. 75
// Menù per la configurazione dell'orologio di linux.
void configMenu()
{
char date[20];
int y=2014, m=0, d=0, h=0, mm=0;
lcd.clear();
lcd.print(F("Configurazione"));
delay(2000);
askNumber("Anno: ", &y) && askNumber("Mese: ", &m) &&
askNumber("Giorno: ", &d) && askNumber("Ora: ", &h) &&
askNumber("Minuti: ", &mm);
sprintf(date, "%d/%d/%d %d:%d", d, m,y, h, mm);
lcd.clear();
lcd.print(date);
lcd.setCursor(0, 1);
lcd.print(F("Confermi?"));
delay(500);
while (true) {
waitForKey();
char c = getKey();
if (c == 'N') {
break;
} else if (c == 'Y') {
lcd.clear();
if (timerSetup(y, m, d, h, mm)) {
lcd.print(F("Salvataggio..."));
reboot();
} else {
lcd.print(F("Formato invalido"));
}
delay(2500);
return;
}
}
}
// Menù per recuperare il nome e la quantità in giacenza dalla
lista dei prodotti.
void infoMenu()
{
char barcode[13];
if (askBarcode(barcode)) {
item_t item;
if (getItem(barcode, &item) == 1) {
int str_len = strlen(item.name);
lcd.clear();
pag. 76
if (str_len == 0) {
lcd.print(barcode);
} else if (str_len > 15) {
item.name[14] = '\0';
lcd.print(item.name);
lcd.print(F(".."));
} else {
lcd.print(item.name);
}
lcd.setCursor(0, 1);
lcd.print(F("Quantita': "));
lcd.print(item.stock);
} else {
lcd.clear();
lcd.print(F("Il prodotto non"));
lcd.setCursor(0, 1);
lcd.print(F("e' in inventario"));
}
waitForKey('Y');
}
}
void caricaMenu()
{
stockItem(true);
}
void scaricaMenu()
{
stockItem(false);
}
// Gestisce l'operazione di carico e scarico merci.
void stockItem(bool toAdd)
{
char barcode[13];
if (askBarcode(barcode)) {
int q=0;
delay(2500);
askNumber("Quantita': ", &q);
if (q > 0) {
int ret = 0;
if (toAdd) {
ret = addStock(barcode, q, 0);
} else {
ret = addStock(barcode, 0, q);
}
if (ret == 0) {
pag. 77
lcd.clear();
lcd.print(F("Errore"));
} else {
lcd.clear();
lcd.print(F("Il prodotto e'"));
lcd.setCursor(0, 1);
lcd.print(toAdd ? F("stato caricato") : F("stato
scaricato"));
}
delay(2500);//waitForKey('N');
}
}
}
// Chiedi all'utente un numero da digitare attraverso la
tastiera.
int askNumber(const char* msg, int *n)
{
lcd.clear();
lcd.print(msg);
lcd.setCursor(0, 1);
lcd.print(*n);
lcd.blink();
while (true) {
int s = getNumberFromKeypad(n);
if (s == 2) {
lcd.noBlink();
return 1;
} else if (s == -1) {
lcd.noBlink();
return 0;
} else if (s == 1) {
lcd.setCursor(0, 1);
lcd.print(F("
lcd.setCursor(0, 1);
lcd.print(*n);
}
delay(250);
}
}
// Chiedi per un codice a barre.
int askBarcode(char *barcode)
{
lcd.clear();
lcd.print(F("Codice prodotto:"));
lcd.setCursor(0, 1);
lcd.blink();
"));
pag. 78
while (!getBarcode(barcode)) {
if (isPressed('N')) {
lcd.noBlink();
return 0;
}
delay(250);
}
lcd.noBlink();
lcd.print(barcode);
return 1;
}
PS2Keyboard scanner;
// Inizializza lo scanner.
void scannerSetup()
{
scanner.begin(4, 3);
}
// Funzione asincrona per recuperare il barcode.
// Restituisce 1 se 'data' viene popolata correttamente, 0 in
caso contrario.
int getBarcode(char *data) {
// può essere utile pulire il buffer alla prima chiamata:
// questo per evitare di restituire barcode non richiesti dal
programma.
static bool cleanBufferFirst = true;
if (cleanBufferFirst) {
while(scanner.available()) {
scanner.read();
}
cleanBufferFirst = false;
}
// non-blocking: se non è presente alcun dato restituisci 0
// e dai la possibilità di gestire l'evento.
if (!scanner.available()) {
return 0;
}
int i=0;
cleanBufferFirst = true;
do {
delay(5); // ?
if (scanner.available()) {
data[i++] = scanner.read();
} else {
pag. 79
return 0;
}
} while(i < 13);
data[13] = '\0';
return 1;
}
#define NUM_KEY 12
typedef struct KEYPAD_TABLE
{
char val_key;
int analog_min;
int analog_max;
} KEYPAD_TABLE;
// Tabella con i valori del tastierino, con associati il
relativo range di tensione in cui devono cadere.
static const KEYPAD_TABLE PROGMEM keypadData[NUM_KEY] =
{
{'1', 42, 50},
{'2', 76, 88},
{'3', 120, 126},
{'4', 180, 190}, {'5', 291, 298}, {'6', 390, 396},
{'7', 495, 526}, {'8', 640, 660}, {'9', 720, 748},
{'Y', 795, 818}, {'0', 850, 882}, {'N', 898, 918},
};
volatile bool anyKeyIsPressed = false;
volatile byte keypad_index = 0;
void keypadSetup()
{
attachInterrupt(1, interrupt_handler, FALLING);
}
// Analizza l'input analogico, e verifica se e quale pulsante è
stato premuto.
void scanKeys()
{
int n = 10; // n. letture da fare.
int analogValue = 0;
// @TODO: ho notato che fare la media di una decina di letture
del valore analogico rende la lettura più "stabile" e
veritiera..
// il problema è che questa routine viene eseguita da
interrupt, e non dovrebbe impiegare più di qualche ms per essere
eseguita.
// ma solo per fare la media di questa tensione ci mettiamo
più di 20ms...
for (int c=0; c<n; c++) {
analogValue += analogRead(A0);
pag. 80
}
// recupero del valore digitalizzato della tensione
analogValue = analogValue/n;
for (int i=0; i<NUM_KEY; i++) {
if (analogValue > pgm_read_word(&keypadData[i].analog_min)
&& analogValue < pgm_read_word(&keypadData[i].analog_max)) {
anyKeyIsPressed = true;
keypad_index = i;
break;
}
}
}
// E' stato premuto un pulsante per la tastiera?
bool isKeyPressed()
{
return anyKeyIsPressed;
}
// Restituisci il valore associato al pulsante premuto.
// Ho ritenuto che l'utilizzo di un buffer per riuscire a
recuperare il valore di più pulsanti quando il programma è
bloccato
// fosse più svantaggioso che altro: se il programma non rileva
la pressione di un pulsante allora ripremilo di nuovo!
char getKey() {
if (anyKeyIsPressed) {
anyKeyIsPressed = false;
return pgm_read_word(&keypadData[keypad_index].val_key);
}
}
// Gestione interrupt
void interrupt_handler()
{
static unsigned long last_interrupt_time = 0;
unsigned long interrupt_time = millis();
if (interrupt_time - last_interrupt_time > 250) {
scanKeys();
}
last_interrupt_time = interrupt_time;
}
// helper
bool isPressed(const char c) {
if (isKeyPressed()) {
char key = getKey();
if (key == c) {
pag. 81
return true;
}
}
return false;
}
// helper
void waitForKey(const char c)
{
while(!(getKey() == c)) {
delay(500);
}
}
// helper
void waitForKey()
{
while(!isKeyPressed());
}
int getNumberFromKeypad(int *n)
{
if (isKeyPressed()) {
char key = getKey();
if ('Y' == key) {
return 2;
} else if ('N' == key) {
if (*n == 0) {
return -1;
} else {
*n=0;
return 1;
}
} else if (key >= '0' && key <= '9') {
*n=*n*10+(key-48);
return 1;
}
}
return 0;
}
pag. 82
Sitografia
[1]
Agus G. – Il magazzino virtuale di Unitec: Applicazione ad un distretto
sanitario.
http://www.unitec.it/ita/tesi/agus/tesi_agus.html
[2]
Manuale del codice a barre
http://www.codiceabarre.it/bcmanu.htm
[3]
Panoramica su codici a barre e tipi di lettori
http://www.gestionalev5.it/panoramica-su-codici-a-barre-e-tipi-di-lettori/
[4]
Bresil A. – Analisi tecnica del riconoscimento dei codici a barre
http://xoomer.virgilio.it/andrea_bresil/2.htm
[5]
Which Barcode Scanner Interface is right for me?
http://www.taltech.com/barcodesoftware/articles/which_barcode_scanner_interface
[6]
Arduino.cc
http://arduino.cc/
[7]
Nepori A. – Arduino, Una rivoluzione open source
http://camillomiller.com/arduino/index.html
[8]
Tastiera e la PS2
http://www2.units.it/marsi/elettronica2/tesine_elettro/eco/il_progetto_file/TASTIERA%2
0E%20LA%20PS2.pdf
[9]
Bernando G. –Gestione di un tastierino a matrice
http://www.settorezero.com/wordpress/corso-programmazione-picmicro-in-capprofondimenti-gestione-di-un-tastierino-a-matrice/
[10] Connection to an ADC with a resistor matrix
http://www.avr-asm-tutorial.net/avr_en/keypad/keyboard.html#adc
[11] Maffucci M. – Appunti su Arduino: pilotare un display LCD
http://www.maffucci.it/2012/02/17/appunti-su-arduino-pilotare-un-display-lcd/
[12] Stabilizzatore LM78XX / LM79XX
http://www.grix.it/viewer.php?page=7751
[13] Ceratto F. – Analisi comparata di MySQL, PostgreSQL e SQLite.
http://www.roberto.foglietta.name/pub/docs/Comparazione_RDBMS-14a.pdf
pag. 83
[14] SQLite
http://www.xenialab.it/meo/web/white/oracle/sqlite.htm
[15] Benfante L. – Il modello relazionale
http://www.html.it/pag/31720/il-modello-relazionale/

Quotidiano di Sicilia 10 aprile 2015

0111 - Invece io vi dico

COMUNICATO STAMPA - Banco di Desio e della Brianza

Decreto sblocca-trivelle, pioggia di ricorsi

Fondazione Ort. I due Statuti a confronto in un unico

La portabilità è un diritto

Le cifre difficili del fotovoltaico

Biomasse e biogas senza incentivi

Cambiamenti climatici, si alza la voce del buon senso