Controllo Remoto di una WebCam di Sorveglianza Relazione del progetto presentato come approfondimento per l’Esame di Stato.

Anno Scolastico 2003-2004 Realizzato da: Enrico Corneo, Alberto Filigura, Marco Giudici, Matteo Restelli

Classe 5 Indirizzo: Informatico –Telecomunicazioni Sezione: A

2

Motivazioni sulla scelta dell’approfondimento. Si è scelto di realizzare un sistema di video sorveglianza tramite una Webcam montata su due motori passo-passo controllabile da un qualsiasi computer remoto. Abbiamo scelto di realizzare un prototipo di una telecamera a controllo remoto perché ci ha permesso di ampliare le nostre conoscenze nel campo dell’elettronica e dell’informatica, utilizzando concetti tratti in classe con gli altri studenti, ma poi approfonditi e adattati al nostro caso. IL progetto è suddiviso nelle seguenti parti:

• Controllo motori Sviluppato da Enrico Corneo & Alberto Filigura

• Cattura frame video della webcam Sviluppato da Matteo Restelli

• Settaggio della webcam Sviluppato da Marco Giudici

• Pubblicazione del servizio on-line tramite pagina ASP Collaborazione tra il gruppo

Blocchi Logici

Spiegazione dettagliata dei punti sviluppati: Controllo motori Attività svolte:

• Analisi di fotocopie e fogli tecnici per apprendere il funzionamento della porta parallela, dell’elettronica di controllo del motore passo-passo, di alcuni componenti di questa scheda di controllo e del motore stesso.

• Prova per il funzionamento del motore tramite software già esistente. • Stesura di un programma di prova per far muovere il motore passo-passo con

richiamo però di funzioni di libreria già esistenti. • Raccolta di dati e immagini tramite oscilloscopio di alcuni segnali presenti nel

funzionamento dell’ elettronica di controllo del motore passo-passo. • Modifica del programma di prova per far muovere il motore passo-passo di un

determinato numero di gradi immessi dall’utente in senso orario e antiorario. • Realizzazione di una parte della meccanica in alluminio che servirà a far

muovere la webcam sia in orizzontale che in verticale.

3

• Aggiunta del secondo motore e implemento del codice in modo da permettere il movimento della webcam anche in verticale.

• Modifica del codice per fare in modo che i due motori si muovano all’interno di un certo range stabilito, evitando così nella fase di posizionamento ed anche durante l’utilizzo l’attorcigliamento dei cavi.

• Assemblaggio dei singoli programmi di gestione dei motori, di cattura del frame e del riconoscimento dell’immagine per il posizionamento iniziale, in un unico programma con quattro oggetti diversi.

• Installazione e assemblaggio di tutti i componenti necessari al movimento e controllo della webcam in una scatola elettrica, con costruzione del circuito di alimentazione e relativo cablaggio.

Inizializzazione e movimento motori Per sviluppare la parte di inizializzazione e movimento dei motori si è dovuto apprendere da fotocopie e fogli tecnici il funzionamento di alcuni componenti che serviranno al movimento e al controllo dei motori, quali la porta parallela, i circuiti di controllo dei motori passo-passo, alcuni componenti di questi circuiti di controllo e il funzionamento dei motori stessi. Funzionamento della porta parallela(LPT):

La porta parallela è utilizzata per interfacciare il pc ai circuiti di controllo dei motori passo-passo; essa è costituita da tre registri chiamati registro dati, registro di stato e registro di controllo. Il registro dati è un registro utilizzato in sola scrittura dal pc, il quale deposita su di esso i dati che successivamente verranno inviati ai circuiti di

controllo dei motori; il registro di stato è un registro di sola lettura utilizzato dal pc per ricevere i dati dall’esterno, ma nel nostro caso non verrà utilizzato in quanto non ci sono dati da trasmettere verso il pc; il registro di controllo è un registro che viene primariamente utilizzato in scrittura dal pc, nel nostro caso viene utilizzato per l’invio del segnale di strobe che serve per comunicare all’elettronica che il dato è stabile e che può venire processato. Elettronica di controllo micro-step driver:

Questo circuito permette di interfacciare i due motori passo-passo al pc mediante l’ utilizzo della porta parallela. Il circuito è isolato otticamente dal pc per motivi di sicurezza e permette di collegare fino a sei motori ad un’unica porta parallela. Con questo circuito si ha la possibilità di far compiere ai motori oltre che al passo intero e al mezzo passo anche dei micro passi, che nel nostro caso moltiplicherebbero fino a 64 il numero dei

4

passi del motore. Il motore orizzontale quindi, invece di compiere solamente 200 passi al giro sarà in grado di compierne 12800, mentre quello verticale 25600 anziché solamente 400. Questa modalità risulta vantaggiosa nel nostro caso, in quanto la webcam si potrà così muovere di un numero maggiore di passi all’interno di un singolo grado eliminando totalmente o quasi il funzionamento a scatti. Motori passo-passo:

I motori passo-passo sono motori che a differenza degli altri hanno anche la possibilità di mantenere fermo l’albero in una posizione di equilibrio oltre che girare in senso orario e antiorario. La rotazione avverrà solamente quando si invierà al motore, attraverso la scheda di controllo, una serie di impulsi di corrente secondo una determinata sequenza, in modo da far spostare per scatti successivi la posizione di partenza.

Un motore passo-passo è costituito da un rotore e da uno statore. Il rotore è formato da una coppia di ruote dentate affiancate e solidali all’albero e sono costituite da un nucleo magnetico; lo statore è formato anch’esso da piccoli denti che si affacciano a quelli del rotore ed è anche costituito da avvolgimenti che percorsi da corrente generano il campo magnetico. Registro a scorrimento HCT4094: L’ HCT4094 è un registro a scorrimento seriale a 8-stage capace di immagazzinare i dati connessi con ogni fase del segnale di ingresso seriale strobe con quelli di uscita paralleli del buffer 3-state. Le uscite parallele possono essere connesse direttamente alle linee del bus comune. Il dato è spostato ad ogni fronte di salita del segnale di clock(CP). I dati di ogni fase dello shift register sono trasferiti allo storage register quando il segnale d’ingresso strobe (STR) è a livello alto. I dati nello storage register appaiono in uscita ogni volta che il segnale di ingresso output enabled (OE) è a livello alto.

Dopo aver appreso alcune nozioni fondamentali sul funzionamento dei componenti che si dovevano utilizzare si è provato a far funzionare il motore passo-passo tramite l’utilizzo di un software già esistente. Durante queste prove si sono raccolte le immagini, e i relativi dati, delle forme d’onda riguardanti i segnali coinvolti nel funzionamento dell’elettronica di controllo dei motori, ossia del segnale di strobe, di clock e di data. Questi tre segnali provenienti dalla porta parallela del pc passano prima attraverso degli

optoisolatori, in modo da isolare il pc dal circuito di controllo dei motori, per poi giungere al registro di scorrimento HCT4094.

5

Grafici delle forme d’onda dei segnali coinvolti

Graf. 1 Visualizzazione della sequenza dei segnali. Il primo segnale dall’alto è il segnale di dato che verrà inserito nel registro un bit alla volta a ogni fronte di clock. Il secondo segnale è di strobe che serve per indicare che il caricamento del dato nel registro è finito. Il terzo invece è di clock in uscita dalla parallela, utilizzato per il riempimento del registro a scorrimento presente sulla PCB.

Graf. 2 Misurazione dell’ampiezza d’onda del segnale di dato. (4,69 V) Si può notare che la compatibilità di tale dato è di tipo TTL in rispetto dello standard SPI

Graf. 3 Misurazione dell’ampiezza d’onda del segnale di strobe. (4,69 V)

Graf. 4 Misurazione dell’ampiezza d’onda del segnale di clock. (4,84 V)

6

Graf. 5 Misurazione del tempo impiegato per ottenere il fronte di discesa del segnale. (1,3us)

Graf. 6 Misurazione del tempo impiegato per ottenere il fronte di salita del segnale. (2,1us) Si può notare che il tempo del fronte di salita è più lento di quello di discesa.

Dopodiché si è passati alla stesura del codice utilizzando VisualBasic come linguaggio di programmazione. La prima versione permetteva solamente di far muovere continuamente il motore in un verso, poi dopo alcune modifiche si poteva far muovere il motore di un determinato numero di gradi, immessi dall’utente, in senso orario o antiorario. Ulteriori modifiche sono state fatte quando si è aggiunto anche il secondo motore, quello sull’asse verticale; si è implementato il codice in modo da permettere il movimento di rotazione verticale e si è imposto anche alla webcam di muoversi all’interno di un range stabilito, così da poter evitare l’attorcigliamento dei cavi durante il movimento. Il codice è stato modificato nuovamente quando si sono assemblati in un unico codice i tre programmi di movimento dei motori, di cattura del frame e di riconoscimento della croce, così da ruotare fino al riconoscimento della croce e posizionarsi in modo da poter essere utilizzata dall’utente. Si è inoltre realizzato un telaio in alluminio a cui è stato fissato il motore verticale, sul quale è installata la webcam, che verrà montato sull’albero del motore orizzontale così che la webcam possa muoversi in senso orario e antiorario e verso l’alto e verso il basso.

7

Funzione Motore La funzione definitiva è stata studiata in modo da poter dichiarare due oggetti di tipo motore così da poter dedicare un motore ai movimenti verticali, e l’altro ai movimenti orizzontali. Il programma si compone delle seguenti funzioni:

• Funzione di inizializzazione che si occupa di trovare l’indirizzo della porta LPT, tramite la funzione di libreria dedicata interrogando il BIOS del computer in uso, e settare una variabile per il richiamo della porta stessa.

• Funzione MuoviMotore che si occupa di prendere come parametro il numero di

gradi inseriti dall’utente di cui deve far muovere il motore, controllare il verso di rotazione, chiamare la funzione di conversione da gradi in passi passandogli come parametro il modulo dei gradi inseriti ed infine chiamare la funzione MuoviMotoreDiPassi passandogli a) il numero di passi ritornati dalla funzione precedentemente chiamata b) il canale del motore c) il verso di rotazione d) la variabile contenete l’indirizzo della porta LPT.

• Funzione di conversione da gradi in passi che si occupa di prendere il

numero di gradi passatogli come parametro e il moltiplicatore dei passi al giro del motore ed eseguire la seguente operazione:

NumeroPassi = NumeroGradi * Moltiplicatore

infine restituire come valore di ritorno il numero di passi. NOTA: Ogni motore passo-passo può compiere duecento passi al giro o multipli di questo. Da qui la decisione di inserire un parametro chiamato appunto moltiplicatore.

• Funzione MuoviMotoreDiPassi che dopo aver preso in consegna tutti i

parametri passati dalla funzione precedente, si occupa di gestire il verso di rotazione calcolando il miglior spostamento, sia per quanto riguarta la brevità del percorso stesso, sia per evitare l’attorcigliamento dei cavi. Quindi di chiamare la funzione di libreria che fa eseguire il movimento al motore assegnato al canale passatogli in precedenza.

• Funzione MotorStepUnlock che si occupa di mandare sul canale della LPT

passatogli come parametro la sequenza si sblocco dei motori. La funzione esegue la funzione di libreria dedicata allo sblocco.

8

Funzione Cattura Frame Funzione che permette di catturare un frame (immagine) dalla webcam. Questa parte è formata da varie funzioni:

• Funzione di inizializzazione della classe: Si occupa essenzialmente di vedere se ,all’interno della directory,in cui sono presenti le pagine asp, è presente la directory temporanea, fondamentale perché è dove verranno salvate le immagini scattate.

• Una funzione principale (Cattura) che essenzialmente si occupa di: o Creare la finestra di cattura all’interno di un form. Questa finestra è

necessaria perché contribuirà al salvataggio dell’immagine su di un file. o Chiamare la funzione di connessione al driver o Chiamare la funzione di libreria (winapi32.dll) che permette la cattura di

un frame dalla webcam. o Chiamare la funzione di salvataggio del frame catturato in un file di tipo

jpg e salvare in una variabile il percorso del file. o Chiamare la funzione di libreria (winapi32.dll) di disconnessione dal

driver. Tale funzione sarà il metodo di classe chiamato dalla funzione principale di tutto il progetto. Si occuperà quindi di restituire il percorso del file contenente l’immagine scattata.

• Una funzione di connessione al driver: Si occupa essenzialmente di chiamare una funzione di libreria (winapi32.dll) che permette di connettersi al driver e di verificare se questa connessione è avvenuta correttamente oppure no.

• Una funzione di salvataggio del frame catturato:

Si occupa anch’essa di chiamare una funzione di libreria (winapi32.dll) che permette il salvataggio di un frame in un file di tipo bmp. Verrà poi chiamata, sempre in questa funzione, un’altra funzione che permetterà la conversione dal formato bmp al formato jpg.

• Una funzione di conversione dal formato BMP al formato JPG: Si occupa dell’effettiva conversione dal formato BMP al formato JPG. Utilizza alcune funzioni di libreria essenziali presenti nella libreria VIC32.dll. Questa conversione viene effettuata soprattutto per ridurre lo spazio utilizzato dalle immagini (immagini salvate con il formato BMP occupano molto più spazio di immagini salvate con il formato JPG). Una volta che il file .bmp viene convertito tale file verrà cancellato istantaneamente.

• Una funzione di cancellazione files: Si occupa di cancellare i files vecchi. Siccome il nome del file è standard (IMG+oralocale) ciò ci permette di confrontare l’ora in cui è stato salvato il file con l’ora attuale di sistema; il file, quindi, se risulta troppo vecchio viene cancellato opportunamente.

9

Funzione Settaggio Webcam Per settaggio della Webcam si intendono tutte le operazioni necessarie per trovare il punto di partenza da cui poter muovere la telecamera. In particolare il settaggio si occupa di analizzare le immagini scattate dalla webcam, utilizzata come macchina fotografica, per individuare una croce nera su sfondo bianco. Il programma che esegue tali operazioni è composto da diverse funzioni, le principali sono:

• Estrazione del codice RGB dall’immagine. Per estrarre il codice RGB di un’immagine utilizzo il metodo Point (x,y) fornito dall’oggetto PictureBox di Visual Basic.

• Calcolo dinamico della luminosità e saturazione media dell’immagine. Il codice RGB di ogni pixel viene convertito in codice HLS (Hue, Lightness, Saturation) e viene così calcolata la luminosità e la saturazione media dell’immagine.

• Confronto di ogni pixel dell’immagine, convertito in codice HSL, con il valore di luminosità media appena calcolato e riempimento di una matrice con pixel bianchi e neri

Ogni pixel viene confrontato con i valori di luminosità e saturazione appena calcolati e riempimento di una matrice bidimensionale con pixel bianchi e neri.

• Calcolo numero massimo di pixel neri di ogni riga e ogni colonna della matrice.

Per ogni riga e colonna della matrice vengono calcolati il numero di pixel neri e vengono memorizzati in due vettori.

• Individuazione dei picchi massimi di pixel neri e calcolo dello scostamento dal centro dell’immagine.

Vengono ricercati all’interno dei vettori i valori massimi e viene calcolato lo scostamento del valore massimo dal centro dell’immagine.

10

File INI È stato creato un progetto di Visual Basic con tre moduli di classe:

1. clsMirino settaggio webcam 2. clsMotori controllo motori 3. clsWebCam cattura frame

tutte e tre le classi possiedono proprietà e metodi, utilizzano parametri che possono essere modificati tramite un programma che scrive file di configurazione. Tali file di configurazione sono file.ini che vengono letti da ogni classe che imposta i propri parametri.

11

Pubblicazione del servizio on-line tramite pagina ASP Si è realizzato un sito essenzialmente in html & asp che permette di controllare la webcam da remoto. Vi sono 2 pagine asp che permettono il controllo:

• interfaccia.asp che è la pagina d’interfaccia vera e propria cioè la pagina dove viene visualizzata l’immagine e la pagina dove l’utente, attraverso particolari bottoni, può controllare la webcam da remoto. Questa pagina contiene infatti un form con dei bottoni che permette il passaggio dei dati (tramite il metodo “POST”) dalla pagina d’interfaccia alla pagina di collegamento.

Immagine Interfaccia

• collegamento.asp che permette di inviare i dati al processo che controlla la webcam. Questa pagina asp inizialmente riceve i dati (tramite il metodo Request.form) dalla pagina d’interfaccia. Una volta che li ha ricevuti li elabora e li tratta e crea una stringa da 5 caratteri da inviare al processo che controlla la webcam. Ci sono essenzialmente 5 trame

inviabili al processo di controllo:

o “DE!GR” DE=DESTRA o “SI!GR” SI=SINISTRA o “GI!GR” GI=GIU’ o “SU!GR” o zz!zz

GR= Gradi. Numero a 2 cifre. Può essere 10,20,45,90. zz!zz= Trama di default. Viene inviata la prima volta che ci si connette alla webcam. Con questa trama il processo di controllo capisce che è la prima volta che si effettua la connessione alla webcam quindi scatta l’immagine senza compiere alcun movimento.

Dopo aver quindi creato la trama da inviare, la pagina si occupa di dimensionare un oggetto che permette di connettersi tramite protocollo TCP/IP verso il processo di controllo; la pagina si occuperà di aprire una connessione (socket) sulla porta 20001 all’indirizzo locale (127.0.0.1). Questa porta è la porta su cui è in ascolto il processo di controllo. Dopo aver stabilito la connessione la pagina asp invierà la trama precedentemente creata; dopo aver inviato i dati rimarrà in ascolto e successivamente riceverà il percorso del file contenente l’immagine scattata. Il percorso del file verrà passato alla pagina d’interfaccia tramite una variabile di sessione. Infine la pagina si occuperà di indirizzare il browser (tramite il metodo Response.Redirect) verso la pagina d’interfaccia.

12

CODICE SORGENTE

CLASSI

• Motori • Webcam • Mirino • Controllo Camera

MODULI

• Declare • Main • Mirino • Motore • Ini • Webcam

FORM

• Mirino • WebCam • Winsock

FILE INI

13

CLASSI

14

MOTORI '############################################################################################### '# # '# Enrico Corneo & Alberto Filigura # '# # '# Anno scolastico 2003 - 2004 AREA DI PROGETTO # '# # '# Ambito Informatico - Eletttonico # '# # '# ActiveXMicroStep che tramite chiamate alla dll gestisce il motore passo passo # '# # '############################################################################################### 'Dichiaro che è obligatorio il dimensionameto delle variabili Option Explicit 'Dicharazione delle variabili globali Public iCanale As Integer 'Dichiarazione della variabile dedita a contenere il canale in uso Public iAngoloMassimo As Integer 'Dichiarazione della variabile dedita a contenere il numero di gradi massimo dell'angolo di rotazione del motore Public iAngoloMinimo As Integer 'Dichiarazione della variabile dedita a contenere il numero di gradi minimo dell'angolo di rotazione del motore Public iMoltiplicatoreStep As Integer 'Dichiarazione della variabile dedita a contenere il fattore di moltiplicazione degli step per il motore Public dPosizione As Double 'Dichiarazione della variabile che si ricorda l'ultima posizione 'Dichiarazione delle costanti Const TIME = 1 'In millesimi di secondo Costante di tempo che trascorre tra un passo e l'altro 'Const iTempoSleep = 20 'Numero passi che vengono effettuati prima di fare lo Sleep Dim iTempoSleep As Integer

15

'############################################################################################### '# # '# Funzione inizialize della classe ActiveXMicroStep # '# # '# Questa funzione si deve occupare di attivare tutto ciò che riguarda l'Hardware in parti- # '# colare deve chiamare la funzione di libreria VVIO_CD4094_Inizialize(iLpt, lAddrUse). # '# Insieme all'inizializzazione della PCB deve recuperare gli indirizzi delle LPT dal bios con # '# la funzione di libreria VVIO_LPT_GetLptFromBios(lAddr0, lAddr1, lAddr2) e di bloccare la # '# porta che si intende usare con la funzione VVIO_LPT_Lock(iLpt) # '# # '############################################################################################### Private Sub Class_Initialize() Leggi_FileINI 'Nella prima esecuzione setto dPosizione a 0 If bPrimaEsecuzione Then dPosizione = 0 Exit Sub End If bPrimaEsecuzione = True 'Rendo vera la variabile booleana che controlla se è la prima volta che viene eseguito il programma 'Dichiarazioni delle variabili locali Dim iLptError As Integer 'Variabile che contiene l'errore restituito dalla funzione VVIO_LPT_GetLptFromBios Dim iErrorLptLock As Integer 'Variabile che contiene l'errore restituito dalla funzione VVIO_LPT_Lock Dim iErrorLptInizialize As Integer 'Variabile che contiene l'errore restituito dalla funzione VVIO_CD4094_Inizialize Dim lAddr0 As Long 'Variabile che contiene l'indirizzo della prima Lpt Dim lAddr1 As Long 'Variabile che contiene l'indirizzo della seconda Lpt Dim lAddr2 As Long 'Variabile che contiene l'indirizzo della terza Lpt Dim lAddrUse As Long 'Variabile che contiene l'indirizzo della Lpt che è utilizzata

16

'Prendo l'elenco degli indirizzi delle lpt sul pc iLptError = VVIO_LPT_GetLptFromBios(lAddr0, lAddr1, lAddr2) 'Calcolo quale porta intendo utilizzare If lAddr0 <> 0 Then iLpt = 1 lAddrUse = lAddr0 Else If lAddr1 <> 0 Then iLpt = 2 lAddrUse = lAddr1 End If End If 'Blocco la Lpt che utilizzo iErrorLptLock = VVIO_LPT_Lock(iLpt) 'Inizializzo la comunicazione tra PC e PCB passando il numero della porta che utilizzo e il suo indirizzo fisico iErrorLptInizialize = VVIO_CD4094_Inizialize(iLpt, lAddrUse) End Sub '############################################################################################### '# # '# Funzione di avvio dei motori della classe ActiveXMicroStep # '# # '# Questa funzione si deve occupare di controllache in che vero il motore deve girare, e di # '# chiamare la funzione che provvederà a far girare il motore del numero di passi stabilito. # '# # '############################################################################################### Public Function MuoviMotore(dNumeroGradi As Double) Dim iNumeroPassi As Integer 'Variabile dedita a contenere il numero di step da fare Dim iError As Integer 'Variabile dedita a ricevere l'eventuale errore Dim iVerso As Integer 'Variabile dedita a contenere il verso di rotazione

17

Dim dNuovaPosizione As Double 'Variabile dedita a contenere la posizione a cui si deve arrivare 'Controllo se il numero di gradi di cui mi devo muovere è pari a zero allora esco dalla funzione If (dNumeroGradi = 0) Then Exit Function End If 'Controllo e eseguo lo spostamento richiesto dNuovaPosizione = (dPosizione + dNumeroGradi) Mod 360 If dNuovaPosizione < iAngoloMinimo Then dNuovaPosizione = iAngoloMinimo ElseIf dNuovaPosizione > iAngoloMassimo Then dNuovaPosizione = iAngoloMassimo End If dNumeroGradi = dNuovaPosizione - dPosizione dPosizione = dNuovaPosizione 'Controllo il verso If dNumeroGradi < 0 Then iVerso = 1 Else iVerso = -1 End If 'Chiamo la funzione che mi converte il numero di gradi in passi iNumeroPassi = ConversioneGradiPassi(Abs(dNumeroGradi)) 'Chiamo la funzione che muove il motore iError = MuoviMotoreDiPassi(iNumeroPassi, iLpt, iCanale, iVerso, TIME) End Function

18

'############################################################################################### '# # '# Funzione di movimento del motore della classe ActiveXMicroStep # '# # '# Questa funzione si deve occupare di chiamare la funzione di libreria che fa muovere il # '# motore dei passi che gli sono stati indicati dalla funzione che ha invocato quest'ultima. # '# # '############################################################################################### Private Function MuoviMotoreDiPassi(iNumeroPassi As Integer, iLpt As Integer, iCh As Integer, iVerso As Integer, iTime As Long) Dim iError As Integer 'Variabile dedicata al ritorno di un eventuale errore Dim icont As Integer 'Contatore per la scansione dei passi Dim iSleep As Integer 'Moltiplico il numero dei passi per il moltiplicatore iNumeroPassi = iNumeroPassi * iMoltiplicatoreStep 'Ciclo che fa muovere di iNumeroPassi il motore For icont = 0 To iNumeroPassi 'Chiamata alla funzione di libreria per far muovere un motore di iNumeroPassi iError = VVIO_CD4094_NextStepBipolar(iLpt, iCh, iVerso, 1) 'Aspetto un certo periodo di tempo prima di rieseguire il ciclo If iSleep > iTempoSleep Then Sleep iTime iSleep = 0 Else iSleep = iSleep + 1 End If DoEvents Next

19

End Function '############################################################################################### '# # '# Funzione di conversione dei gradi in passi della classe ActiveXMicroStep # '# # '# Questa funzione si deve occupare di convertire il numero di gradi passatogli in passi. # '# Il valore trovato verrà passato come valore di ritorno. # '# # '############################################################################################### Private Function ConversioneGradiPassi(dNumeroGradi As Double) As Integer Dim iNumeroPassi As Integer 'Variabile dedita a contenere il numero di step da fare 'Eseguo il conto necessario e lo metto nella variabile apposita. iNumeroPassi = dNumeroGradi * (12800# / 360#) 'Passo come valore di ritorno il contenuto della variabile appena riempita ConversioneGradiPassi = iNumeroPassi End Function '############################################################################################### '# # '# Funzione Sblocca della classe ActiveXMicroStep # '# # '# Questa funzione si deve occupare di disattivare tutto ciò che riguarda l'Hardware in parti- # '# colare deve chiamare la funzione di libreria VVIO_CD4094_18245(iLpt, iCont, 0, 0, 1). # '# Deve fare una scansione per canale e far uscire dalla Lpt il segnale di arresto. # '# # '###############################################################################################

20

Public Sub MotorStepUnlock() Dim iError As Integer 'Variabile dedicata al ritorno di un eventuale errore 'Chiamata alla funzione della dll che arresta tutto iError = VVIO_CD4094_18245(iLpt, iCanale, 0, 0, 1) End Sub Private Function Leggi_FileINI() Dim sPercorsoINI As String Dim ret As String Dim RetLen sPercorsoINI = App.Path sPercorsoINI = sPercorsoINI & "\config.ini" ret = Space$(255) RetLen = GetPrivateProfilestring("CONFIGURAZIONE", "ITIMESLEEP", "", ret, Len(ret), sPercorsoINI) ret = Left$(ret, RetLen) iTempoSleep = Val(ret) End Function

21

WEBCAM '####################################################### '# # '# Cattura di un frame da webcam, salvataggio del # '# frame in un file e successiva conversione da bmp # '# a jpg. Le immagini scattate verranno salvate # '# opportunamente in una cartella temporanea interna # '# alla directory dove è presente l'intero programma # '# # '####################################################### 'Const BASEPATH = "C:\Inetpub\wwwroot\bbb\temp\" Dim BASEPATH As String Dim hcapwnd As Long Private Sub Class_Initialize() Leggi_FileINI 'Creazione della directory \temp se non esiste 'sPercorsoAttuale = App.Path If (Dir(BASEPATH, vbDirectory) = "") Then MkDir (BASEPATH) End Sub Public Function Cattura() As String Dim sPercorso As String frmWebcam.Hide 'Cancellazione dei files vecchi nella directory Call CancellaFiles 'Creazione della finestra di cattura hcapwnd = capCreateCaptureWindow("VB CAP WINDOW", WS_CHILD Or WS_VISIBLE, 0, 0, 160, 120, frmWebcam.hWnd, 0) 'Chiamata della funzione di connessione al driver. Call DriverConnect(hcapwnd) 'chiamata della funzione che cattura il frame. Call capGrabFrame(hcapwnd) 'Chiamata della funzione relativa al salvataggio del frame in un file bmp sPercorso = SalvaFrame(hcapwnd) Cattura = sPercorso 'Disconnessione dal driver retVal = capDriverDisconnect(hcapwnd)

22

Unload frmWebcam End Function Public Function Disconnetti() As Boolean 'Funzione per disconnettersi dal driver Disconnetti = capDriverDisconnect(hcapwnd) End Function Private Sub DriverConnect(ByVal hcapwnd As Long) Const CAP_STRING_MAX As Long = 128 Dim retVal As Boolean Dim iIndice As Integer iIndice = 0 'Connessione al driver retVal = capDriverConnect(hcapwnd, iIndice) If retVal = True Then Debug.Print ("Connessione al driver riuscita") Else Debug.Print ("Connessione al driver non riuscita") End If End Sub Private Function SalvaFrame(hcapwnd As Long) As String Dim sFileName As String Dim retVal As Boolean Dim sPercorso As String sFileName = BASEPATH & "img" & TIME & ".bmp" 'Salvataggio in un file bmp del frame retVal = capFileSaveDIB(hcapwnd, sFileName) 'Chiamate della funzione di conversione da bmp a jpg sPercorso = ConversioneJPG(sFileName) SalvaFrame = sPercorso End Function Private Function ConversioneJPG(FileName As String) As String Dim sPercorso As String Dim objFSO As FileSystemObject Set objFSO = New FileSystemObject Dim tmpimage As imgdes Dim tmp2image As imgdes Dim rcode As Long Dim quality As Long

23

Dim vbitcount As Long Dim bdat As BITMAPINFOHEADER Dim jpg_fname As String jpg_fname = BASEPATH & "img" & TIME & ".jpg" quality = 75 rcode = bmpinfo(FileName, bdat) If (rcode <> NO_ERROR) Then MsgBox "Il file non riesce ad essere trovato", 0, "ERRORE!" Exit Function End If vbitcount = bdat.biBitCount If (vbitcount >= 16) Then vbitcount = 24 End If rcode = allocimage(tmpimage, bdat.biWidth, bdat.biHeight, vbitcount) If (rcode <> NO_ERROR) Then MsgBox "Memoria non sufficiente", 0, "ERRORE!" Exit Function End If ' Load image rcode = loadbmp(FileName, tmpimage) If (rcode <> NO_ERROR) Then freeimage tmpimage MsgBox "Il file non riesce ad essere caricato", 0, "ERRORE!" Exit Function End If If (vbitcount = 1) Then rcode = allocimage(tmp2image, bdat.biWidth, bdat.biHeight, 8) If (rcode = NO_ERROR) Then rcode = convert1bitto8bit(tmpimage, tmp2image) freeimage tmpimage End If

24

End If 'Chiamata della funzione di salvataggio del file JPG rcode = savejpg(jpg_fname, tmpimage, quality) freeimage tmpimage 'Cancellazione del file .bmp che contiene il frame scattato objFSO.DeleteFile (FileName) 'sPercorso = App.Path 'sPercorso = sPercorso & "\" & jpg_fname ConversioneJPG = jpg_fname End Function Public Function CancellaFiles() Dim bCancella As Boolean Dim sNomeFile As String Dim sNome As String Dim Cartella As Folder Dim file As file Dim sPercorsoCartella As String Dim objFSO As FileSystemObject Set objFSO = New FileSystemObject sPercorsoCartella = BASEPATH Set Cartella = objFSO.GetFolder(sPercorsoCartella) For Each file In Cartella.Files sNomeFile = file.Name sPercorsoFile = file.Path bCancella = EstraiDati(sNomeFile) If bCancella = True Then objFSO.DeleteFile (sPercorsoFile) End If Next file End Function Private Function EstraiDati(sNome As String) As Boolean Dim bCancella As Boolean Dim sOraImg As String Dim sMinutiImg As String

25

Dim sSecondiImg As String Dim sTempoAttuale As String Dim sOraAttuale As String Dim sMinutiAttuale As String Dim sSecondiAttuale As String sNome = Mid(sNome, 4, 8) sOraImg = Mid(sNome, 1, 2) sMinutiImg = Mid(sNome, 4, 2) sTempoAttuale = TIME sOraAttuale = Mid(sTempoAttuale, 1, 2) sMinutiAttuale = Mid(sTempoAttuale, 4, 2) EstraiDati = Confronto(sOraImg, sMinutiImg, sOraAttuale, sMinutiAttuale) End Function Private Function Confronto(sOraImg As String, sMinutiImg As String, sOraAttuale As String, sMinutiAttuale As String) As Boolean If (sOraImg < sOraAttuale) Then Confronto = True Else If (sMinutiImg < (sMinutiAttuale - 5)) Then Confronto = True Else Confronto = False End If End If End Function Private Function CancellaFile() Dim bCancella As Boolean Dim sNomeFile As String Dim sNome As String Dim Cartella As Folder Dim file As file Dim sPercorsoCartella As String Dim sPercorsoFile As String Dim objFSO As FileSystemObject

26

Set objFSO = New FileSystemObject sPercorsoCartella = BASEPATH Set Cartella = objFSO.GetFolder(sPercorsoCartella) For Each file In Cartella.Files sNomeFile = file.Name sPercorsoFile = file.Path bCancella = EstraiDati(sNomeFile) If bCancella = True Then objFSO.DeleteFile (sPercorsoFile) End If Next file End Function Private Sub Class_Terminate() Disconnetti End Sub Private Function Leggi_FileINI() Dim sPercorsoINI As String Dim ret As String Dim RetLen sPercorsoINI = App.Path sPercorsoINI = sPercorsoINI & "\config.ini" ret = Space$(255) RetLen = GetPrivateProfilestring("CONFIGURAZIONE", "BASEPATH", "", ret, Len(ret), sPercorsoINI) ret = Left$(ret, RetLen) BASEPATH = ret End Function

27

MIRINO Option Explicit Const HLSMAX = 240 'valore massimo del codice HLS Const RGBMAX = 255 'valore massimo del codice RGB Const RIGHE = 288 'costante con la dimensione delle Righe Const COLONNE = 352 'costante con la dimensione delle Colonne 'Const LUMINOSITà = 0.6 'costante per la luminosità dell'immagine 'Const SOGLIAPICCO = 10 'costante per il confronto tra i picchi di pixel neri Const UNDEFINED = HLSMAX / 2 * 3 Dim LUMINOSITà As Double Dim SOGLIAPICCO As Integer Dim dValMedioLumin As Double 'memorizza il valore medio LUMINOSITà Dim dValMedioSatur As Double 'memorizza il valore medio SATURAZIONE Dim Photo(RIGHE, COLONNE) As Capture Dim lIndexPhoto As Long Dim mtxBiancoNero(RIGHE, COLONNE) As Boolean Dim Verticale(COLONNE) As Long 'memorizza il numero di pixel neri in verticale Dim Orizzontale(RIGHE) As Long 'memorizza il numero di pixel neri in orizzontale Private strImmagine As String Public bRisposta As Boolean 'croce trovata Vero o Falso? Private iXBar As Integer 'coordinata x Private iYBar As Integer 'coordinata y Private iXMax As Integer 'coordinata x Private iYMax As Integer 'coordinata y Public iX As Integer Public iY As Integer Public DEBUGGER As Boolean 'Variabile per l'attivazione della modalità debugger Dim Myfrm As New frmMirino 'Dim frmGrafic As New frmGrafico

28

Public Sub Analizza(Percorso As String) 'strImmagine = Percorso Myfrm.picImmagine.Picture = LoadPicture(Percorso) Scansione_Immagine Media 'Media LUMINOSITà e saturazione Confronto Conta iX = iXMax iY = iYMax Crea_Grafico_Verticale Crea_Grafico_Orizzontale Stampa_Valori End Sub Private Sub Confronto() Svuota_Matrice Dim c As Integer, r As Integer 'indici della matrice For c = 0 To COLONNE - 1 For r = 0 To RIGHE - 1 If Photo(r, c).lLuminosità > (dValMedioLumin * LUMINOSITà) Then mtxBiancoNero(r, c) = True 'picMatrice.PSet (c, r), RGB(255, 255, 255) Else mtxBiancoNero(r, c) = False 'picMatrice.PSet (c, r), RGB(0, 0, 0) End If Next Next End Sub

29

Private Sub Svuota_Matrice() Dim i As Integer For i = 0 To COLONNE Verticale(i) = 0 Next For i = 0 To RIGHE Orizzontale(i) = 0 Next Dim c As Integer, r As Integer For c = 0 To COLONNE - 1 For r = 0 To RIGHE - 1 mtxBiancoNero(r, c) = False Next Next End Sub Private Function Calcolo_Coordinate(dNumeratore As Double, dDenominatore As Double) As Integer Calcolo_Coordinate = Int(dNumeratore / dDenominatore) End Function Private Function Calcolo_Max(ByRef iVMax As Integer, ByRef iOMax As Integer, ByRef c As Integer, ByRef r As Integer) Dim v As Integer 'indice verticale Dim o As Integer 'indice orizzontale For c = 0 To COLONNE - 1 For r = 0 To RIGHE - 1 If mtxBiancoNero(r, c) = False Then Verticale(v) = Verticale(v) + 1 If iVMax < Verticale(v) Then iVMax = Verticale(v) iXMax = v End If Next v = v + 1 Next For r = 0 To RIGHE - 1

30

For c = 0 To COLONNE - 1 If mtxBiancoNero(r, c) = False Then Orizzontale(o) = Orizzontale(o) + 1 If iOMax < Orizzontale(o) Then iOMax = Orizzontale(o) iYMax = o End If Next o = o + 1 Next End Function Private Function Calcolo_Scostamento(ByVal iVMax As Integer, ByVal iOMax As Integer, _ ByVal dVMedia As Double, ByVal dOMedia As Double, ByRef x As Integer, ByRef y As Integer) If (iVMax > (SOGLIAPICCO * dVMedia)) And (iOMax > (SOGLIAPICCO * dOMedia)) Then bRisposta = True ' iX = (((COLONNE / 2) - iX) * 100) / COLONNE ' iY = (((RIGHE / 2) - iY) * 100) / RIGHE Else bRisposta = False End If x = ((COLONNE / 2) - x) y = ((RIGHE / 2) - y) If Abs(x) > 100 Or Abs(y) > 100 Then bRisposta = False End If End Function Private Function Crea_Grafico_Orizzontale() Dim iContX As Integer Dim iContY As Integer Myfrm.picGrafSpettOriz.Cls For iContX = 0 To RIGHE For iContY = 0 To Orizzontale(iContX) Myfrm.picGrafSpettOriz.PSet (iContY, iContX), &H80000008

31

Next Next End Function Private Sub Crea_Grafico_Verticale() Dim iContX As Integer Dim iContY As Integer Myfrm.picGrafSpettVert.Cls For iContX = 0 To COLONNE For iContY = 0 To Verticale(iContX) Myfrm.picGrafSpettVert.PSet (iContX, iContY), &H80000008 Next Next End Sub Private Sub Conta() Dim c As Integer Dim r As Integer Dim v As Integer 'indice verticale Dim o As Integer 'indice orizzontale Dim iVMax As Integer 'valore max tra Verticale Dim iOMax As Integer 'valore max tra Orizzontale Dim x As Integer, y As Integer Dim dOMedia As Double 'media del numero di pixel neri in orizzontale Dim dVMedia As Double 'media del numero di pixel neri in verticale Dim dVSomma As Double 'somma di tutti i pixel neri del verticale Dim dOSomma As Double 'somma di tutti i pixel neri dell'orizzontale Dim dONumeratore As Double 'numeratore per calcolo della coordinata X Dim dVNumeratore As Double 'numeratore per calcolo della coordinata Y Calcolo_Max iVMax, iOMax, x, y Calcolo_Somma_Pixel_Neri dVSomma, dOSomma, dONumeratore, dVNumeratore 'chiamata funzione _ di elaborazione dei dati per calcolo della coordinata tramite calcolo del bericentro della figura 'COORDINATA X

32

iXBar = Calcolo_Coordinate(dONumeratore, dOSomma) 'COORDINATA Y iYBar = Calcolo_Coordinate(dVNumeratore, dVSomma) dOMedia = dOSomma / COLONNE dVMedia = dVSomma / RIGHE Calcolo_Scostamento iVMax, iOMax, dVMedia, dOMedia, iXMax, iYMax End Sub Private Sub Calcolo_Somma_Pixel_Neri(ByRef dVSomma As Double, ByRef dOSomma As Double, _ dONumeratore As Double, ByRef dVNumeratore As Double) Dim v As Integer 'indice verticale Dim o As Integer 'indice orizzontale For o = 0 To RIGHE - 1 dOSomma = dOSomma + Orizzontale(o) ' calcolo del denominatore per coordinata X dONumeratore = dONumeratore + (Orizzontale(o) * (o + 1)) 'calcolo numeratore per la coodinata X Next For v = 0 To COLONNE - 1 dVSomma = dVSomma + Verticale(v) 'calcolo del denominatore per coordinata Y dVNumeratore = dVNumeratore + (Verticale(v) * (v + 1)) 'calcolo numeratore per la coordinata Y Next End Sub Private Sub Media() Dim iColonna As Integer Dim iRiga As Integer For iColonna = 0 To COLONNE - 1 For iRiga = 0 To RIGHE - 1 dValMedioLumin = dValMedioLumin + Photo(iRiga, iColonna).lLuminosità dValMedioSatur = dValMedioSatur + Photo(iRiga, iColonna).lSaturazione Next Next dValMedioLumin = dValMedioLumin / (CDbl(RIGHE) * CDbl(COLONNE))

33

dValMedioSatur = dValMedioSatur / (CDbl(RIGHE) * CDbl(COLONNE)) End Sub Private Sub RGB2HLS(ByVal r As Byte, ByVal G As Byte, ByVal B As Byte, ByRef H As Double, _ ByRef L As Double, ByRef s As Double) Dim Max As Double Dim Min As Double Dim Rdelta As Double Dim Gdelta As Double Dim Bdelta As Double ' Get maximum value between R, G and B. If (r > G) Then Max = r Else Max = G If (Max < B) Then Max = B ' Get minimum value between R, G and B. If (r < G) Then Min = r Else Min = G If (Min > B) Then Min = B L = ((Max + Min) * HLSMAX + RGBMAX) / (2 * RGBMAX) ' Luminance If (Max = Min) Then ' Color is gray. s = 0 H = UNDEFINED Else ' Calculate Saturation. If (L <= HLSMAX / 2) Then s = ((Max - Min) * HLSMAX + (Max + Min) / 2) / (Max + Min) Else s = ((Max - Min) * HLSMAX + (2 * RGBMAX - Max - Min) / 2) / (2 * RGBMAX - Max - Min) End If ' Calculate Hue. Rdelta = ((Max - r) * HLSMAX / 6 + (Max - Min) / 2) / (Max - Min) Gdelta = ((Max - G) * HLSMAX / 6 + (Max - Min) / 2) / (Max - Min) Bdelta = ((Max - B) * HLSMAX / 6 + (Max - Min) / 2) / (Max - Min) If (r = Max) Then H = Bdelta - Gdelta ' between yellow and magenta.

34

ElseIf (G = Max) Then H = (HLSMAX / 3) + Rdelta - Bdelta ' between cyan and yellow. Else ' (B = max) H = 2 * HLSMAX / 3 + Gdelta - Rdelta ' between magenta and cyan. End If ' Convert Hue to degree in range [0..360]. If (H < 0) Then H = H + HLSMAX If (H > HLSMAX) Then H = H - HLSMAX End If End Sub Private Sub Scansione_Immagine() Dim iRiga As Integer Dim iColonna As Integer 'Scansione dell'immagine per estrazione dei pixel For iColonna = 0 To COLONNE - 1 For iRiga = 0 To RIGHE - 1 Photo(iRiga, iColonna).lRGB = Myfrm.picImmagine.Point(iColonna, iRiga) Separa_R_G_B iRiga, iColonna 'SEPARAZIONE R G B Next Next End Sub Private Function Separa_R_G_B(ByVal iRiga As Long, ByVal iColonna As Long) Dim lR As Long Dim lG As Long Dim lB As Long lR = (Photo(iRiga, iColonna).lRGB And &HFF) lG = (Photo(iRiga, iColonna).lRGB And &HFFFF&) \ &H100 lB = (Photo(iRiga, iColonna).lRGB \ &H10000) RGB2HLS lR, lG, lB, Photo(iRiga, iColonna).lTonalità, Photo(iRiga, iColonna).lLuminosità, _ Photo(iRiga, iColonna).lSaturazione End Function

35

Private Sub Class_Initialize() Load Myfrm Myfrm.Visible = True Leggi_FileINI End Sub Private Sub Stampa_Valori() Myfrm.txtRisposta.Text = bRisposta If bRisposta Then Myfrm.txtX.Text = iX Myfrm.txtY.Text = iY End If End Sub 'Public Function Visualizza_Immagine(Percorso As String) ' ' Myfrm.picImmagine.Picture = LoadPicture(Percorso) ' Myfrm.txtFileName = Percorso ' 'End Function Private Function Leggi_FileINI() Dim sPercorsoINI As String Dim ret As String Dim RetLen sPercorsoINI = App.Path sPercorsoINI = sPercorsoINI & "\config.ini" ret = Space$(255) RetLen = GetPrivateProfilestring("CONFIGURAZIONE", "LUMINOSITà", "", ret, Len(ret), sPercorsoINI) ret = Left$(ret, RetLen) LUMINOSITà = Val(ret) ret = Space$(255) RetLen = GetPrivateProfilestring("CONFIGURAZIONE", "SOGLIAPICCO", "", ret, Len(ret), sPercorsoINI) ret = Left$(ret, RetLen) SOGLIAPICCO = Val(ret) End Function

36

Public Sub Chiudi() Unload Myfrm End Sub

37

CONTROLLO CAMERA Option Explicit Public sPercorsoFile As String Public sBloccoNord As String Public sBloccoSud As String Public sBloccoOvest As String Public sBloccoEst As String 'Const PRECISIONE = 15 'precisione in pixel 'Const MUOVITANTO = 10 'Const MUOVIPOCO = 1 'Const ATTESA = 10 Dim PRECISIONE As Integer Dim MUOVITANTO As Double Dim MUOVIPOCO As Double Dim ATTESA As Integer Private Mirino As New clsMirino Private Capture As New clsWebcam Public motVerticale As New clsMotore Public motOrizzontale As New clsMotore Private iVersoArrivo As Integer Private iNumeroPassi As Integer Public Sub Chiudi() Capture.Disconnetti motOrizzontale.MotorStepUnlock motVerticale.MotorStepUnlock End Sub Public Sub Init() Leggi_FileINI Posizionamento End Sub

38

Public Function MuovieScatta(iDirezione As Integer, iGradi As Integer) As String Dim sStringa As String If iDirezione = 0 Then motVerticale.MuoviMotore CDbl(iGradi) If iDirezione = 1 Then motVerticale.MuoviMotore CDbl(iGradi) If iDirezione = 2 Then motVerticale.MuoviMotore CDbl(iGradi * (-1)) If iDirezione = 3 Then motOrizzontale.MuoviMotore CDbl(iGradi) If iDirezione = 4 Then motOrizzontale.MuoviMotore CDbl(iGradi * (-1)) 'MuovieScatta = Sleep 1000 Dim sFileName As String sFileName = Capture.Cattura frmWinsock.picImmagine = LoadPicture(sFileName) MuovieScatta = sFileName If motOrizzontale.dPosizione = motOrizzontale.iAngoloMinimo Then sBloccoOvest = 1 Else sBloccoOvest = 0 End If If motOrizzontale.dPosizione = motOrizzontale.iAngoloMassimo Then sBloccoEst = 1 Else sBloccoEst = 0 End If If motVerticale.dPosizione = motOrizzontale.iAngoloMassimo Then sBloccoNord = 1 Else sBloccoNord = 0 End If

39

If motVerticale.dPosizione = motOrizzontale.iAngoloMinimo Then sBloccoSud = 1 Else sBloccoSud = 0 End If End Function Private Function Posizionamento() 'Capture.CancellaDirectory 'Setto i motori con angoli di blocco che consentano il posizionamento With motVerticale .iCanale = 2 .MotorStepUnlock Sleep 1000 .iMoltiplicatoreStep = 2 .iAngoloMassimo = 180 .iAngoloMinimo = 0 .MuoviMotore 85 End With With motOrizzontale .iCanale = 1 .MotorStepUnlock .iMoltiplicatoreStep = 1 .iAngoloMassimo = 200 .iAngoloMinimo = -200 End With iNumeroPassi = 0 PosizionamentoGrosso If Mirino.bRisposta Then PosizionamentoFine

40

Else motOrizzontale.MotorStepUnlock motVerticale.MotorStepUnlock End End If 'Setto i nuovi angoli di blocco della rotazione With motVerticale .iCanale = 2 .iMoltiplicatoreStep = 2 .iAngoloMassimo = 150 .iAngoloMinimo = 30 End With With motOrizzontale .iCanale = 1 .dPosizione = 0 .iMoltiplicatoreStep = 1 .iAngoloMassimo = 120 .iAngoloMinimo = -120 End With Mirino.Chiudi frmWinsock.picImmagine = LoadPicture(Capture.Cattura) End Function Private Function PosizionamentoGrosso() Mirino.Analizza Capture.Cattura If Mirino.bRisposta Then iVersoArrivo = 1 Exit Function End If

41

Do While iNumeroPassi <= 180 motOrizzontale.MuoviMotore MUOVITANTO iNumeroPassi = iNumeroPassi + MUOVITANTO Sleep ATTESA Mirino.Analizza Capture.Cattura If Mirino.bRisposta Then iVersoArrivo = 1 Exit Function End If Loop motOrizzontale.MuoviMotore -180 Mirino.Analizza Capture.Cattura iNumeroPassi = 0 Do While ((Not Mirino.bRisposta) And (iNumeroPassi <= 180)) motOrizzontale.MuoviMotore -MUOVITANTO iNumeroPassi = iNumeroPassi + MUOVITANTO Sleep ATTESA Mirino.Analizza Capture.Cattura Loop iVersoArrivo = -1 End Function Private Function PosizionamentoFine() Do While (Abs(Mirino.iX) > PRECISIONE) If (Mirino.iX > 0) Then motOrizzontale.MuoviMotore -MUOVIPOCO

42

'sleep attesa Mirino.Analizza Capture.Cattura Else motOrizzontale.MuoviMotore MUOVIPOCO 'sleep attesa Mirino.Analizza Capture.Cattura End If Loop Do While (Abs(Mirino.iY) > PRECISIONE) If (Mirino.iY > 0) Then motVerticale.MuoviMotore MUOVIPOCO 'sleep attesa Mirino.Analizza Capture.Cattura Else motVerticale.MuoviMotore -MUOVIPOCO 'sleep attesa Mirino.Analizza Capture.Cattura End If Loop If iVersoArrivo < 0 Then motOrizzontale.MuoviMotore 180 Else motOrizzontale.MuoviMotore -180 End If End Function

43

Private Function Leggi_FileINI() Dim ret As String Dim RetLen ret = Space$(255) Dim sPercorsoINI As String sPercorsoINI = App.Path sPercorsoINI = sPercorsoINI & "\config.ini" RetLen = GetPrivateProfilestring("CONFIGURAZIONE", "PRECISIONE", "", ret, Len(ret), sPercorsoINI) ret = Left$(ret, RetLen) PRECISIONE = Val(ret) ret = Space$(255) RetLen = GetPrivateProfilestring("CONFIGURAZIONE", "MUOVITANTO", "", ret, Len(ret), sPercorsoINI) ret = Left$(ret, RetLen) MUOVITANTO = Val(ret) ret = Space$(255) RetLen = GetPrivateProfilestring("CONFIGURAZIONE", "MUOVIPOCO", "", ret, Len(ret), sPercorsoINI) ret = Left$(ret, RetLen) MUOVIPOCO = Val(ret) ret = Space$(255) RetLen = GetPrivateProfilestring("CONFIGURAZIONE", "ATTESA", "", ret, Len(ret), sPercorsoINI) ret = Left$(ret, RetLen) ATTESA = Val(ret) 'PRECISIONE = Val(GetPrivateProfilestring("CONFIGURAZIONE", "PRECISIONE", PRECISIONE, Len(PRECISIONE), sPercorsoINI)) 'MUOVITANTO = Val(GetPrivateProfilestring("CONFIGURAZIONE", "MUOVITANTO", , , , sPercorsoINI)) 'MUOVIPOCO = Val(GetPrivateProfilestring("CONFIGURAZIONE", "MUOVIPOCO", , , , sPercorsoINI)) 'ATTESA = Val(GetPrivateProfilestring("CONFIGURAZIONE", "ATTESA", , , , sPercorsoINI)) End Function

44

MODULI

45

DECLARE Declare Sub VVIO_SetNtMode Lib "vvio.dll" () Declare Sub VVIO_SlowDown Lib "vvio.dll" (ByVal x1 As Long) Declare Function VVIO_in Lib "vvio.dll" (ByVal x1 As Long) As Integer Declare Sub VVIO_out Lib "vvio.dll" (ByVal x1 As Long, ByVal x2 As Integer) Declare Function VVIO_LPT_Inizialize Lib "vvio.dll" (ByVal x1 As Integer, ByVal x2 As Long) As Integer Declare Function VVIO_LPT_GetLptFromBios Lib "vvio.dll" (x1 As Long, x2 As Long, x3 As Long) As Integer Declare Function VVIO_LPT_Lock Lib "vvio.dll" (ByVal x1 As Integer) As Integer Declare Function VVIO_LPT_GetStatus Lib "vvio.dll" (ByVal x1 As Integer) As Integer Declare Function VVIO_LPT_WriteData Lib "vvio.dll" (ByVal x1 As Integer, ByVal x2 As Integer) As Integer Declare Function VVIO_LPT_WriteControl Lib "vvio.dll" (ByVal x1 As Integer, ByVal x2 As Integer, ByVal x3 As Integer, ByVal x4 As Integer, ByVal x5 As Integer) As Integer Declare Function VVIO_MAX147_Inizialize Lib "vvio.dll" (ByVal x1 As Integer, ByVal x2 As Long) As Integer Declare Function VVIO_MAX147_GetVolt Lib "vvio.dll" (ByVal x1 As Integer, ByVal x2 As Integer, x3 As Double) As Integer Declare Function VVIO_MAX147_GetSamples Lib "vvio.dll" (ByVal x1 As Integer, x2 As Double) As Integer Declare Function VVIO_CD4094_Inizialize Lib "vvio.dll" (ByVal x1 As Integer, ByVal x2 As Long) As Integer Declare Function VVIO_CD4094_Write Lib "vvio.dll" (ByVal x1 As Integer, ByVal x2 As Integer, ByVal x3 As Integer, ByVal x4 As Integer) As Integer Declare Function VVIO_CD4094_18245 Lib "vvio.dll" (ByVal x1 As Integer, ByVal x2 As Integer, ByVal x3 As Integer, ByVal x4 As Integer, ByVal x5 As Integer) As Integer Declare Function VVIO_CD4094_NextStepBipolar Lib "vvio.dll" (ByVal x1 As Integer, ByVal x2 As Integer, ByVal x3 As Integer, ByVal x4 As Integer) As Integer Declare Function VVIO_CD4094_NextStepUnipolar Lib "vvio.dll" (ByVal x1 As Integer, ByVal x2 As Integer, ByVal x3 As Integer, ByVal x4 As Integer, ByVal x5 As Integer) As Integer Public Declare Sub Sleep Lib "kernel32" (ByVal dwMilliseconds As Long)

46

MAIN Public Sorveglianza As New clsControlloCamera Sub Main() Sorveglianza.Init Load frmWinsock frmWinsock.Show 'frmMirino.Winsock.Listen ' Dim pippo As String ' Call Sorveglianza.MuovieScatta(1, 10) ' Sleep 500 ' Call Sorveglianza.MuovieScatta(2, 10) ' Sleep 500 ' Call Sorveglianza.MuovieScatta(2, 10) ' Sleep 500 ' Call Sorveglianza.MuovieScatta(1, 10) ' Sleep 500 ' Call Sorveglianza.MuovieScatta(3, 10) ' Sleep 500 ' Call Sorveglianza.MuovieScatta(4, 10) ' ' Call Sorveglianza.Arresta End Sub

47

MIRINO Type Capture lRGB As Long lSaturazione As Double lLuminosità As Double lTonalità As Double End Type

MOTORE Public bPrimaEsecuzione As Boolean Public iLpt As Integer 'Porta Lpt selezionata

INI Declare Function GetPrivateProfilestring Lib "kernel32" Alias _ "GetPrivateProfileStringA" (ByVal lpApplicationName _ As String, ByVal lpKeyName As Any, ByVal lpDefault _ As String, ByVal lpReturnedString As String, ByVal _ nSize As Long, ByVal lpFileName As String) As Long Declare Function WritePrivateProfileString Lib "kernel32" Alias _ "WritePrivateProfileStringA" (ByVal lpApplicationName _ As String, ByVal lpKeyName As Any, ByVal lpString As Any, _ ByVal lpFileName As String) As Long

48

WEBCAM Type imgdes ibuff As Long stx As Long sty As Long endx As Long endy As Long buffwidth As Long palette As Long colors As Long imgtype As Long bmh As Long hBitmap As Long End Type Type BITMAPINFOHEADER biSize As Long biWidth As Long biHeight As Long biPlanes As Integer biBitCount As Integer biCompression As Long biSizeImage As Long biXPelsPerMeter As Long biYPelsPerMeter As Long biClrUsed As Long biClrImportant As Long End Type Option Explicit 'Costanti Public Const WS_CHILD As Long = &H40000000 Public Const WS_VISIBLE As Long = &H10000000 Public Const WM_USER As Long = &H400 Public Const WM_CAP_START As Long = WM_USER

49

Public Const WM_CAP_DRIVER_CONNECT As Long = WM_CAP_START + 10 Public Const WM_CAP_DRIVER_DISCONNECT As Long = WM_CAP_START + 11 Public Const WM_CAP_DRIVER_GET_NAME As Long = WM_CAP_START + 12 Public Const WM_CAP_DRIVER_GET_VERSION As Long = WM_CAP_START + 13 Public Const WM_CAP_DRIVER_GET_CAPS As Long = WM_CAP_START + 14 Public Const WM_CAP_FILE_SAVEDIB As Long = WM_CAP_START + 25 Public Const WM_CAP_DLG_VIDEOFORMAT As Long = WM_CAP_START + 41 Public Const WM_CAP_DLG_VIDEOSOURCE As Long = WM_CAP_START + 42 Public Const WM_CAP_DLG_VIDEODISPLAY As Long = WM_CAP_START + 43 Public Const WM_CAP_GRAB_FRAME As Long = WM_CAP_START + 60 'Dichiarazioni generali WINAPI Declare Function capCreateCaptureWindow Lib "avicap32.dll" Alias "capCreateCaptureWindowA" _ (ByVal lpszWindowName As String, _ ByVal dwStyle As Long, _ ByVal x As Long, _ ByVal y As Long, _ ByVal nWidth As Long, _ ByVal nHeight As Long, _ ByVal hwndParent As Long, _ ByVal nID As Long) As Long 'returns HWND Private Declare Function SendMessageAsLong Lib "user32" Alias "SendMessageA" _ (ByVal hWnd As Long, _ ByVal wMsg As Long, _ ByVal wParam As Long, _ ByVal lParam As Long) As Long Private Declare Function SendMessageAsString Lib "user32" Alias "SendMessageA" _ (ByVal hWnd As Long, _ ByVal wMsg As Long, _ ByVal wParam As Long, _ ByVal lParam As String) As Long 'Dichiarazioni libreria VIC32.dll che servirà per la conversione da bmp a jpg Declare Function bmpinfo Lib "VIC32.DLL" (ByVal Fname As String, bdat As BITMAPINFOHEADER) As Long Declare Function allocimage Lib "VIC32.DLL" (image As imgdes, ByVal wid As Long, ByVal leng As Long, ByVal BPPixel As Long) As Long Declare Function loadbmp Lib "VIC32.DLL" (ByVal Fname As String, desimg As imgdes) As Long Declare Sub freeimage Lib "VIC32.DLL" (image As imgdes)

50

Declare Function convert1bitto8bit Lib "VIC32.DLL" (srcimg As imgdes, desimg As imgdes) As Long Declare Sub copyimgdes Lib "VIC32.DLL" (srcimg As imgdes, desimg As imgdes) Declare Function savejpg Lib "VIC32.DLL" (ByVal Fname As String, srcimg As imgdes, ByVal quality As Long) As Long 'DICHIARAZIONE DI FUNZIONI PER LA CATTURA E IL SALVATAGGIO DI UN FRAME 'Funzione di connessione al driver Function capDriverConnect(ByVal hcapwnd As Long, Optional ByVal i As Long = 0&) As Boolean capDriverConnect = SendMessageAsLong(hcapwnd, WM_CAP_DRIVER_CONNECT, i, 0&) End Function 'Funzione di disconnessione dal driver Function capDriverDisconnect(ByVal hcapwnd As Long) As Boolean capDriverDisconnect = SendMessageAsLong(hcapwnd, WM_CAP_DRIVER_DISCONNECT, 0&, 0&) End Function 'Funzione di salvataggio del frame in un file .bmp Function capFileSaveDIB(ByVal hcapwnd As Long, ByVal FilePath As String) As Boolean capFileSaveDIB = SendMessageAsString(hcapwnd, WM_CAP_FILE_SAVEDIB, 0&, FilePath) End Function 'Funzione di Cattura del frame Function capGrabFrame(ByVal hcapwnd As Long) As Boolean capGrabFrame = SendMessageAsLong(hcapwnd, WM_CAP_GRAB_FRAME, 0&, 0&) End Function

51

FORM

52

MIRINO Private Sub Form_Load() Const COLORESFONDO = &H80000001 Const COLORESCRITTA = &H80FFFF With Me .BackColor = COLORESFONDO .lblImmagine.BackColor = COLORESFONDO .lblImmagine.ForeColor = COLORESCRITTA .lblOrizzontale.BackColor = COLORESFONDO .lblOrizzontale.ForeColor = COLORESCRITTA .lblValori.BackColor = COLORESFONDO .lblValori.ForeColor = COLORESCRITTA .lblVerticale.BackColor = COLORESFONDO .lblVerticale.ForeColor = COLORESCRITTA .lblRisposta.BackColor = COLORESFONDO .lblRisposta.ForeColor = COLORESCRITTA .lblX.BackColor = COLORESFONDO .lblX.ForeColor = COLORESCRITTA .lblY.BackColor = COLORESFONDO .lblY.ForeColor = COLORESCRITTA .shaValori.FillStyle = 1 .shaValori.BorderColor = COLORESCRITTA .shaValori.BackColor = COLORESFONDO End With End Sub

53

WEBCAM Private Sub Form_Load() End Sub

WINSOCK Private Sub Form_Load() ApriConn End Sub Private Sub Form_Unload(Cancel As Integer) Sorveglianza.Chiudi End End Sub Private Sub Winsock_Close() If Winsock.State <> sckClosed Then Winsock.Close End If ApriConn End Sub Private Sub Winsock_ConnectionRequest(ByVal requestID As Long) AddLog "Requested" If Winsock.State <> sckClosed Then AddLog "Closing .." Winsock.Close End If Winsock.Accept requestID AddLog "Accepted"

54

End Sub Private Sub Winsock_DataArrival(ByVal bytesTotal As Long) Dim sPercorso As String Dim sDati As String Winsock.GetData sDati AddLog "Arrived: " & sDati sPercorso = TrattaDati(sDati) sPercorso = Mid(sPercorso, 19) Winsock.SendData sPercorso & String(100, " ") AddLog "Sent: " & sPercorso 'Sleep 5000 'Winsock.Close 'ApriConn End Sub Private Function TrattaDati(sDati As String) As String Dim iGradi As Integer Dim sDirezione As String Dim sPercorso As String sDirezione = Mid(sDati, 1, 2) iGradi = Val(Mid(sDati, 4, 2)) Select Case sDirezione Case "zz" sPercorso = Sorveglianza.MuovieScatta(0, 0) Case "SU" sPercorso = Sorveglianza.MuovieScatta(1, iGradi) Case "GI" sPercorso = Sorveglianza.MuovieScatta(2, iGradi) Case "DE"

55

sPercorso = Sorveglianza.MuovieScatta(3, iGradi) Case "SI" sPercorso = Sorveglianza.MuovieScatta(4, iGradi) End Select TrattaDati = sPercorso End Function Private Function ApriConn() Winsock.LocalPort = 20001 Winsock.Listen AddLog "Listening ...." End Function

FILE INI

[Configurazione] LUMINOSITà=0.6 SOGLIAPICCO=10 PRECISIONE=15 MUOVITANTO=10 MUOVIPOCO=1 ATTESA=10 ITIMESLEEP=20 BASEPATH="D:\INETPUB\WEBCAM\TEMP\"

56

PAGINE ASP

57

DEFAULT.ASP

<% @ LANGUAGE="VBScript"%> <% Response.redirect("collegamento.asp") %> <html> <head> <meta name="Microsoft Border" content="l, default"> </head> <body>&nbsp;</body> </html>

58

COLLEGAMENTO.ASP

<% @ LANGUAGE="VBScript" %> <% Dim sGradi Dim sDirezione a=Request.Form("direzione") if a="Refresh" then c="zz!zz" if a <> "Refresh" Then sGradi = mid(a,1,2) sDirezione=mid(a,10,2) c= sDirezione & "!" & sGradi if c="!" then c="zz!zz" sGradi=0 End if End if 'Constants: Connection states Const asCONN_DISCONNECTED = 1 Const asCONN_LISTENING = 2 Const asCONN_CONNECTED = 3 ' Constants: Some Error codes Const asERR_SUCCESS = 0 Const asERR_INVALIDPARAMETER = 1 Const asERR_CREATETHREADFAILED = 2 Const asERR_EVALUATIONEXPIRED = 3 Const asERR_INVALIDLICENSE = 4 ' Constants: Protocols Const asPROTOCOL_RAW = 1 Const asPROTOCOL_TELNET = 2 Set oSck = CreateObject("ActivXperts.Socket") oSck.Protocol = asPROTOCOL_TELNET 'oSck.Protocol = asPROTOCOL_RAW ' Make a connection to port 20001 on local server oSck.Connect "127.0.0.1", 20001 If oSck.LastError = 11001 Then Response.write "Error 11001: Specify a valid hostname-parameter in the Connect-method." End If If oSck.LastError = asERR_SUCCESS And oSck.ConnectionState = asCONN_CONNECTED Then ' YES, connection established. Response.write "Connection established" & vbCrLf 'oSck.Sleep 1000

59

oSck.SendString c, True Response.write "Sent: " & c & vbCrLf 'oSck.Sleep 100 * CInt(sGradi) / 3 * 2 if sGradi= 0 then oSck.Sleep 3000 end if if sGradi= 10 then oSck.Sleep 3000 end if if sGradi= 20 then oSck.Sleep 3000 end if if sGradi= 45 then oSck.Sleep 5000 end if if sGradi= 90 then oSck.Sleep 7000 end if 'oSck.Sleep 5000 'If oSck.HasData Then strReceived = oSck.ReceiveString Response.write "Received: " & strReceived 'End If 'oSck.Sleep 1000 ' And finally, disconnect oSck.Disconnect Session("img")=strReceived End If 'Response.write "FINE" Response.Redirect("Interfaccia.asp") %> <html> <head> <meta name="Microsoft Border" content="l, default"> </head> <body>&nbsp; <% Response.Redirect("Interfaccia.asp") %> </body> </html>

60

INTERFACCIA.ASP <% Dim strImg strImg=Session("img") Response.ExpiresAbsolute = now()-2 Response.Addheader "pragma", "no-cache" Response.Addheader "cache-control","private" Response.Cachecontrol="no-cache" %> <html> <head> <meta http-equiv="Content-Language" content="it"> <meta http-equiv="Content-Type" content="text/html; charset=windows-1252"> <meta name="GENERATOR" content="Microsoft FrontPage 6.0"> <meta name="ProgId" content="FrontPage.Editor.Document"> <title>WebCam Motorizzata</title> <meta name="Microsoft Border" content="l, default"> </head> <body> <form name="Form" method ="post" action="collegamento.asp"> <div align="center"> <table border="0" width="57%" height="385" id="table16" align="left"> <tr> <td width="97%" height="57" colspan="3"> <p align="center"> <font face="Courier New" color="#3333FF" style="font-size: 48pt"> WebCam</font></td> </tr> <tr> <td width="37%" height="106"> <p align="center"><input type="submit" value="Refresh" name="direzione"> </p> </td> <td width="25%" height="106"> <div align="center"> <table border="0" width="31%" id="table21" cellspacing="0" cellpadding="0"> <tr>

61

<td align="center"> <input type="Submit" value="90 GRADI SU" NAME="direzione" ></td> </tr> <tr> <td align="center"> <input type="Submit" value="45 GRADI SU" NAME="direzione" ></td> </tr> <tr> <td align="center"> <input type="Submit" value="20 GRADI SU" NAME="direzione" ></td> </tr> <tr> <td align="center"> <input type="Submit" value="10 GRADI SU" NAME="direzione" ></td> </tr> </table> </div> </td> <td width="35%" height="106">&nbsp;</td> </tr> <tr> <td width="37%" height="106"> <div align="center"> <table border="0" width="56%" id="table18" cellspacing="0" cellpadding="0"> <tr> <td> <input type="Submit" value="10 GRADI SINISTRA" NAME="direzione" ></td> </tr> <tr> <td> <input type="Submit" value="20 GRADI SINISTRA" NAME="direzione" ></td> </tr> <tr> <td> <input type="Submit" value="45 GRADI SINISTRA" NAME="direzione" ></td> </tr> <tr> <td>

62

<input type="Submit" value="90 GRADI SINISTRA" NAME="direzione" ></td> </tr> </table> </div> </td> <td width="25%" height="106"> <p align="center"> <IMG src="<%=strImg%>"> </p> </td> <td width="35%" height="106"> <div align="center"> <table border="0" width="30%" id="table19" cellspacing="0" cellpadding="0"> <tr> <td> <input type="Submit" value="10 GRADI DESTRA" NAME="direzione" ></td> </tr> <tr> <td> <input type="Submit" value="20 GRADI DESTRA" NAME="direzione" ></td> </tr> <tr> <td> <input type="Submit" value="45 GRADI DESTRA" NAME="direzione" ></td> </tr> <tr> <td> <input type="Submit" value="90 GRADI DESTRA" NAME="direzione" ></td> </tr> </table> </div> </td> </tr> <tr> <td width="37%" height="106"></td> <td width="25%" height="106">

63

<div align="center"> <table border="0" width="30%" id="table20" cellspacing="0" cellpadding="0"> <tr> <td> <input type="Submit" value="10 GRADI GIU" NAME="direzione" ></td> </tr> <tr> <td> <input type="Submit" value="20 GRADI GIU" NAME="direzione" ></td> </tr> <tr> <td> <input type="Submit" value="45 GRADI GIU" NAME="direzione" ></td> </tr> <tr> <td> <input type="Submit" value="90 GRADI GIU" NAME="direzione" ></td> </tr> </table> </div> </td> <td width="35%" height="106"></td> </tr> </table> </div> <p align="center"> <br> </p> <p align="center"> <p align="center">&nbsp;</p> <p align="center"></p> </form> &nbsp;</body> </html>

64

INDICE Motivazioni sulla scelta dell’approfondimento. Progetto suddiviso nelle seguenti parti:

• Controllo motori 2 o Inizializzazione e movimento motori 2 o Funzionamento della porta parallela(LPT) 2 o Elettronica di controllo micro-step driver 2 o Motori passo-passo 3 o Registro a scorrimento HCT4094 4 o Grafici delle forme d’onda dei segnali coinvolti 5 o Funzione Motore 7

• Cattura frame video della webcam 8 o Funzione Cattura Frame 8

• Settaggio della webcam 9

o Settaggio Webcam 9

• File INI 10

• Pubblicazione del servizio on-line tramite pagina ASP 11 o Immagine Interfaccia 11

• Codice Sorgente 12

o CLASSI 13 Motori 14 Webcam 21 Mirino 27 Controllo Camera 37

o MODULI 44 Declare 45 Main 46 Mirino 47 Motore 47 Ini 47 Webcam 48

o FORM 51 Mirino 52 WebCam 53 Winsock 53

• File Ini 55

o Contenuto 55

• Pagine ASP 56 o Default 57 o Collegamento 58 o Interfaccia 61

65

BIBLIOGRAFIA www.vincenzov.net Porta LPT Motori micro-step www.msdn.microsoft.com Cattura frame da periferiche di acquisizione Conversione formato immagine da “bmp” a “jpg” Conversione codice “RGB” a codice “HLS” File di configurazione “INI” www.vbscript.it www.vahland.com/asocket/ Pagine ASP (VBScript) aSocket (VBScript)