Tesi Centralina Di Controllo Per Serrature ONLINE

UNIVERSITA’ TELEMATICA “e-Campus”

Facoltà di Ingegneria Corso Di Laurea in Informatica

Progettazione e sviluppo in C++ di una centralina di controllo per serrature motorizzate con controllo accessi

Relatore: Luigi Sarti

Tesi di Laurea di: Aldo Fadalti

Matricola numero 5500

Anno Accademico 2011/ 2012

Università Telematica e-Campus Facoltà di Ingegneria

Pag. 2

ALLEGATO “B”

AUTORIZZAZIONE ALLA CONSULTAZIONE DELLA TESI DI LAUREA

Il sottoscritto Aldo Alessandro Fadalti N° di matricola 5500 nato a Treviso il 03/12/1976 autore della tesi dal titolo

Progettazione e sviluppo in C++ di una centralina di controllo per serrature motorizzate con controllo accessi

AUTORIZZA la consultazione della tesi stessa, fatto divieto di riprodurre,

parzialmente o integralmente, il contenuto.

Dichiara inoltre di AUTORIZZARE per quanto necessita l’università telematica e-

Campus, ai sensi della legge n. 196/2003, al trattamento, comunicazione, diffusione e pubblicazione in Italia e all’estero dei propri dati personali per le finalità ed entro i limiti illustrati dalla legge.

Data________________ Firma__________________ SPAZIO RISERVATO ALL’UFFICIO SEGRETERIA: Laureato/a il ______________ Con la votazione di ______/ 110


Pag. 3

Indice

Introduzione............................................................................................... 5

Requisiti ................................................................................................... 10

Concetti del corso di Algoritmi e Strutture Dati presenti nell’ambito

della progettazione e sviluppo del software della centralina .................. 12

Scelta del microcontrollore ..................................................................... 14

Pre-verifica disponibilità RAM e uso della EEprom per i dati permanenti

................................................................................................................. 16

Scelta del Keypad e comunicazione con la centralina ............................ 19

Metodi di inizializzazione e startup in Arduino ...................................... 23

Inizializzare le risorse hardware .............................................................. 25

Creazione di oggetti polimorfici sulla base di parametri iniziali costanti

................................................................................................................. 29

Gli Interrupt ............................................................................................. 33

Creazione degli oggetti OOP ad allocazione dinamica tramite l’operatore

New() ....................................................................................................... 36

Override del metodo di sistema per ricavare data e ora da un chip

DS1307 .................................................................................................... 38

Debugging, gestione errori e difficoltà caratteristiche dello sviluppo con

un microcontrollore ................................................................................. 40


Pag. 4

Gestione password, parsing e logica di ricerca ....................................... 43

Realizzazione hardware della centralina ................................................. 46

Motoriduttore .......................................................................................... 49

Esploso di montaggio .............................................................................. 51

Possibili utilizzi del prototipo ................................................................. 53

Analisi comparativa con i dispositivi commerciali esistenti ed elementi

di novità ................................................................................................... 56

Bibliografia .............................................................................................. 63


Pag. 5

Introduzione

In un periodo di crisi economica che sta coinvolgendo i Paesi più

industrializzati, è doveroso indirizzare gli sforzi creativi verso la ricerca di

nuove tecnologie. L’Italia e’ un paese non in grado di competere con i

nuovi Paesi emergenti dal punto di vista della manodopera industriale. Di

conseguenza, è di fondamentale importanza maturare l’etica di creare

novità tecnologiche in ogni contesto. Ecco da dove nasce l’idea di

progettare una serratura motorizzata.

Ormai è consuetudine nello stile di vita quotidiana usufruire di automatismi

che rendono il vivere più agevole. Sono svariate le comodità di cui è ormai

difficile fare a meno; si va dall’aria condizionata ai finestrini elettrici di

un’automobile, dai cancelli automatici alle tapparelle elettriche di una casa.

La serratura rimane ancora uno dei pochissimi dispositivi profondamente

legati all’azione manuale della persona, si pensi che la prima chiave risale

al 4000 a.C. nell’antico Egitto. Pur essendosi evoluta nella tecnica di

realizzazione costruttiva, la chiave è rimasta concettualmente invariata nei

secoli. Bisogna sempre ruotarla manualmente. La chiave è anche un

oggetto ingombrante da tenere sempre con sè e, in caso di perdita, sussiste

il serio pericolo di duplicazione.


Pag. 6

E’ stato riscontrato che le porte blindate, in assenza della chiusura con le

mandate, sono facilmente apribili semplicemente forzando lo scrocco

attraverso l’inserimento di una piccola lastra radiografica. E’ altresì

consuetidine, forse per pigrizia, non chiudere le mandate nelle ore diurne o

per brevi permanenze nell’ambiente, con conseguente esposizione al

rischio di ingressi forzati ad opera di indesiderati. Nel progetto della

serratura motorizzata, la centralina impone la chiusura completa delle

mandate ad ogni accostamento della porta. La presenza di un interruttore

facilmente accessibile, chiamato Day&Night, inibisce in caso di attivazione

la chiusura automatica che risulterebbe oppressiva negli ambienti

lavorativi.


Pag. 7

Figura 1: Vista esterna del dispositivo installato

Se si considerano sufficienti i motivi finora esposti per dotarsi di una

serratura motorizzata, si possono allora valutare anche altre funzionalità

dovute alla presenza di una centralina elettronica. La più importante è

sicuramente caratterizzata dal controllo accessi che, oltre a garantire


Pag. 8

l’ingresso autenticato, permette anche di limitare l’entrata degli utenti solo

in certe fasce orarie di determinati giorni settimanali. Oltre a ciò, l’utente

con i privilegi di ammistratore può in qualunque momento disporre

dell’elenco completo degli accessi, comprensivo di orario e di

identificativo, salvato su una comune chiavetta USB.

L’installazione del dispositivo che abilita fisicamente l’apertura automatica

è intuitivo e applicabile a qualunque sistema di chiusura già pre esistente.

Ciò è reso possibile, a livello meccanico, dalla giunzione mediante coppia

conica fra il perno del motoriduttore e il codolo del cilindro. Il numero

ridotto di componenti di cui è composto il prototipo costuisce un ulteriore

vantaggio sia in termini di costi che di installazione.


Pag. 9

Figura 2: Vista interna del prototipo montato


Pag. 10

Requisiti

La centralina soddisfa le seguenti specifiche:

Funzione day&night attivabile con semplice tasto selettore; in

modalità’ day non chiude le mandate

Programmabile facilmente dall’utente da tastiera

Impostazione di password personalizzate con accesso a fasce orarie

ristrette, giornaliere o settimanali fino a 50 utenti

Blocco tastiera esterna (pressione di 2,5 secondi del pulsante di

apertura interno); sblocco automatico all’apertura dall’interno

Rolling code: permette di inserire più’ numeri fino all’inserimento

della password corretta(per evitare la memorizzazione visiva di chi

osserva mentre digiti il codice)

La tastiera comunica con la centralina in modo criptato, anche

collegando i fili tra di loro, il sistema non apre la porta.

Dopo 30 digitazioni casuali, il sistema si blocca per 3 minuti.

Funzione anticoercizione: inserendo il proprio codice +1 apre la

porta e chiama e/o manda SMS fino a 5 numeri di telefono con

funzione allarme


Pag. 11

Apertura e chiusura automatica di scrocco e mandate senza l’ausilio

delle chiavi

Apertura da remoto tramite un semplice squillo telefonico senza

costo

Gestione degli utenti abilitati all’apertura da remoto tramite semplici

SMS autorizzati da un codice amministrativo

Memorizzazione degli ultimi 5500 accessi, con relativo orario.

L’utente amministratore ha la possibilità di scaricare su una chiavetta

USB i dati memorizzati in un file formato Excel

Figura 3: Specifiche operazionali del software del microcontrollore


Pag. 12

Concetti del corso di Algoritmi e Strutture Dati presenti

nell’ambito della progettazione e sviluppo del software

della centralina

1. Applicazione di Design Pattern per esigenze tipiche dei

microcontrollori applicati al C++

2. Concorrenza nel microcontrollore a CPU singola. Uso degli interrupt

per la gestione di processi secondari a priorità Real Time. Variabili

volatili

3. Uso di meccanismi di astrazione, tipici della programmazione OOP,

come strumento per un ottimale riutilizzo di codice.

4. Il concetto di ricorsione applicato alla scansione di strutture dati in

memoria EEprom. Complessità teorica dell’algoritmo. Vantaggi e

svantaggi nell’uso di una EEprom


Pag. 13

5. Applicazione dei concetti fondamentali della programmazione

orientata agli oggetti: incapsulazione, strutturazione gerarchica delle

classi, ereditarietà, polimorfismo e information hiding

6. Programmazione event driven in C++ in risposta a eventi fisici

esterni trasmessi da sensori e keypad

7. Gestione delle eccezzioni nel microcontrollore. Debugging e

monitoring della memoria su un dispositivo privo di output visivo,

con uptime continuo al 100% (watchdog)

8. Trasmissione seriale tra microcontrollori. Ricezione dei caratteri dal

keypad e corrispettivo invio di informazioni sul segnale acustico

9. Gestione password, parsing e logica di ricerca.

10. Tecniche avanzate della programmazione OOP nel microcontrollore,

hacking dello stesso al fine di disporre di Templates e allocazione di

oggetti (operatori new()e free())


Pag. 14

Scelta del microcontrollore

Arduino è un microcontrollore open source programmabile in C++.

Figura 4: Una foto del microcontrollore Arduino Mega

Il modello utilizzato per governare la centralina di questo progetto è il

Mega basato su processore ATmega1280 ad una frequenza di 16MHz.

L’Arduino Mega1 ha 54 input/output digitali, 16 input analogici e 4 porte

seriali. La memoria Flash è di 128KB ed è allo stesso tempo la massima

dimensione possibile del compilato, la SRAM è di 8KB ed è la quantità di

memoria disponibile a run-time per le variabili e per ogni altra struttura

1 Fonte: http://arduino.cc/en/Main/ArduinoBoardMega2560

http://arduino.cc/en/Main/ArduinoBoardMega2560


Pag. 15

temporanea, è disponibile anche una EEprom di 4KB utilizzata dal

software di questo progetto per contenere le password degli utenti con le

loro restrizioni di accesso.


Pag. 16

Pre-verifica disponibilità RAM e uso della EEprom per i

dati permanenti

Nei microcontrollori la quantità di RAM disponibile è sempre molto

limitata per mantenere basso il prezzo del prodotto e ridurre al massimo le

dimensioni. In tali condizioni è fondamentale progettare fino dall’inizio il

software in modo tale da non necessitare di grandi strutture dati nella

memoria volatile che risulterebbe ben presto insufficiente. Nel software

oggetto di questa tesi la più grande struttura dati è rappresentata dal numero

di utenti programmabili con all’interno i dati caratteristici di accesso:

struct StrutturaPwd {

char pwd[MAX_PWD_LEN]; //5 bytes

signed char deleted; //1 byte

signed char dayOfWeek[DAYS]; //7bytes

signed char fromHour[DAYS]; //7bytes

signed char toHour[DAYS]; //7bytes

signed char fromMinute[DAYS]; //7bytes

signed char toMinute[DAYS]; //7bytes

};

La quantità di spazio richiesta dalla struttura va moltiplicata per i 50 utenti

disponibili da specifiche. Una tale dimensione in bytes risulterebbe essere

di 50x(5+1+7+7+7+7+7), decisamente troppa per l’esigua RAM

disponibile alla quale va comunque garantita una minima quantità libera


Pag. 17

per ogni evenienza. Si è così deciso di far risiedere i dati degli utenti nella

EEprom senza mai spostarli o copiarli nella RAM per le operazioni di

ricerca/inserimento/cancellazione. La memoria EEprom, Electrically

Erasable Programmable (Read-Only) Memory, è per concezione piuttosto

rapida nell’accesso in lettura ma molto lenta in scrittura dato che in tale

operazione si devono ossidare i gates dei transitors Floating Gate MOSFET

interni alla memoria Eeprom. Per meglio dare una sensazione pratica,

vengono, per così dire, “riscaldati” delle sorte di “fusibili ripristinabili”

corrispondenti agli 1 e 0 della memoria stessa, e per tale motivo sussiste un

limite massimo nel numero di riscritture di una cella EEprom pari circa a

1000/1500 e l’operazione richiede quindi un certo tempo in più rispetto alla

lettura.

Nel momento in cui un utente inserisce il proprio codice per essere

autenticato dalla centralina, vengono scansionate le password direttamente

nella EEprom senza trasferire nulla in RAM.


Pag. 18

Figura 5: Immagine del microcontrollore2 a bordo dell'Arduino Mega. La EEprom

di 4 KB è integrata.

2 Fonte: http://it.rs-online.com/web/

http://it.rs-online.com/web/


Pag. 19

Scelta del Keypad e comunicazione con la centralina

Figura 6: Il keypad scelto è di classe IP67 con uscita a matrice

Il keypad3 è lo strumento principale di input per l’utente. Tramite il keypad

è possibile entrare nel menù amministrativo e svolgere le principali

impostazioni della centralina. Le più importanti sono

l’aggiunta/eliminazione di utenti, l’impostazione di data e ora e il reset a

fabbrica di tutto il sistema.

3 Fonte: http://www.eao.com/global/en/home.asp?navid=0

http://www.eao.com/global/en/home.asp?navid=0


Pag. 20

Figura 7: Fotografia reale del keypad

Il keypad è di fabbrica predisposto con un uscita a matrice, il che significa

dover impiegare ben nove ingressi digitali sul microcontrollore oltre ai

collegamenti necessari per alimentare l’illuminazione dei tasti alla loro

prima pressione. Per ridurre il numero di connessioni tra keypad e

centralina si è scelto di cambiare la comunicazione da analogica a digitale.

Invece di collegare direttamente l’uscita a matrice alla centralina la si

collega ad un piccolo microprocessore PIC installato su una PCB posta

dietro il keypad.


Pag. 21

Figura 8: Il microcontrollore PIC legge la matrice del keypad e invia i dati in

protocollo seriale alla centralina

Il PIC4 si prenderà cura di leggere le pressioni dei tasti dall’uscita a matrice

e di trasmetterli alla centralina in protocollo seriale alla velocità di 600 bit

per secondo. Con tale digitalizzazione si riduce il numero di connessioni

con la centralina a un solo filo per la trasmissione e altri due per

l’alimentazione. Inoltre la bassa velocità di trasmissione scelta rende molto

più ampia la possibilità di installare i cavi all’interno di canaline disturbate

elettricamente dal passaggio di corrente in altri cavi vicini.

4 Fonte: http://it.rs-online.com/web/

http://it.rs-online.com/web/


Pag. 22

Figura 9: Il circuito stampato ospitante due PIC per la conversione A/D di suoni e

pressioni tasti


Pag. 23

Metodi di inizializzazione e startup in Arduino

Per scrivere del codice sorgente in grado di far funzionare il

microcontrollore Arduino sono necessari soltanto due metodi

void setup()

e

void loop()

Il primo è una sorta di “costruttore” del microcontrollore stesso. Viene

eseguito una sola volta all’inizio e solitamente lo si utilizza per:

inizializzare risorse hardware

definire gli interrupt

collegare metodi in risposta agli eventi di interrupt

creare gli oggetti OOP ad allocazione dinamica tramite l’operatore

New()

abilitazione interna di resistenze di “Pull Down” negli ingressi

digitali

inizializzare le porte seriali e settarne la velocità

“Override” del metodo di sistema per ricavare data e ora da un

circuito integrato DS13075

5 Fonte: http://www.ti.com/

http://www.ti.com/


Pag. 24

instanziare gli oggetti polimorfici sulla base di parametri costanti

iniziali

Il secondo altro non è che il metodo che, come può suggerire il nome

stesso, viene continuamente richiamato fin tanto che viene fornita

alimentazione alla centralina.

Tra le operazioni fondamentali eseguite continuamente dal

microcontrollore vi sono:

controllo del buffer seriale per cogliere la presenza di dati relativi

alla pressione di un tasto sul keypad

controllo della pressione del pulsante di apertura interna per

l’apertura porta

controllo della pressione del pulsante di apertura interna per la

disabilitazione del keypad quando la pressione si prolunga oltre i due

secondi

controllo dello stato del deviatore che imposta la modalità Day &

Night abilitando la chiusura automatica delle mandate

controllo dello stato del sensore porta


Pag. 25

Inizializzare le risorse hardware

L’inizializzazione delle risorse hardware è un compito che viene svolto

all’avvio del microcontrollore. Più precisamente all’accensione si avvia un

programma predefinito, il Bootloader, che richiama staticamente il metodo

void setup()

Tale metodo è previsto per dare la possibilità di richiamare procedure che

impostino fisicamente parti dell’hardware del microcontrollore stesso al

fine di predisporle all’uso dedicato allo svolgimento dell’applicativo.

Per lo sviluppo del progetto è necessario avvalersi del metodo

void setup()

in modo tale da:

impostare i canali digitali come ingresso o uscita

attivare resitenze interne da 20KOhm di “Pull Down”

impostare canali analogici come ingressi o uscite di tipo PWM

(Pulse Width Modulation)

impostare la velocità di trasmissione sulle porte seriali

I canali digitali vengono predisposti come ingresso o come uscita tramite la

chiamata


Pag. 26

void pinMode(canale, INPUT/OUTPUT)

Se impostati come ingresso, è possibile leggerne lo stato di contatto o

apertura tramite la funzione

int digitalRead(canale)

ottenendo 1 nel primo caso o 0 nel secondo.

Nel caso di canali digitali configurati come output, tramite la procedura

void digitalWrite(canale, HIGH/LOW)

è possibile portare la tensione a massa nel caso di LOW o a 5V nel caso di

HIGH. Il progettista deve sempre tenere presente che la massima quantità

di corrente erogabile da un singolo canale del microcontrollore Arduino è

di 40mA. Tale quantità è normalmente sufficiente ad illuminare i

tradizionali led di uso comune in elettronica, ma nel caso in cui sia

necessario alimentare carichi più consistenti bisognerà necessariamente

utilizzare come amplificatore di corrente un transistor NPN. Il risultato

finale con l’utilizzo di un transistor, è quello di alimentare il carico

direttamente dalla sorgente di corrente principale che, nei casi più comuni,

è l’alimentatore stesso. In tal caso, avendo la massa in comune con il

carico, va tenuta in considerazione la possibilità di avere disturbi di

tensione sul microcontrollore (EMI Electro Magnetic Interference); ciò è

seriamente possibile alimentando motori a elevato assorbimento di

corrente. Nel progetto in essere, i consumi di 1.6A del motore, a seguito di


Pag. 27

analisi effettuata con l’oscilloscopio, non generano disturbi tali da

richiedere contromisure di schermatura elettromagnetica.

L’attivazione delle resistenze interne di “Pull Down” si effettua

semplicemente chiamando

void digitalWrite(canale, HIGH)

dopo aver impostato il canale come ingresso. La resistenza di “Pull Down”

connette il polo positivo del canale a massa in modo tale da filtrare i

disturbi nella lettura dando un preciso riferimento nullo nel caso in cui

esternamente non si cortocircuitino i due poli del canale.

Il metodo di inizializzazione

void setup()

viene infine usato per impostare la velocità di comunicazione delle porte

seriali. Il protocollo seriale non prevede l’auto-negoziazione della velocità

tra i dispositivi, questa va preimposta al medesimo valore su entrambi

tramite il metodo

Serial.begin(9600);

Nel progetto si utilizzano due porte seriali, relativamente per:

la comunicazione tra il microcontrollore Arduino nella centralina e il

PIC posizionato sul retro del keypad


Pag. 28

l’uscita dedicata alle stringhe di debug


Pag. 29

Creazione di oggetti polimorfici sulla base di parametri

iniziali costanti

E’ previsto il funzionamento della centralina in due configurazioni:

collegata direttamente alla matrice di un keypad

collegata in ricezione seriale a un keypad digitale

E’ evidente che gran parte delle funzionalità logiche siano comuni alle due

tipologie di tastiere; come ad esempio:

lettura del tasto premuto

disabilitazione fisica del dispositivo

segnalazione acustica

accensione retroilluminazione in configurazione notturna

cancellazione del buffer a scadenza di un timeout

Si può quindi dire che entrambe le tastiere rispondano a specifiche comuni

pur realizzandole internamente in modo diverso essendo di differente

tipologia.

In tale scenario la programmazione a oggetti ci permette di creare un

keypad virtuale costituito esclusivamente dalle specifiche logiche comuni a


Pag. 30

tutte le tipologie di keypad reali, tralasciando le peculiarità fisiche non

comuni.

Succesivamente la centralina potrà riferirsi unicamente al keypad virtuale

senza sapere con quale tipo di keypad reale si sta interfacciando.

Figura 10: Diagramma delle classi per il Keypad


Pag. 31

Nella figura sopra riportata è possibile vedere come quanto spiegato sia

stato realizzato, agglomerando tutte le parti logiche comuni nella classe

virtuale/astratta KeybVirtual. Le classi KeybSerial e KeybAnalog, derivate

della classe astratta (figlie), contengono tutte le caratteristiche di

funzionamento specifiche per la loro tipologia fisica di tastiera.

Ad esempio il metodo

void disable()

comune a tutte le tipologie, permette di disabilitare qualunque keypad da

tentativi di utilizzo fisico esterno inibendo la ricezione della pressione dei

tasti. Mentre il metodo

void serial2Write()

della classe KeybSerial permette di inviare in forma digitale, sottoforma di

byte, il codice ASCII corrispondente al tasto premuto. Si faccia bene

attenzione che dal punto di vista logico non è KeybSerial che invia il byte

direttamente alla centralina, ma è la centralina stessa che legge il carattere,

corrispondente alla pressione del tasto, dalla classe astratta KeybVirtual!

Si sarà anche notata in figura la presenza della classe Keypad evidenziata in

arancione e riferita da KeybAnalog con una freccia differente. Ciò sta a

significare che Keypad è una semplice variabile di KeybAnalog e pertanto


Pag. 32

ne potranno essere chiamati a piacere i metodi pubblici da parte del

contenitore KeybAnalog. Infatti se si decide di collegare alla centralina

direttamente una tastiera a matrice, sarà compito della centralina stessa

occuparsi del parsing della matrice rilevando le pressioni dei tasti. La

classe Keypad fa parte delle librerie Arduino di sistema.

Figura 11: Principale vista gerarchica delle classi del SW

Si vuole ricordare che nella tecnologia Arduino, per ridurre l’uso di risorse,

non è prevista di serie la possibilità di implementare un’architettura

polimorfica. Il programmatore può scegliere di disporne e di abilitarla

attraverso la seguente chiamata all’inizio del codice sorgente:

extern "C" void

__cxa_pure_virtual() {

while(1);

}


Pag. 33

Gli Interrupt

L’Interrupt è un segnale asincrono che indica il 'bisogno di attenzione' da

parte di una periferica finalizzata ad una particolare richiesta di servizio.

Nel progetto in esame vengono utilizzati due interrupt per la lettura dei

seguenti dispositivi:

encoder motore

sensore di chiusura porta

Nel primo caso vi è un encoder che, solidale alla rotazione del perno

motore, genera tre impulsi elettrici per ogni rotazione completa attorno

all’asse. E’ evidente che il numero di impulsi provenienti dall’encoder è

molto elevato; avendo scelto un motore da 80 rpm con riduzione 1:50

allora il numero di impulsi al minuto sarà 80x50x3= 12.000 imp/min. Tale

frequenza sarebbe troppo elevata per poter verificare la presenza di

tensione, corrispondente ad un impulso, nel metodo

void loop()

Infatti, in modalità “watchdog”, non è sufficiente affidarsi rigorosamente

alla frequenza di clock della CPU, anche se elevata, per non perdere

nemmeno un’impulso. Ma è necessario garantire che anche il metodo

contenente il controllo dell’impulso debba terminare almeno entro la metà


Pag. 34

della durata impulso stesso. Con i dati di progetto il tempo massimo di

durata del metodo principale

void loop()

, affinchè non venga perso nemmeno un impulso, dovrebbe essere di

(3.600/12.000)/2=0.15 sec. Un tempo decisamente troppo breve e

comunque impossibile da garantire sotto certe condizioni logiche in cui

operazioni considerate unitarie, come ad esempio l’apertura dello scrocco,

aumenterebbero la durata del metodo principale a qualche secondo.

L’adozione degli interrupt in tale situazione permette di avere un metodo

che, nel caso di un singolo impulso, viene automaticamente richiamato

sospendendo ogni altro flusso in esecuzione. Gli unici vincoli da rispettare

sono:

la limitata disponibilità fisica di interrupt

l’obbligo di rendere il metodo richiamato il più breve possibile

Ecco che nel progetto in risposta diretta agli impulsi encoder ci si limita

solamente a incrementare una variabile:

void encoderListener(){

encoderCount++;

}

Questo metodo viene assegnato all’interrupt con la dichiarazione

attachInterrupt(<canale>, encoderListener, CHANGE);


Pag. 35

in cui viene passato come parametro un puntatore al metodo in gestione.

Non ultimo, va ben tenuto presente che ogni variabile modificata da un

metodo richiamato da un evento di tipo interrupt, deve essere dichiarata di

tipo

volatile

Con tale dichiarazione, propria del linguaggio C++, ci si assicura che il

valore della variabile verrà sempre aggiornato ad ogni lettura della stessa

evitando ogni meccanismo di caching.

Alla fine di quanto detto è lecito affermare che l’uso degli interrupt è a tutti

gli effetti una modalità di programmazione concorrente.


Pag. 36

Creazione degli oggetti OOP ad allocazione dinamica

tramite l’operatore New()

Tra i vantaggi portati dalla programmazione a oggetti vi è, in termini di

performaces, la capacità di poter creare strutture dati, con metodi definiti

all’interno, facendole esistere solo per il tempo necessario alla

computazione. Tali strutture dati, nel momento in cui ne viene allocata

fisicamente la memoria, altro non sono che gli oggetti da cui trae nome la

Programmazione Orientata agli Oggetti.

Tramite il metodo

Object New(<Class Name>)

viene allocata fisicamente la memoria ottenendo in ritorno un puntatore

corrispondente all’oggetto creato.

Una volta soddisfatta la necessità di utilizzo dell’oggetto creato si deve

necessariamente deallocare la memoria precedentemente riservata

all’oggetto prima che il puntatore riferito allo stesso oggetto risulti non

essere più accessibile poichè divenuto esterno al campo di visibilità. Il

metodo in questione è

Void free(<pointer>)


Pag. 37

Non si può non accennare al fatto che, al giorno d’oggi, esistano linguaggi

di programmazione che non necessitano di alcun tipo di deallocazione

esplicita di oggetti nel codice sorgente. Stiamo parlando di linguaggi che,

come ad esempio Java, si basano su una Virtual Machine che si prende cura

di deallocare automaticamente le zone di memoria a cui fanno riferimento

puntatori divenuti ormai inaccessibili. Tale operazione viene comunemente

chiamata Garbage Collection.

Nella tecnologia di Arduino non è nativamente supportato l’uso dei meotdi

sopra descritti per allocare e deallocare oggetti. Tale scelta è motivata dai

bassi costi e ridotti spazi del microcontrollore. E’ lasciata al programmatore

la scelta di abilitare o meno il pieno supporto all’allocazione dinamica di

oggetti tramite la seguente dichiarazione:

#include <stdlib.h>

extern void * operator new(size_t size){return malloc(size);}

void operator delete(void * ptr) {free(ptr);}


Pag. 38

Override del metodo di sistema per ricavare data e ora

da un chip DS1307

Figura 12: L'orologio in chip al quarzo modello 1307 della Dallas

I requisiti del progetto per la gestione delle fascie orarie a giorni settimali,

impongono che il microcontrollore possa disporre dell’ora esatta anche in

condizioni di riavvio a seguito di mancanza di corrente elettrica.

Il chip DS1307 è di fatto un orologio al quarzo che, quando viene

alimentato costantemente con una tensione di 3V, è in grado di fornire un

valore numerico corrispondente all’ora esatta. Tale valore numerico viene

trasmesso digitalmente tramite protocollo I2C.

Il protocollo I2C ha la particolare caratteristica di permettere la

comunicazione con un elevato numero di dispositivo sui medesimi cavi di


Pag. 39

trasmissione. Ciò è permesso in virtù dell’assegnamento di un indirizzo,

corrispondente ad un byte univoco, ad ogni singola periferica. La

comunicazione è coordinata da un unico dispositivo master; nel caso di

questo progetto è lo stesso microcontrollore Arduino.

Il valore numerico trasmesso dal chip consiste nel numero di secondi

trascorsi a partire dal 1 Gennaio 1970 all’istante corrente.


Pag. 40

Debugging, gestione errori e difficoltà caratteristiche

dello sviluppo con un microcontrollore

Sviluppare codice sorgente per un microcontrollore presenta notoriamente

svariate difficoltà aggiuntive rispetto a quelle che si incontrano impiegando

un comune personal computer. Prima fra tutte è la mancanza di un monitor

dove poter visualizzare comodamente informazioni di debug e stack di

errori durante lo sviluppo. E’ evidente che non potendo fare a meno di una

qualunque segnalazione, perlomeno a seguito di certi cambiamenti di stato

critici, bisogna ricorre all’output prodotto da periferiche non propriamente

progettate per lo scopo. E’ il caso tipico dell’utilizzo di led per la

segnalazione luminosa e buzzer piezoceramici per la segnalazione acustica.

Nei primi è possibile variare la frequenza di lampeggio e nei secondi è

possibile variare la frequenza sonora, ottenendo toni alti o bassi.


Pag. 41

Figura 13: Diodi led e un buzzer piezo elettrico

Oltre alle problematiche finora descritte, nello sviluppo di codice sorgente

per un microcontrollore si aggiunge spesso anche la mancanza di poter

effettuare il debug del codice riga per riga. E, di conseguenza, non è

possibile esaminare il valore delle variabili durante l’esecuzione del

software.

Una delle sostanziali differenza fra un microcontrollore ed un personal

computer, seppure ad uso industriale, sta nelle pretese molto più rigide di

continuo up-time del primo rispetto al secondo. Infatti mentre per un

personal computer, solo per aggiornamenti indispensabili, sono previsti dei

fermi anche di svariati giorni nell’arco di un anno; da un microcontrollore,

quale può essere Arduino, si pretende che resti in funzione 24 ore su 24

senza soluzioni di continuità. In aggiunta nei microcontrollori, nemmeno a


Pag. 42

seguito di situazioni impreviste, si deve ferificare un errato accesso a zone

di memoria non corrette; in quanto, essendo comunemente usati linguaggi

di programmazione di basso livello, questo provocherebbe nel migliore dei

casi il reset del sistema.


Pag. 43

Gestione password, parsing e logica di ricerca

La centralina è stata configurata in modo tale da essere in grado di gestire

fino a 50 utenti. Tale dimensione deriva direttamente dalla capacità di

memorizzazione, pari a 4 KB, della Eeprom interna al microcontrollore

Arduino Mega.

Per rendere più difficile la memorizzazione della propria password di

accesso da parte di persone nelle immediate vicinanze, l’utente ha la

possibilità di effettuare pressioni casuali di vari tasti prima di inserire la

corretta sequenza di ingresso corrispondente alla propria password. Questa

modalità, comunemente chiamata “Rolling Code”, è molto diffusa nel

settore delle casseforti elettroniche.

Il riconoscimento della password viene effettuato su un buffer di caratteri

contenente le ultime 5 pressioni inviate dal keypad. La prima di operazione

di riconoscimento consiste nell’individuare l’indice della struttura dati in

memoria Eeprom contenente la password corrispondente, attraverso il

seguente metodo:

PwdData* Pwds::getPwdIndexByPwdNotDeletedd(String strPwd) {

PwdData* result=NULL;

for(int i=0; i<MAX_PWDS; i++) {

Pwd p = getPwd(i);

if(!p.isDeleted()) {


Pag. 44

PwdDataMatch pwdDataMatch = p.isPwd(strPwd);

if(pwdDataMatch.isMatch()) {

result = new PwdData(i, pwdDataMatch.getType());

break;

}

}

}

return result;

}

Come si può notare direttamente dal codice sorgente, le strutture dati

vengono scansionate dalla prima all’ultima, essendo memorizzate senza

seguire alcun tipo di ordine. Naturalmente la ricerca si interrompe quando

c’è uguale corrispondenza fra la password inserita dall’utente e quella

contenuta nella struttura dati in esame. Si noti che sono escluse le strutture

dati che sono state precedentemente marcate come cancellate.

Una volta stabilita la validità della password inserita, viene verificata

l’abilitazione all’ingresso nel giorno e nella fascia oraria corrente. Infatti

l’utente amministratore può decidere di limitare gli orari e i giorni di

accesso di tutti gli altri utenti.


Pag. 45

Figura 14: Diagramma delle classi per la gestione accessi via password a fasce

orarie


Pag. 46

Realizzazione hardware della centralina

Il circuto stampato della centralina è stato progettato al computer con un

software CAD dedicato. E’ prassi comune, anche per prototipi amatoriali,

delegare la realizzazione fisica dello stampato a una delle molte aziende

specializzate in questo tipo di stampa. In tal caso si è adoperato il software

usato nella progettazione per generare dei files di tipo “Gerber”. Questi

files vengono resi disponibili all’azienda di stampaggio e sono compatibili

industrialmente con le apparecchiature CAD/CAM del realizzatore.

Figura 15: Printed Circuit Board ospitante il microcontrollore Arduino Mega e

l’elettronica logica e di potenza


Pag. 47

La scheda a circuito stampato è stata disegnata per ospitare componenti

comunemente reperibili in commercio con modalità di montaggio a foro

passante.

Di seguito si riportano le immagini reali della centralina assemblata. Si

notino i seguenti elementi principali:

l’Arduino Mega inserito capovolto

la resistenza di potenza gialla che limita l’assorbimento del motore

la morsettiera di tipo “a castello”

i tre relay rettangolari di colore nero che fungono da Ponte H per il

motore e da “Open Collector” verso altri eventuali dispositivi esterni

Figura 16: Vista lato componenti della centralina


Pag. 48

Figura 17: Vista lato saldature della centralina


Pag. 49

Motoriduttore

E’ stato scelto il seguente motoriduttore a spazzole considerando:

la velocità media a coppia massima

i consumi di corrente

la bassa tensione continua, nel rispetto delle normative

la presenza di un encoder a effetto Hall integrato

l’elevato tempo di vita dichiarato dal produttore

Figura 18: Esploso6 e dimensioni del motoriduttore

6 Fonte: www.micromotorssrl.com

http://www.micromotorssrl.com/


Pag. 50

Figura 19: Dati tecnici del motoriduttore

Motoriduttore epicicloidale.

Albero di uscita supportato da due cuscinetti a sfera.

Soppressione disturbi con VDR sul collettore e condensatori.

Direzione di rotazione secondo polarità.

Può essere montato in ogni posizione.

Massimo carico radiale: 200N

Massimo carico assiale: 100N

Temperatura di esercizio: -20°C/60°C

Peso approssimativo: 385/485g


Pag. 51

Esploso di montaggio

Grazie all’utilizzo di Autocad Inventor è stato realizzare con precisione il

disegno tecnico del cover. In modo più semplice è stato riprodotto il

motoriduttore al fine di creare un chiaro esploso di montaggio.

Si desidera far notare la scelta dell’utilizzo una coppia conica in acciaio

Inox per trasferire il moto rotazionale del perno in uscita dal motoriduttore

al codolo del cilindro della serratura.

Figura 20: Esploso di montagggio del motoriduttore sul codolo


Pag. 52

Figura 21: L'ambiente di sviluppo integrato durante la progettazione del cover


Pag. 53

Possibili utilizzi del prototipo

Di seguito si vuole dare una panoramica dei possibili utilizzi del prototipo

in diversi scenari.


Pag. 54


Pag. 55

Figura 22: Possibili utilizzi del prototipo


Pag. 56

Analisi comparativa con i dispositivi commerciali

esistenti ed elementi di novità

Tutti i grandi produttori di serrature di livello internazionale stanno

aggiornando i loro cataloghi dei prodotti inserendo versioni motorizzate

delle serrature. I dispositivi motorizzati prevedono l’apertura e la chiusura

automatica di scrocco e mandate senza l’ausilio delle chiavi. Generalmente

i produttori considerano l’accessorio più comune per l’accesso il lettore di

impronta digitale, non valutando le molteplici difficoltà che tale dispositivo

può comportare:

necessaria presenza fisica dell’utente a cui si vuole garantire

l’accesso

combinazione difficoltosa di tasti per la memorizzazione

dell’impronta

problematica la modifica o la cancellazione di dati esistenti senza

ricorrere al collegamento di un personal computer o dispositivo

esterno di programmazione

In altri casi viene considerato come strumento di apertura il transponder

con le seguenti difficoltà e svantaggi:

necessaria presenza fisica dell’utente per consegna del dispositivo


Pag. 57

stesse problematiche della normale chiave quali il furto, lo

smarrimento, la duplicazione e l’ingombro

necessaria riconsegna del dispositivo nel caso di revoca dell’accesso

problematica la modifica o la cancellazione di dati esistenti senza

ricorrere al collegamento di un personal computer o dispositivo

esterno di programmazione

La tastiera è un ulteriore dispositivo per l’immissione delle credenziali di

accesso. Nei sistemi attualmente in commercio, le tastiere presentano i

seguenti limiti:

sono di dimensioni troppo ridotte per un comodo utilizzo in quanto

sono favoriti l’estetica e il design

le parti del sistema installate esternamente all’ingresso, tra cui la

tastiera, sono costituite di materiale plastico e quindi facilmente

danneggiabili

la fragile qualità del materiale di costruzione delle tastiere implica

nel tempo un’evidente usura dei tasti, andando ad evidenziare quelli

premuti per l’inserimento della password

l’installazione delle tastiere è prevista solo sulla struttura della porta

stessa e non sulle opere murarie adiacenti

Alcuni produttori hanno progettato le serrature motorizzate prevedendone

l’installazione solo su porte dedicate ad ospitare il dispositivo. Invece la


Pag. 58

totalità dei produttori obbliga il cliente, già in possesso di una porta

blindata, alla sostituzione della serratura e del cilindro per renderli

compatibili con il prodotto automatizzato.

Dal punto di vista operativo si possono riscontrare altre problematiche

riguardanti i prodotti attualmente in commercio. Le più frequenti sono:

la poca coppia in uscita al perno del motoriduttore che è causa di

chiusure incomplete su porte di vecchia costruzione con

accostamenti imprecisi

vari comportamenti errati del sistema nel caso di situazioni

impreviste come ad esempio nel caso di lenti accostamenti della

porta alla cassamatta. Tale situazione è conseguenza di una chiusura

errata delle mandate sui battenti a cui segue la mancata segnalazione

sonora all’utente o addirittura la riapertura automatica

le effrazioni al sensore porta non sono considerate dalla logica del

sistema. Spesso la manomissione del sensore viene rilevata dal

sistema come una apertura manuale della porta tramite chiave a cui

segue l’inopportuna apertura automatica della serratura

Il prototipo oggetto della tesi è dotato di una centralina elettronica

attraverso la quale vi è la possibilità di programmare le password di

accesso tramite il solo utilizzo della tastiera e con l’ausilio di segnali


Pag. 59

sonori. Il progetto è stato sviluppato in modo tale da poter impostare fino a

50 utenti personalizzabili con accesso a fasce orarie ristrette, giornaliere o

settimanali. Nessuna funzionalità di programmazione richiede il

collegamento della centralina con un personal computer esterno.

La tastiera è tra i componenti più importanti dell’intero prototipo e come

tale presenta le seguenti caratteristiche di rilievo:

manifattura in acciaio inox, tasti compresi

certificazione antivandalo e grado di protezione IP67

comunicazione digitale e criptata con la centralina e, di conseguenza,

anche operando direttamente sui fili il sistema non potrà ricevere un

comando di apertura

possibilità di bloccare la tastiera attraverso un pulsante interno

segnalatore acustico integrato

Prendendo in considerazione i difetti dei dispositivi attualmente reperibili

nel mercato, il prototipo di serratura motorizzata è stato fin dall’inizio

progettato inserendo i seguenti elementi di novità e miglioramento:

un potente motoriduttore da 2 Ncm in grado di aprire e chiudere le

mandate anche nelle più difficili situazioni

la serratura motorizzata è stata predisposta in modo tale da poter

essere installata ovunque, anche su cilindri già esistenti con codolo


Pag. 60

modalità Day&Night attivabile con un interruttore che permette di

inibire la chiusura automatica a seguito dell’accostamento della

porta. E’ utile negli uffici e negli ambienti a elevata frequentazione

funzionalità Rolling Code mediante la quale, a seguito di svariate

pressioni di tasti, il sistema verifica sempre solo gli ultimi 5 numeri

digitati. Ciò rende più difficoltosa la memorizzazione visiva da parte

di persone nelle immediate vicinanze

blocco della tastiera per 3 minuti a seguito di 30 digitazioni non

corrette. La tastiera si riattiva prima del tempo nel caso di aperture

manuali o pressioni del tasto di apertura dall’interno

possibilità di memorizzare fino a 5500 accessi con le relative data e

ora. Tutti questi dati sono scaricabili comodamente su una chiavetta

USB

Un altro elemento di novità nel prototipo è rappresentato dalla presenza di

un modulo GSM.


Pag. 61

Figura 23: Il modulo GSM adottato nel prototipo

Tale modulo integrato permette di abilitare le seguenti funzionalità:

apertura da remoto tramite squillo telefonico senza alcun costo in

quanto il modulo disconnette subito la chiamata non appena

identifica il chiamante tra gli autorizzati

facile programmazione, anche da remoto, tramite semplici messaggi

SMS contenti una password amministrativa


Pag. 62

anticoercizione utile in caso di richiesta forzata di apertura della

porta da parte di estranei in situazioni di pericolo. Infatti, inserendo il

proprio codice con l’ultimo numero incrementato di uno, la porta si

apre normalmente e in contemporanea il modulo GSM manda dei

messaggi preimpostati a degli utenti presenti in una lista di

emergenza.


Pag. 63

Bibliografia

Stan Gibilisco, Manuale pratico di elettrotecnica ed elettronica,

Hoepli, 2008

Michael Margolis, Arduino. Progetti e soluzioni, Hops, 2011

Muhammad Rashid, Elettronica di potenza. Dispositivi e circuiti,

Pearson, 2007

Cesare Rota, Programmare con C++, Hoepli, 2009

Salvatore Salpagno, Manuale di programmazione modulo GSM

TELxxC versione 20, Salpagno, 2011

Maik Schmidt, Il manuale di Arduino, Apogeo, 2011

Curtis Waguespack, Sean Dotson, Bill Bogan e Andrew Faix,

Mastering Autodesk Inventor 2009 and Autodesk Inventor LT 2009,

Autodesk, 2010

Arduino Learning, tratto da http://arduino.cc/en/Tutorial/HomePage

Arduino Reference, tratto da

http://arduino.cc/en/Reference/HomePage

Tutorial e specifiche del software Sprint Layout, tratto da

http://www.abacom-online.de/uk/html/sprint-layout.html

EAO Product Information S.series Lite, datasheet del keypad

http://arduino.cc/en/Tutorial/HomePage

http://arduino.cc/en/Reference/HomePage

http://www.abacom-online.de/uk/html/sprint-layout.html


Pag. 64

Datasheet del motoriduttore, tratto da

http://www.micromotorssrl.com/motor_e192/e192_pg.html

Datasheet di Arduino Mega, tratto da

http://arduino.cc/en/Main/ArduinoBoardMega

http://www.micromotorssrl.com/motor_e192/e192_pg.html

http://arduino.cc/en/Main/ArduinoBoardMega

Tesi Centralina Di Controllo Per Serrature ONLINE

Documents

Transcript of Tesi Centralina Di Controllo Per Serrature ONLINE