Sviluppo ed ottimizzazione di un sistema innovativo per la misura di efficienza quantica interna di...

Facoltà di Ingegneria Civile e Industriale

Corso di Laurea Magistrale in Ingegneria delle Nanotecnologie

Sviluppo ed ottimizzazione di un sistema innovativo per la misura di efficienza

quantica interna di celle fotovoltaiche

Anno Accademico 2014/2015

Candidato:

Stefano Cash Relatore:

Prof. Rita Asquini

Correlatori:

Dr. Mario Tucci

Dott. Luca Martini

Facoltà di Ingegneria Civile e Industriale

Corso di Laurea Magistrale in Ingegneria delle Nanotecnologie

Sviluppo ed ottimizzazione di un sistema innovativo per la misura di efficienza

quantica interna di celle fotovoltaiche

Anno Accademico 2014/2015

Relatore:

Prof. Rita Asquini

Correlatori:

Dr. Mario Tucci

Dott. Luca Martini

Controrelatore:

Prof. Antonio Carcaterra

Candidato:

Stefano Cash

Matricola:

1514318

Arriva un momento in cui realizzi che non ti

sei semplicemente specializzato in qualcosa:

qualcosa si è specializzato in te!

I

Introduzione

Un fotorivelatore converte un segnale luminoso in un segnale elettrico, cioè tensione o

corrente.

L'efficienza quantica interna di un fotorivelatore è definita come il rapporto tra il numero di

coppie di portatori di carica effettivamente utili alla variazione di corrente e il numero totale

di fotoni incidenti. La misura di efficienza quantica è un parametro fondamentale per la

caratterizzazione di fotorivelatori e la stima della loro efficienza.

Attualmente per poter valutare la IQE (Internal Quantum Efficiency) di un fotorivelatore, è

necessario possedere un banco di Quantum Efficiency ed uno spettrofotometro, ovvero

strumentazione con un notevole impatto economico per un laboratorio. Si procede con le

misure separate di EQE (External Quantum Efficiency) e di riflettanza e da queste si ricava

analiticamente la IQE del fotorivelatore. Le misure richiedono mediamente quindici minuti

ciascuna.

Conoscere la IQE, permette di ricavare molti altri parametri per la caratterizzazione di

fotorivelatori, come la ricombinazione superficiale, la lunghezza di diffusione, la profondità

di Back Surface Field etc…

L’interesse di questo strumento deriva dalla sua capacità di fornire risposte rapide, ovvero

in pochi minuti e di avere un costo contenuto.

Questa tesi si pone l’obiettivo di sviluppare ed ottimizzare un dispositivo integrato per la

misura di IQE di fotorivelatori in fase prototipale realizzato nel centro di Ricerca ENEA di

Casaccia. Il sistema si compone di alcune schede elettroniche, di varie sorgenti luminose e

di una sfera integratrice e basa il suo funzionamento sulla raccolta di valori discreti di

misura e la ricostruzione successiva tramite il metodo del simplesso delle curve.

Dopo la spiegazione del funzionamento del prototipo di partenza saranno descritte le fasi

principali del lavoro svolto quali: la calibrazione del sistema di misura, la sostituzione ed

integrazioni di componenti danneggiate o mancanti, l’allineamento dell’ottica, la

progettazione delle nuove schede elettroniche, l’interfacciamento con una scheda di

acquisizione (in questo caso un PC) e la stesura di un brevetto per il nuovo sistema di

misura.

Verranno descritti e spiegati i miglioramenti introdotti al sistema di partenza e le soluzioni

proposte per andarne a migliorare ulteriormente le prestazioni dove possibile (con i relativi

costi), saranno infine riportate delle misure effettuate con lo strumento ottimizzato.

La tesi si articola nei seguenti capitoli:

Il primo capitolo effettua una breve descrizione dei fotorivelatori, descrivendone il

funzionamento ed i parametri chiave, illustra le tecniche standard per la misura dei

parametri ed accenna alle sorgenti che saranno utilizzate dal dispositivo.

Il secondo capitolo è incentrato sulla letteratura della sfera integratrice che verrà descritta

in tutti i suoi aspetti in maniera dettagliata, a partire dal suo principio di funzionamento,

dalle grandezze caratteristiche e dalle approssimazioni necessarie di cui tenere conto.

II

Il terzo capitolo mostra alcuni blocchi di cui è costituito il sistema senza entrare nel dettaglio

del funzionamento per evitare di perdere la possibilità di brevettare il sistema.

Il quarto capitolo illustra le schede elettroniche presenti per il funzionamento del sistema,

la descrizione del microcontrollore PIC ed i moduli utilizzati per il funzionamento dai vari

stadi.

Il quinto capitolo è il cuore della tesi, vengono mostrate tutte le migliorie introdotte al

sistema di partenza, da quelle hardware a quelle software, riportando infine un confronto

delle misure ottenute.

Il sesto capitolo mostra tutti gli step necessari per la stesura di un brevetto ed i vantaggi che

può portare.

Il settimo capitolo conclude l’analisi con alcune considerazioni.

Sommario

Capitolo 1. Fotorivelatori e parametri ...................................................................................... 1

1.1 EQE (), R (), IQE () ........................................................................................................ 1

1.2 Misura di QE su banco ottico ............................................................................................ 3

1.3 Misura di riflettanza con spettrofotometro .................................................................... 4

1.4 Sorgenti a spettro largo: LED ............................................................................................ 4

1.5 Range di misura .................................................................................................................. 5

Capitolo 2. La sfera integratrice ................................................................................................. 6

2.1 Teoria della sfera integratrice ........................................................................................... 6

2.2 Equazione della sfera integratrice .................................................................................... 8

2.3 Il moltiplicatore di sfera, M() .......................................................................................... 9

2.4 La riflettanza media ......................................................................................................... 10

2.5 Integrazione spaziale ....................................................................................................... 11

2.6 Risposta temporale ........................................................................................................... 11

2.7 Calibrazione della sfera integratrice .............................................................................. 12

2.8 Rivestimenti interni .......................................................................................................... 12

2.9 Stima di ρ del sidewall ..................................................................................................... 13

Capitolo 3. Il sistema di partenza ............................................................................................ 15

3.1 Le sorgenti ......................................................................................................................... 15

3.1.1 I LASER .......................................................................................................................... 16

3.1.2 I LED ............................................................................................................................... 17

3.2 La focalizzazione del fascio ............................................................................................. 17

3.3 Misura, calcolo di EQE () e R () .................................................................................. 19

Capitolo 4. Le schede elettroniche ........................................................................................... 21

4.1 Scheda di pilotaggio ......................................................................................................... 21

4.1.1 Microcontrollore PIC 18F4553 ..................................................................................... 21

4.1.2 Modulo ADC ................................................................................................................. 23

4.1.3 Modulo USB .................................................................................................................. 26

4.1.4 Protocollo di comunicazione HID .............................................................................. 29

4.1.5 Porte AND ..................................................................................................................... 30

4.1.6 Layout ............................................................................................................................. 30

4.2 Alimentazione ................................................................................................................... 33

4.3 LASER driver EU-42 ........................................................................................................ 33

4.4 Transconduttanza ............................................................................................................. 34

4.5 Transimpedenza ............................................................................................................... 38

Capitolo 5. L’ottimizzazione del sistema ............................................................................... 39

5.1 L’ottimizzazione della testa ............................................................................................ 39

5.1.1 L’allineamento delle sorgenti ...................................................................................... 41

5.2 L’ottimizzazione della transimpedenza ........................................................................ 42

5.3 L’ottimizzazione della guida ottica................................................................................ 46

5.4 L’ottimizzazione del software ........................................................................................ 48

5.4.1 Il software di debug ...................................................................................................... 48

5.4.2 Il software per la misura .............................................................................................. 49

5.5 I risultati ............................................................................................................................. 51

5.5.1 Riflettanza ...................................................................................................................... 51

5.5.2 Efficienza quantica esterna .......................................................................................... 52

5.5.3 Efficienza quantica interna .......................................................................................... 52

Capitolo 6. La stesura del brevetto .......................................................................................... 54

6.1 I vantaggi di un brevetto ................................................................................................. 54

6.2 Quando depositare la domanda di brevetto ................................................................ 56

6.3 La vita di un brevetto ....................................................................................................... 56

Capitolo 7. Conclusioni e considerazioni ............................................................................... 58

Appendici ........................................................................................................................................... 59

A - Firmware di misura PIC 18F4553 ................................................................................... 59

B - Firmware di debug PIC 18F4553 .................................................................................... 68

C - Interfaccia Visual Basic per la misura ............................................................................ 81

D - Interfaccia Visual Studio per il debug ........................................................................... 91

Bibliografia ........................................................................................................................................ 97

Ringraziamenti ................................................................................................................................... 99

Indice delle figure

Figura 1: Efficienza Quantica .......................................................................................................... 2

Figura 2: Schema del sistema di misura per la misura di efficienza quantica ......................... 3

Figura 3: Spettro di emissione di un LED ...................................................................................... 5

Figura 4: Frazione di scambio [1] .................................................................................................... 6

Figura 5: Fattore geometrico [1] ...................................................................................................... 7

Figura 6: Rappresentazione sfera [1] .............................................................................................. 8

Figura 7: Moltiplicatore di sfera vs riflettanza [3] ...................................................................... 10

Figura 8: Radianza relativa vs numero di riflessioni [4] ........................................................... 11

Figura 9: Spettro di riflettanza Spectralon e Spectraleft [6] ...................................................... 12

Figura 10: Riflettanza sfera tramite baffle [6] .............................................................................. 13

Figura 11: Riflettanza sfera stimata .............................................................................................. 14

Figura 12: Testa sorgenti ................................................................................................................ 15

Figura 13: Modello matematico guida ottica............................................................................... 17

Figura 14: Guida ottica in plexiglass ............................................................................................ 19

Figura 15: Interfaccia di misura Visual Basic .............................................................................. 20

Figura 16: Pinout PIC scheda di pilotaggio ................................................................................. 22

Figura 17: Schema dei registri del modulo A/D ADCON0, ADCON1 e ADCON2 ................ 24

Figura 18: Modello dell'ingresso dell'A/D ................................................................................... 24

Figura 19: Tempi di conversione ................................................................................................... 25

Figura 20: Modulo USB PIC 18F4553 ........................................................................................... 26

Figura 21: Modalità Bus Power Only ............................................................................................. 27

Figura 22: Modalità Self-Power Only ............................................................................................. 27

Figura 23: Modalità Dual Power ..................................................................................................... 28

Figura 24: Integrato Texas Instruments CD4081B ...................................................................... 30

Figura 25: Layout scheda di pilotaggio ......................................................................................... 31

Figura 26: Scheda di pilotaggio ..................................................................................................... 32

Figura 27: Alimentatore del sistema ............................................................................................. 33

Figura 28: LASER driver EU-42 ...................................................................................................... 34

Figura 29: Stadio di transconduttanza ......................................................................................... 35

Figura 30: Layout scheda di polarizzazione ................................................................................. 36

Figura 31: Scheda di polarizzazione delle sorgenti visibili ....................................................... 37

Figura 32: Scheda di polarizzazione delle sorgenti infrarosse ................................................. 37

Figura 33: Blocco di transimpedenza ........................................................................................... 38

Figura 34: Testa sorgenti con LASER sostituiti ........................................................................... 39

Figura 35: Collaudo delle sorgenti sostituite .............................................................................. 40

Figura 36: Accoppiamento in ingresso della testa con la sfera ................................................. 41

Figura 37: Operazione di allineamento delle sorgenti ............................................................... 41

Figura 38: Transimpedenza OPA656 ............................................................................................ 42

Figura 39: Schematico della transimpedenza LMP7721 realizzata .......................................... 43

Figura 40: Stampato transimpedenza LMP7721 ......................................................................... 44

Figura 41: Transimpedenza LMP7721 .......................................................................................... 45

Figura 42: Transimpedenza LMP7721 completa ........................................................................ 45

Figura 43: Realizzazione della nuova guida ottica al tornio ..................................................... 46

Figura 44: Guida ottica metallizzata ............................................................................................. 47

Figura 45: Sistema di misura completo ........................................................................................ 47

Figura 46: Interfaccia di debug ....................................................................................................... 48

Figura 47: Interfaccia di misura..................................................................................................... 50

Figura 48: Misura di riflettanza ..................................................................................................... 51

Figura 49: Misura di EQE ............................................................................................................... 52

Figura 50: Misura di IQE ................................................................................................................ 53

Indice delle tabelle Tabella 1: Elenco sorgenti LASER ................................................................................................. 16

Tabella 2: Elenco sorgenti LED...................................................................................................... 17

Tabella 3: Valori di b in relazione a ............................................................................................ 18

Capitolo 1. Fotorivelatori e parametri

1


Per poter comprendere a pieno la trattazione che segue è necessario accennare ai parametri

utilizzati per la caratterizzazione dei fotorivelatori e nello specifico quelli che saranno

oggetto delle misure che il sistema si pone di eseguire.

Nella trattazione si useranno i simboli EQE (), R () e IQE (), per indicare rispettivamente

i parametri Efficienza Quantica Esterna, Riflettanza ed Efficienza Quantica Interna.

Ovviamente tutte queste grandezze dipendono dalla lunghezza d’onda, quindi si sceglierà

un range nel quale valutarli.

1.1 EQE (), R (), IQE ()

L’efficienza quantica esterna (EQE: External Quantum Efficiency), è il rapporto tra il numero

di portatori raccolti da una cella solare ed il numero di fotoni incidenti su di essa per ogni

lunghezza d’onda. Sarà dunque una funzione di λ. Se, per ogni λ, tutti i fotoni incidenti

fossero assorbiti ed i risultanti portatori minoritari fotogenerati fossero raccolti, allora

l’efficienza quantica sarebbe unitaria. Infatti la curva associata ad una EQE ideale ha la

forma di un rettangolo di altezza unitaria e base pari a λ = hc/Eg.

Poiché fotoni di energia minore della “band gap” non sono assorbiti, la EQE può essere vista

come una probabilità di raccolta del tasso di generazione dei minoritari per ogni λ, integrato

sull’intero spessore del dispositivo, e normalizzata al numero di fotoni incidenti. Quindi

l’andamento della EQE reale si discosterà da quello di una EQE ideale a causa della

ricombinazione e delle perdite ottiche. Esiste una distinzione tra efficienza quantica esterna,

EQE, ed efficienza quantica interna, IQE, queste grandezze sono legate tra loro nella

seguente espressione:

EQE = IQE(1 − R) Equazione 1

In cui R è la riflettanza di una cella solare. Ciò che viene misurato dal dispositivo è

l’efficienza quantica esterna, EQE, che corredata con la misura di riflettanza R, restituisce

l’andamento della IQE che non è influenzata dalle perdite dovute alla riflessione.

La Figura 1 mostra l’andamento della efficienza quantica in funzione della lunghezza

d’onda. Si può notare l’andamento ideale (linea marrone) che è pari ad un quadrato di

altezza unitaria. In questo caso, come già detto in precedenza, per ogni λ tutti i fotoni

incidenti sono assorbiti ed i risultanti portatori minoritari fotogenerati raccolti.

La curva inscritta nel quadrato invece (linea nera), rappresenta un andamento reale. Si nota

che per basse lunghezze d’onda (nel blu) il dispositivo non raccoglie i portatori fotogenerati

a causa della ricombinazione superficiale dell’emitter.


2

Figura 1: Efficienza Quantica

Per le lunghezze d’onda centrali, che sono assorbite all’interno del dispositivo, la curva reale

si discosta da quella ideale a causa di una bassa lunghezza di diffusione che non permette

ad alcuni dei portatori minoritari fotogenerati di arrivare in prossimità della giunzione e

quindi essere raccolti. Infine per lunghezze d’onda nel vicino infrarosso che vengono

assorbite dal retro della cella, l’efficienza quantica è molto bassa a causa della bassa

lunghezza di diffusione e mancanza di un BSF (Back Surface Field) adeguatamente profondo.

L'efficienza quantica (QE: Quantum Efficiency) può essere intesa come la probabilità di

accumulazione dovuta al profilo di generazione di una singola lunghezza d'onda, integrata

rispetto allo spessore del dispositivo e normalizzata al numero di fotoni incidenti. La QE

esterna include gli effetti dovuti a perdite ottiche quali la riflessione. E’ comunque utile

leggere la QE togliendo i quantitativi di luce persi per riflessione o trasmissione. Si parla in

tal caso di QE interna con la quale possiamo avere una misura di quanti portatori che si

perdono a causa dei centri di ricombinazione.

E’ importante avere una stima della qualità della cella a prescindere dallo strato antiriflesso.

Si deve in tal caso calcolare la riflettanza, ottenendo il valore per ogni lunghezza d’onda. La

differenza tra QE esterna e riflettanza è la QE interna.

La riflettanza è misurata con lo spettrofotometro. Il campione è posto davanti una fenditura

di una piccola camera sferica completamente ricoperta da uno strato di bianco ottico

realizzata in bario, la sfera integratrice. La sfera presenta due aperture, una per consentire

l’ingresso di un fascio luminoso al suo interno, l’altra per permettere all’oggette che si vuole

misurare di affacciarsi alla sfera.

Lo strumento funziona emettendo un fascio luminoso che entra nella sfera integratrice e

viene riflesso dal campione, e si misura quanto di questo fascio viene riflesso. Lo

spettrofotometro, così come il simulatore solare, usa due lampade per meglio simulare il

comportamento del sole attorno al blu e attorno al rosso. La prima lampada lavora sopra gli

850 nm, la seconda poco al di sotto di tale valore. Dopo la misura occorre una semplice


3

correzione tramite interpolazione proprio nei pressi degli 850 nm poiché altrimenti la

riflettanza avrebbe una discontinuità che non è realmente presente.

1.2 Misura di QE su banco ottico

Questa misura ci dà un’informazione molto utile sull’intera cella, dall’emitter al back,

passando per la regione di svuotamento, cosa che non avviene con altri sistemi di misura.

Questo perché sfrutta la capacità delle componenti dello spettro luminoso di attraversare la

materia ognuna a profondità diverse e della cella fotovoltaica di produrre energia elettrica

quando colpita dalla luce stessa. Per la misura viene utilizzata una luce bianca che è un

insieme di onde elettromagnetiche a diversa lunghezza d’onda (quindi diversi colori).

Queste ultime possono essere separate tramite un apparecchio chiamato monocromatore

che presenta al suo interno un reticolo di diffrazione capace appunto di selezionare in uscita

una tra tutte le onde elettromagnetiche presenti nella luce bianca prodotta da una lampada

alogena situata all’ingresso dell’apparato. Il monocromatore si comporta un po’ come un

prisma di vetro sul quale incide un fascio di luce bianca che come risaputo crea un effetto

arcobaleno dovuto alla dispersione cromatica. Le varie onde elettromagnetiche a diversa

lunghezza d’onda penetrano nella cella a diverse profondità dandoci un’idea di come si

comporta il dispositivo nella sua interezza, infatti la luce blu viene assorbita dall’emitter,

quella rossa dal back e quelle intermedie dal resto del dispositivo.

Questo è il principio di funzionamento del sistema per la misura dell’efficienza quantica,

che è composto dal monocromatore da una basetta conduttrice su cui viene posizionato il

campione da misurare, da un amplificatore lock-in e da un radiometro.

Figura 2: Schema del sistema di misura per la misura di efficienza quantica


4

Nel laboratorio ottico del centro di Ricerca ENEA è stato montato un banco ottico con il

sistema di misura. Come si può vedere in in Figura 2, per effettuare questa misura è

necessaria una strumentazione complessa nonché costosa. In particolare sono necessari:

Lampade alogene;

Monocromatore;

Radiometro;

Chopper;

Lock-in amplifier.

Durante il processo di misura il campione viene posto in maniera tale che uno dei due fasci

uscenti dal beam splitter, incida lo stesso. Una volta lanciata la misura, si attende di avere

acquisito tutte le lunghezze d’onda prescelte. Il tempo di esecuzione per ciascuna misura

può richiedere anche più di dieci minuti, dipendendo dal numero di lunghezze d’onda che

si intende acquisire.

1.3 Misura di riflettanza con spettrofotometro

Per la misura di riflettanza di un campione si utilizza lo spettrofotometro. Questo è uno

strumento molto complesso, che si compone di tanti elementi quali un reticolo con due

lampade, un’ottica molto fine e una sfera integratrice. Ad una porta di quest’ultima viene

affacciato il campione del quale si vuole conoscere lo spettro di trasmittanza. Anche questa

misura ha una durata abbastanza consistente, che si aggira sui dieci minuti.

L’utilizzo della sfera integratrice è indispensabile, perché si riesce ad avere informazioni

sulla riflessione del campione su tutto l’emisfero. Di norma si incide il campione con un

angolo di 8 rispetto alla normale uscente dal campione.

Per questo motivo nel progetto si adotterà la convenzione dell’incisione ad 8 e si utilizzerà

una sfera integratrice di 25 cm di diametro.

1.4 Sorgenti a spettro largo: LED

Nella modellizzazione, si attribuirebbe alla misura fatta con un LED un solo punto, ovvero

la lunghezza d’onda di massima emissione del LED. Questo può sicuramente andare bene

per sorgenti LASER, che hanno uno spettro di emissione stretto, e quindi si avvicinano

molto alla condizione di emissione in un unico punto dello spettro.

Non è così scontata invece la modellizzazione di un LED in tale maniera. Questo perché un

diodo LED di sicuro ha uno spettro di emissione più ampio, che nel migliore dei casi sarà

±20 nm intorno alla lunghezza d’onda di massima emissione.


5

Figura 3: Spettro di emissione di un LED

Quello riportato in Figura 3, è un tipico spettro di emissione di un LED. In questo caso la

sorgente emette la massima potenza ad 850nm, ma se si prende come limite di trascurabilità

un’intensità radiante relativa di 0.4, ci si accorge che la larghezza di banda si aggira sui

valori citati sopra. Inoltre lo spettro è riferito alla condizione di 25C, ovvero se si provoca

un riscaldamento della sorgente perché ad esempio la si sta polarizzando con una corrente

maggiore di quella indicata nel datasheet, lo spettro si allarga.

1.5 Range di misura

Il sistema di misura è stato realizzato per lavorare in un range di lunghezze d’onda

compreso tra 350 nm e 1200 nm. Tale scelta si può giustificare considerando che in questo

range risultano compresi tutti i campioni in silicio, sia cristallino sia amorfo, con i quali è

stato impostato il setup di misura.

Il limite superiore di 1200 nm in particolare è stato scelto perché era quello di riferimento

sul banco di QE, ma nulla vieta di ampliare il range negli sviluppi futuri.

Altra motivazione che ha limitato il range ad un massimo di 1200 nm è che la calibrazione

e l’utilizzo della sfera integratrice per lunghezze d’onda anche molto diverse tra loro, non è

un argomento noto in letteratura ed ha varie problematiche che si presentano per le

lunghezze d’onda alle quali la sfera si allontana dalle condizioni di idealità.

Capitolo 2. La sfera integratrice

6


In questo paragrafo si approfondirà la teoria relativa alla sfera integratrice, per poi dedurre

dal modello matematico le procedure da seguire per svolgere le misure.

2.1 Teoria della sfera integratrice

La sfera integratrice è uno strumento per misurazioni di radiazioni ottiche, la sua funzione

principale è quella di integrare spazialmente il flusso radiante. La teoria della sfera

integratrice origina dalla teoria degli scambi di radiazioni all’interno di una superficie

diffondente. Consideriamo lo scambio di radiazioni che si ha tra due superfici perfettamente

diffondenti.

Figura 4: Frazione di scambio [1]

La frazione di energia che da dA1 incide su dA2 è chiamato fattore di scambio ed è pari a:

dFd1-d2= cos θ1 cos θ2

πS2dA2 Equazione 2


7

dove 1 e 2 sono riferiti alle normali dei due piani. Considerando ora due elementi dA1 e dA2

all’interno di una superficie diffusiva sferica, Figura 5, con S = 2Rcos1 = 2Rcos2, si ha:

Figura 5: Fattore geometrico [1]

dFd1−d2 = dA2

4πR2 Equazione 3

Il risultato è significativo perché il fattore di scambio è indipendente dall’angolo di vista e

dalla distanza fra le due aree. Quindi la frazione di flusso ricevuta da dA2 è la stessa di ogni

altra area infinitesima della superficie sferica. Se l’area infinitesima dA1 scambia energia con

un’area finita A2, si ottiene:

dFd1−d2 = 1

4πR2 ∫ dA2 =A2

4πR2

A2 Equazione 4

Il risultato è indipendente da dA1. Chiamando As la superficie sferica:

𝐹𝑑1−𝑑2 =𝐴2

4𝜋𝑅2=

𝐴2

𝐴𝑠 Equazione 5

Si evince che la frazione di flusso ricevuta dall’elemento A2 è data dal rapporto tra l’area

stessa dell’elemento e quella totale della sfera [1].


8

2.2 Equazione della sfera integratrice

La luce incidente su una superficie diffondente, crea una sorgente di luce virtuale dovuta

alla riflessione. La luce emanata da una superficie è ben descritta dalla radianza, ovvero la

densità di flusso per angolo solido.

La radianza L di una sfera integratrice illuminata da un flusso entrante i, risulta:

𝐿 = Φ𝜌

𝜋𝐴 [𝑊 𝑚2/𝑠𝑟⁄ ] Equazione 6

Dove ρ è la riflettanza della sfera, A l’area illuminata e π è l’angolo solido totale proiettato

dalla superficie A. Nell’equazione della radianza di una sfera integratrice, bisogna

considerare le riflessioni multiple, le perdite dovute alle aperture per permettere l’ingresso

di un flusso e quelle in cui sono posizionati i detector. In una sfera con Ai porta di ingresso e

Ae porta di uscita come in Figura 6.

Figura 6: Rappresentazione sfera [1]

Ipotizzando che tutto il flusso in ingresso sia perfettamente diffuso dalla riflessione iniziale,

la quantità di flusso incidente sull’intera superficie sferica sarà:

Φ𝑠𝑓𝑒𝑟𝑎′ = Φ𝑖𝜌 (

𝐴𝑠−𝐴𝑖−𝐴𝑒

𝐴𝑠) Equazione 7

La parte tra parentesi è la frazione di superficie della sfera al netto delle aperture e delle

uscite e può essere riscritta come (1-f), dove f = (Ai + Ae)/As si chiama frazione di porta.


9

Con lo stesso ragionamento la quantità di flusso incidente sulla superficie della sfera dopo

la seconda riflessione sarà:

Φ𝑠𝑓𝑒𝑟𝑎′′ = Φ𝜌2(1 − 𝑓)2 Equazione 8

Dopo n riflessioni, il flusso totale incidente sarà:

Φ𝑠𝑓𝑒𝑟𝑎𝑛 = Φ𝜌(1 − 𝑓) 1 + 𝜌(1 − 𝑓) + ⋯ + 𝜌𝑛−1(1 − 𝑓)𝑛−1 Equazione 9

Questa equazione indica che la quantità totale di flusso incidente è maggiore di quello in

ingresso per le riflessioni multiple.

Espandendo ad una serie infinita di potenze ed ipotizzando che (1 – f) < 1 si ha:

Φ𝑠𝑓𝑒𝑟𝑎𝑛 =

Φ𝑖𝜌(1−𝑓)

1−𝜌(1−𝑓) [𝑊] Equazione 10

Quindi la radianza della sfera integratrice sarà:

𝐿𝑠 = Φ𝑖

𝜋𝐴𝑠(1−𝑓)∙

𝜌(1−𝑓)

1−𝜌(1−𝑓) Equazione 11

A seguito delle semplificazioni si ottiene:

𝐿𝑠 = Φ𝑖

𝜋𝐴𝑠∙

𝜌


Questa equazione è usata per predire la radianza di una sfera integratrice con un certo

diametro e con flusso in ingresso noto. Si può notare che all’aumentare del diametro la

radianza decresce [2].

2.3 Il moltiplicatore di sfera, M()

L’ equazione 11 è volutamente divisa in due parti, la prima è approssimabile alla radianza,

la seconda è un coefficiente senza unità di misura che si può associare alla moltiplicazione

di flusso totale all’interno della sfera e che viene detto moltiplicatore di sfera M:

𝑀 =𝜌



10

L’equazione 12 conferma l’aumento della radianza dovuto alle riflessioni multiple. In Figura

7 si può notare come M dipenda fortemente sia dalla frazione di porta f sia dalla riflettanza

della superficie sferica.

Una via semplificata e intuitiva per predire la densità di flusso all’interno della sfera è di

dividere il flusso in ingresso per la superficie della sfera.

Per valori di riflettanza 0.94 < ρ < 0.99 e di frazione di porta 0.02 < f < 0.05, il moltiplicatore

di sfera è di norma compreso tra 10 e 30 [3].

Figura 7: Moltiplicatore di sfera vs riflettanza [3]

2.4 La riflettanza media

Finora ci siamo riferiti al caso di riflettanza della superficie uniforme e di riflettanza di tutte

le porte pari a zero. Nel caso più generale l’espressione di M diventa:

𝑀 = 𝜌0

1−𝜌𝑊(1−∑ 𝑓𝑖𝑛𝑖=0 )−∑ 𝜌𝑖𝑓𝑖

𝑛𝑖=0

Equazione 14

dove:

0 = riflettanza iniziale per il flusso incidente;

w = riflettanza della superficie sferica;

i = riflettanza delle porta i;

fi = frazione della porta i;

La quantità a denominatore, a meno dell’unità, può essere considerata la riflettanza media

della sfera. Il moltiplicatore può essere riscritto in funzione della riflettanza iniziale e quella

media come:

𝑀 =𝜌0

1− Equazione 15


11

2.5 Integrazione spaziale

Un’analisi puntuale della distribuzione di radianza all’interno della sfera dipende dalla

distribuzione del flusso incidente, dai dettagli geometrici della sfera, dalla distribuzione

della riflettanza che a sua volta dipende dai dispositivi affacciati alle porte. E’ buona norma

cercare di uniformare al meglio il cemento che ricopre la superficie interna della sfera e

scegliere una sfera con diametro opportuno rispetto al numero di porte che si utilizzano e

al dispositivo che si affaccia.

La radianza dopo n riflessioni può essere confrontata con la condizione stazionaria di

regime, come si vede in Figura 8.

Un numero grande di riflessioni produce radianza che si avvicina alla stazionarietà al

crescere della riflettanza ed al diminuire della frazione di porta[4].

Figura 8: Radianza relativa vs numero di riflessioni [4]

2.6 Risposta temporale

In molte applicazioni la sfera integratrice è utilizzata come strumento in condizioni

stazionarie. Se il segnale luminoso è rapidamente variabile o pulsato, il segnale in uscita

potrebbe essere notevolmente distorto dalle riflessioni multiple. La forma del segnale di

uscita può essere ottenuto facendo la convoluzione tra il segnale in ingresso e la risposta

impulsiva della sfera integratrice.

La risposta impulsiva è del tipo 𝑒𝑡

𝜏⁄ , e la costante di tempo si può calcolare come:

𝜏 = −2

3∙

𝐷𝑠

𝑐∙

1

ln Equazione 16

con Ds diametro della sfera.

La costante di tempo tipica di una sfera va da pochi nanosecondi a poche decine di

nanosecondi [4].


12

2.7 Calibrazione della sfera integratrice

Andare a calibrare la sfera integratrice in un range UV-VIS-NIR, come già accennato, non è

cosa semplice. Nonostante ci siano studi sulla sfera già a partire dal 1902, in letteratura non

è presente l’utilizzo di tale strumento in un range ampio di lunghezze d’onda

350nm÷1200nm.

Ciò è giustificabile con le difficoltà che si incontrano andando a variare molto la lunghezza

d’onda del segnale luminoso utilizzato. Infatti il cemento che ricopre la superficie interna

della sfera, in genere non ha valori di riflettanza vicini all’unità in tutto il range considerato

e questo provoca un allontanamento nel setup dalle condizioni di idealità, con conseguente

aumento negli errori di misura.

Per evitare di incappare in queste situazioni, si sceglie di solito la ricopertura interna con

riflettanza maggiore nel range di interesse. Nel caso di tale progetto, dovendo riuscire a

svolgere le misure su range ampio con una sola sfera integratrice, sono stati utilizzati dei

fattori di calibrazione. Il modo in cui sono stati ricavati i fattori di calibrazione è spiegato di

seguito.

Nel seguito sono riportati dei grafici che mostrano gli spettri di riflettanza di alcuni materiali

utilizzati per ricoprire internamente le sfere integratrici [5].

2.8 Rivestimenti interni

Il moltiplicatore di sfera, come si può notare in Figura 7, è estremamente sensibile alle

variazioni di riflettanza della sfera. Perciò la scelta del materiale che riveste la sfera può

provocare valori molto differenti di radianza prodotta all’interno della sfera stessa.

Riflettori utilizzati sono Spectralon e Spectraleft, entrambi utilizzabili nel UV-VIS-NIR.

Nella Figura 9 sono riportati gli spettri di riflettanza di entrambi i materiali.

Figura 9: Spettro di riflettanza Spectralon e Spectraleft [6]


13

E’ evidente come lo Spectralon possa essere utilizzato come riflettore quasi ideale fino a

quasi 2000nm.

Per lo Spectraleft invece, si evidenziano dei valori che non superano 0.98 tra 300nm e 700nm,

ed inoltre la riflettanza cala pericolosamente sotto 400nm e sopra 900nm.

Per la sfera utilizzata, non conoscendo il composto del rivestimento interno e volendo

verificare che l’invecchiamento non avesse pregiudicato le proprietà riflettenti, è stata

effettuata una misura con spettrofotometro di un baffle fornito dall’azienda costruttrice

insieme alla sfera.

Figura 10: Riflettanza sfera tramite baffle [6]

Come si può notare dalle figure sopra, la riflettanza della sfera utilizzata somiglia di più,

per valori e andamento, allo Spectraleft piuttosto che allo Spectralon.

Sapendo che il moltiplicatore di sfera è molto sensibile alle variazioni di ρ del sidewall, la

calibrazione avrà un ruolo fondamentale negli errori che si avranno nel blu e nell’infrarosso.

2.9 Stima di ρ del sidewall

Durante il lavoro di tesi è stato messo a punto un protocollo che, facendo uso degli stessi

elementi necessari alle misure, permettesse all’utilizzatore di stimare la riflettanza del

sidewall.

Questa operazione che sembra superflua, in realtà è utile, anzi indispensabile per rendere

la misura più fine possibile e scevra da errori grossolani. Infatti è noto in letteratura che i

cementi o le vernici riflettenti si usurano col tempo, facendo decadere le loro prestazioni.

L’usura può essere dovuta all’utilizzo continuativo della sfera per lunghi periodi o anche a

polveri che si depositano sul sidewall, alterando le riflessioni multiple.

E’ quindi bene ripetere, periodicamente, il calcolo della riflettanza del sidewall per

assicurarsi di lavorare con uno strumento conforme ai dati che si hanno in possesso.


14

In particolare per la stima si effettuano due misure per mezzo del detector inserito nella sfera.

Inizialmente si incide con il fascio un punto del sidewall che non ricada nell’angolo di vista

solido del detector e si misura la corrente uscente dal detector, si incide poi la zona dove

normalmente si posiziona il campione, che però in questa fase risulta essere occupata da un

tappo con riflettanza unitaria su tutte le lunghezze d’onda di interesse.

In questo caso si è preso l’elemento che è il riferimento nello spettrofotometro.

Si ottiene dal modello matematico:

𝜌𝑠𝑖𝑑𝑒𝑤𝑎𝑙𝑙 = 𝐼𝑠𝑝𝑜𝑡 𝑠𝑢 𝑠𝑖𝑑𝑒𝑤𝑎𝑙𝑙

𝑑𝑒𝑡𝑒𝑐𝑡𝑜𝑟

𝐼𝑠𝑝𝑜𝑡 𝑠𝑢 𝑟𝑖𝑓𝑒𝑟𝑖𝑚𝑒𝑛𝑡𝑜𝑑𝑒𝑡𝑒𝑐𝑡𝑜𝑟 × 𝑅𝑎𝑝𝑝𝑜𝑟𝑡𝑜 𝑓𝑎𝑠𝑐𝑖

Equazione 17

Con Rapporto fasci = spot su sidewall / spot su riferimento che si ottiene della caratterizzazione del beam

splitter.

Figura 11: Riflettanza sfera stimata

Dalla Figura 11 si nota che il processo di stima è valido e permette di avere informazione

sullo spettro di riflettanza del sidewall.

Come c’era da aspettarsi, gli errori che affliggono la stima sono proprio nel blu e

nell’infrarosso intorno a 1000nm. C’è da considerare che tali errori sono imputabili anche al

fatto che nel blu la lampada alogena ha una potenza nettamente minore rispetto alle altre

lunghezze d’onda, mentre a 1000nm il detector, essendo in silicio, è praticamente trasparente.

Capitolo 3. Il sistema di partenza

15


In questo capitolo saranno descritti alcuni blocchi che costituiscono il sistema. Non si entra

nel dettaglio poiché si sta pensando di brevettare il dispositivo in fase di realizzazione una

volta che sarà ottimizzato al meglio. Per motivi di sicurezza inerenti alla proprietà del

brevetto non si vuole quindi pubblicare un documento in cui vengono descritti in maniera

dettagliata i principi di funzionamento.

Nei capitoli seguenti verranno quindi descritte alcune parti del sistema, mentre di altri ne

verrà menzionata solamente la presenza.

3.1 Le sorgenti

Le sorgenti più adatte e le prime ad essere prese in considerazione, sono i LASER. Essi

hanno una larghezza di banda in emissione molto ridotta, quindi possono essere

approssimate, senza grande errore, ad un punto dello spettro.

La difficoltà nel trovare LASER che coprissero il range 350nm÷1200nm, con intensità

sufficientemente elevata e con costo contenuto, ha spinto ad accertarsi che eventuali buchi

nello spettro, potessero essere coperti con l’utilizzo di un più comune LED.

Di qui, la ricerca delle sorgenti è stata condotta considerando per ognuna:

Potenza radiante di almeno 1mW;

A parità di lunghezza d’onda, se possibile, scegliere il LASER;

Prezzo del singolo elemento non eccessivo;

Package di 3mm;

Figura 12: Testa sorgenti


16

La specifica relativa al package è giustificata dal fatto che comunque queste sorgenti

andranno affacciate alla sfera e risulta più comodo avere un package meno ingombrante

rispetto al classico da 5mm. In Figura 12 è riportata la foto della testa su cui sono montate

le sorgenti.

3.1.1 I LASER

I LASER scelti nel sistema di partenza non coprono tutto in range. Di seguito si riporta una

tabella con alcune informazioni sui LASER utilizzati.

(nm) Sigla Potenza (mW)

405 DL-3146-151 5

532 ELD-1020-525 5

635 QL63D4SA 5

670 S6705MG 5

780 QL78D6SA 5

808 RLT80805MGS 5

830 S8330MG 30

850 QL85F6SA 10

880 S8810MG 10

904 RLT904-05MG 5

980 S9850MG 50

995 RLT995-5MG 5

1064 ELD-1060-525 1

Tabella 1: Elenco sorgenti LASER


17

A questi LASER, ne sono stati aggiunti due che erano già presenti in laboratorio, che hanno

emissione a 532nm e 1064nm. L’assenza di LASER nell’UV è data dall’elevato costo, che può

raggiungere anche le migliaia di euro per alcune tipologie.

3.1.2 I LED

I LED presenti nel sistema di partenza si collocano nelle zone di spettro non coperte dai

LASER.

La tabella elenca la lunghezza d’onda e la potenza dei LED utilizzati.

(nm) Sigla Potenza (mW)

360 XSL-360-3E 1.5

430 LED430-33 1

470 B3B-447-IX 12

605 B3B-445-30S 6

1020 ELD-1020-525 1

1200 LED1200-06 5

Tabella 2: Elenco sorgenti LED

Sono stati scelti tutti con un package da 3mm, tranne per i LED a 1020nm e 1200nm. Inoltre

la divergenza massima è di ±15.

3.2 La focalizzazione del fascio

Per focalizzare il fascio luminoso nel punto di ingresso della sfera integratrice è presente

una guida ottica in plexiglass. La guida è stata dimensionata tramite il suo modello

matematico. Per i raggi in ingresso alla sfera si ha:

Figura 13: Modello matematico guida ottica


18

Nella Figura 13 è riportata la schematizzazione matematica di una sorgente con divergenza

β affacciata alla guida ottica.

Con semplici formule trigonometriche si ha:

𝑏 = 𝑎 cotan 𝛼 = 𝑎 cotan (90° − 𝜃) = 𝑎 cotan (90° − 𝛾 − 𝛽) Equazione 18

Noti a, b e c si calcola θ per i raggi perpendicolari ad a:

𝜃 = 90° − 𝑐𝑜𝑡−1 (𝑏

𝑎) = 𝛾 + 𝛽 Equazione 19

Si può ottenere il valore dell’angolo limite come:

𝜃𝑙𝑖𝑚 = 𝑠𝑖𝑛−1 (𝑛2

𝑛1) = 𝑠𝑖𝑛−1 (

1

1.49) = 42.155°

Nel nostro caso si vuole >lim e se si considera γ come angolo limite, essendo questo

l’angolo formato dal fascio maggiormente divergente con la guida d’onda, allora bisogna

avere γ > lim

𝜃∗ = 𝜃𝑙𝑖𝑚 + 𝛽 Equazione 20

𝜃∗ = 𝛾𝑙𝑖𝑚 + 𝛽 Equazione 21

Da qui si può calcolare la divergenza massima consentita dalla sorgente come:

𝛽𝑚𝑎𝑥 = 𝜃∗ − 𝜃𝑙𝑖𝑚 Equazione 22

Le sorgenti presenti sono caratterizzate da una divergenza massima =15, dalle formule

sopra, considerando a = 3cm come la dimensione della testa dove sono installate le sorgenti

si può calcolare la divergenza massima in funzione di b:

b(cm) ()

3.86 10

4.65 15

6.19 22

7.00 24.65

8.00 27.29

9.32 30

Tabella 3: Valori di b in relazione a


19

La guida è stata realizzata con una lunghezza b di 7 cm nonostante le sorgenti abbiano una

divergenza massima =15. Questo perché l’orientazione può differire da quella

perpendicolare ad a e si potrebbero avere valori di divergenza totali maggiori di 15.

Questa scelta è stata critica poiché una maggiore lunghezza di b permetterebbe una

divergenza più ampia da parte delle sorgenti ma aumenterebbe lo spazio percorso dalle

sorgenti luminose all’interno della guida d’onda aumentando l’assorbimento della

radiazione.

Di seguito è riportata una foto della guida ottica del sistema di partenza.

Figura 14: Guida ottica in plexiglass

3.3 Misura, calcolo di EQE () e R ()

Le sorgenti vengono pilotate tramite un microcontrollore PIC che ha il compito di attivare

le sorgenti luminose così da fornire il segnale d’ingresso. Il circuito stampato su cui si è

montato il PIC verrà descritto nel capitolo successivo.

L’elaborazione del segnale di uscita è realizzata tramite un software realizzato in Visual

Basic scritto ad hoc per la misura che si vuole effettuare. Questo software va a memorizzare

in un file di testo tutte le informazioni delle varie sorgenti ossia: numero della sorgente,

canale di acquisizione, valore di tensione misurato sulla cella e sul detector in base alla

posizione dello shutter.


20

Figura 15: Interfaccia di misura Visual Basic

Per l’elaborazione successiva dei dati acquisiti sono state utilizzate delle suite presenti

nell’ambiente di sviluppo Visual Basic che consentono, a partire dal file di testo generato

precedentemente, di ottenere il grafico della efficienza quantica della cella in esame. In

Figura 15 è riportata l'interfaccia di misura Visual Basic.

Capitolo 4. Le schede elettroniche

21


Per il pilotaggio delle sorgenti e l’acquisizione dei segnali sono state utilizzate delle schede

elettroniche che sostanzialmente dovranno:

Accendere le sorgenti luminose;

Polarizzare ogni sorgente con la giusta corrente di polarizzazione;

Convertire da analogico in digitale il segnale uscente;

Inviare il segnale digitale ad un sistema di acquisizione dati;

Interfacciarsi con l’utente per il settaggio di alcuni parametri di misura.

Di seguito sono esposte le scelte fatte sulle base delle specifiche.

4.1 Scheda di pilotaggio

La scheda di pilotaggio è stata costruita intorno ad un microcontrollore. Il microcontrollore,

è ormai un integrato fondamentale nella progettazione di schede elettroniche, per le

numerose funzioni che può svolgere. Contiene inoltre delle porte AND, necessarie alla

selezione della sorgente da accendere.

Da tale scheda si avrà in uscita il segnale impulsato necessario alla selezione e all’accensione

delle sorgenti.

4.1.1 Microcontrollore PIC 18F4553

Il microcontrollore scelto è un integrato della Microchip, il PIC 18F4553.

Le funzioni utilizzate da tale integrato sono:

Generazione di un’onda per modulare i segnali;

Selezione della sorgente utilizzando i pin come uscite digitali;

Modulo di conversione ADC;

Modulo USB per invio dati al PC;

Programmazione del PIC tramite Pickit 3, con cinque pin dedicati.

La scelta è ricaduta su tale dispositivo e non su un 18F4550, perché il 18F4553 ha un modulo

di conversione ADC a 12 bit e non a 10 bit, quindi è molto più accurato. Avere un

convertitore migliore è necessario, visto che dalle misure esposte nel capitolo 2, si evince

che il sistema è molto sensibile e che l’informazione utile è contenuta in piccole variazioni

del segnale.

Inoltre il PIC18F4553 è un integrato a 40 pin, quindi ne ha a sufficienza da dedicarne 19 alla

selezione della sorgente da rendere attiva.


22

Figura 16: Pinout PIC scheda di pilotaggio

La Figura 16 riporta il pinout pensato per il PIC, e vuole essere una linea guida per il layout

della scheda e per la programmazione del PIC.

Lo studio preliminare del pinout è necessario in primo luogo per capire se il numero di pins

è sufficiente per il progetto in esame. Inoltre è stato valutato che l’utilizzo di 19 pins come

enable per le sorgenti, permette di mantenere liberi gli ingressi per i moduli che si devono

utilizzare, ovvero tre per il modulo USB, sei per il modulo ADC, e tre per programmare il

PIC tramite la scheda Pickit3.

Due ulteriori pin sono stati riservati uno per l’allocazione di uno “status LED” molto utile

in fase di programmazione ed un altro per gestire tramite PIC un attuatore meccanico.

L’attuatore è necessario per indirizzare il fascio sul sidewall tramite un baffle, utilizzando un

unico blocco di sorgenti.

Usare un unico blocco di sorgenti porta il vantaggio di non introdurre errori dovuti a

differenze di polarizzazione e di emissione di stesse sorgenti in blocchi diversi, anche se

obbliga ad utilizzare un attuatore meccanico.


23

4.1.2 Modulo ADC

L’acquisizione dei dati in formato analogico e l’invio di questi al terminale sono effettuati

dal microcontrollore PIC18F4553 della Microchip realizzato in tecnologia CMOS. Le

caratteristiche tecniche sono riportate nel dettaglio sul datasheet. In generale si tratta di una

architettura RISC a 8 bit, e pertanto presenta un set ridotto di istruzioni rispetto ad una

architettura CISC, di circa 35 istruzioni elementari, ognuna delle quali occupa una locazione

della memoria programma. L’esecuzione delle istruzioni è temporizzata tramite l’impiego

di un clock esterno (quarzo) di frequenza massima pari a 48MHz: questa frequenza viene

divisa internamente in 4, e ogni istruzione, eccetto alcune istruzioni ed istruzioni di salto,

vengono eseguite in 4 cicli di clock (clock esterno). Pertanto si può avere un massimo di 12

milioni di istruzioni al secondo ed ogni istruzione dura circa 84ns. Il PIC presenta inoltre un

generatore interno (cella RC) che può essere configurato per oscillare da 31kHz ad 8MHz.

La memoria, oltre la memoria programma, è costituita da 192 byte di RAM e 128 byte di

EEPROM, con registri a 8 bit. Alimentato a 5 V, e ottimizzato per ridurre i consumi, il PIC

può fornire uscite digitali di 0 e 5 V.

Vengono riportate di seguito le caratteristiche generali dei moduli utilizzati. Innanzitutto il

segnale proveniente dal rivelatore di inviluppo viene convertito tramite il convertitore ADC

del PIC. Il modulo ADC utilizza cinque registri: ADRESH (AD Result High Register),

ADRESL (AD Result Low Register), e i registri di controllo (AD Control Register) ADCON0,

ADCON1, ADCON2 (Figura 17):

ADRESH e ADRESL sono registri in cui viene memorizzato il valore digitale della

grandezza analogica misurata. In particolare i primi 8 bit più significativi vengono

memorizzati in ADRESH e i restanti 4 bit (conversione a 12 bit) vengono memorizzati

in ADRESL.

ADCON0 è il registro di controllo del modulo A/D: i bit 7 e 6 non sono utilizzati e

sono letti come ‘0’, i quattro bit dal 5 al 2 permettono la configurazione del canale

analogico sul quale si vuole leggere il dato (porte RA0-RA5 e RE0-RE3), il bit 1

GO/DONE indica se la conversione è in corso oppure è stata eseguita, e il bit 0

(ADON) abilita o disabilita il modulo.

ADCON1 è un registro di controllo che configura le funzioni dei pin delle porte: i bit

7 e 6 non sono utilizzati, i bit 5 e 4 configurano i valori di tensione di riferimento, che

possono essere pari a quelli di alimentazione (fra 0 e 5 byte) o modificati ponendo dei

riferimenti esterni, i bit 3-0 permettono di impostare i canali come ingressi analogici

o digitali.

ADCON2 è un registro in cui il bit permette di giustificare a destra o a sinistra i 12

bit contenuti in ADRESH e ADRESL (i rimanenti bit vengono posti a 0), il bit 6 non è

utilizzato, i bit 5 e 6 configurano il tempo di acquisizione, e i bit 2-0 configurano il

clock per la conversione A/D.


24

Figura 17: Schema dei registri del modulo A/D ADCON0, ADCON1 e ADCON2

Per effettuare una conversione analogico/digitale bisogna quindi seguire i seguenti passi:

1. Configurare il modulo A/D;

2. Configurare gli interrupt (se desiderati);

3. Aspettare il tempo necessario per l’acquisizione A/D;

4. Avviare la conversione;

5. Attendere che la conversione sia completata;

6. Leggere il risultato nei registri ADRESH e ADRESL;

7. Tornare al primo passo per la conversione.

Il tempo necessario all’acquisizione del segnale analogico è determinato dal circuito di

sample and hold posto fra la sorgente di tensione e l’ingresso dell’ADC.

Figura 18: Modello dell'ingresso dell'A/D


25

In Figura 18 è riportato il modello dell'ingresso dell'A/D. La capacità Chold deve riuscire a

caricarsi al livello di tensione in ingresso: l’impedenza dello switch (Rss) e l’impedenza della

sorgente (Rs) determinano il tempo che Chold impiega a caricarsi: nel circuito in esame l’ADC

vede una resistenza sorgente (resistenza equivalente) data dal parallelo della resistenza del

demodulatore di inviluppo (“più grande”) con la resistenza di uscita dell’amplificatore a

monte del demodulatore (“più piccola”), e quindi vede praticamente una resistenza molto

piccola rispetto alla massima consigliata nel datasheet (2.5kΩ). Tale discorso si riferisce al

diodo in conduzione, mentre non risulta più valido quando il diodo è interdetto, caso in cui

si sarebbe potuto utilizzare un buffer di tensione (resistenza di uscita che tende a 0) per

disaccoppiare il circuito analogico da quello digitale.

Il tempo di acquisizione può essere calcolato tramite le formule fornite direttamente dal

datasheet riportati in Figura 19:

Figura 19: Tempi di conversione

dove TCOFF è necessario solo per temperature maggiori di 25°, e dove si è posto Rs pari al

valore massimo ammesso(2.5kΩ), anche essendo in realtà molto minore (si pensi che la

resistenza di uscita di un amplificatore operazionale è circa pari a 0.1Ω). In queste

condizioni il tempo di acquisizione è pari a TACQ = (0.2+5+1.2) μs =6.4 μs.

La conversione A/D può iniziare solo dopo tale tempo. Il tempo di conversione

analogico/digitale Tad è determinato dal clock esterno. Per convertire 10 bit il modulo

impiega un tempo pari circa a 11Tad. Ovviamente la scelta del Tad è vincolata dal teorema

del campionamento, pertanto il periodo di campionamento deve essere maggiore o uguale

all’inverso della banda bilatera del segnale, al fine di evitare il fenomeno dell’aliasing. Nella

presente tesi trattando di reazioni chimiche molto lente, con un clock a 4MHz, questo vincolo


26

è facilmente rispettabile. In particolare, programmando il PIC via software si possono

ottenere tempi di campionamento pari a 2, 4, 8, 16, 32, 64 volte il periodo dell’oscillatore

esterno (TOSC) o si può campionare utilizzando l’oscillatore interno RC.

4.1.3 Modulo USB

Il successivo modulo del microcontrollore che è servito nel progetto è il modulo USB (Figura

20), che contiene un ricetrasmettitore capace di operare a diverse velocità di trasmissione,

ad esempio in full-speed o low-speed. L’interfaccia permette una comunicazione tra qualsiasi

host USB e microcontrollori PIC. Alcune particolari caratteristiche hardware sono state

incluse in questi microprocessori per migliorarne le prestazioni. E’ stato previsto un doppio

accesso diretto alla memoria dati USB (RAM) del dispositivo in modo che quest’ultimo sia

condiviso tra il core del microcontrollore e la SIE (Serial Interface Engine), di cui però non si è

fatto uso nel progetto in esame.

Figura 20: Modulo USB PIC 18F4553

E’ possibile inoltre stabilire la velocità di trasmissione grazie alla presenza di un regolatore

interno di 3.3V disponibile per alimentare internamente il pull up resistor in applicazioni in

cui l’alimentazione sia di 5V. Come esplicitato in Figura 20 esercitando un pull up sul piedino

D+ si stabilisce una connessione full-speed, mentre esercitando un pull up sul piedino D- si


27

stabilisce una connessione low-speed. Il pull up può essere effettuato via hardware, tramite

appositi resistori, oppure via software, abilitando i resistori interni tramite il settaggio di

registri appositi. Un altro aspetto degno di nota riguarda la gestione della tensione sul bus

(Vbus) della porta USB.

Il primo dei quattro pin di una generica porta USB è quello della Vbus che si trova ad un

potenziale fisso di 5V. La potenza fornita dalla porta può essere applicata in tre diverse

modalità: bus power only, self‐power only, dual power con predominanza di self‐power.

Scegliendo la modalità bus power only tutta la potenza per l’applicazione è fornita dalla porta

USB. Come si nota in Figura 21 Vbus è connesso direttamente a Vdd, quindi di fatto la porta

alimenta tutto il circuito. La modalità bus power only risulta essere effettivamente il modo

più semplice per alimentare una periferica.

Figura 21: Modalità Bus Power Only

Nella modalità self‐power only il circuito provvede alla propria alimentazione e Vbus è

utilizzata solo per effettuare un pull up su un piedino generico del microcontrollore come

mostrato in Figura 22. Il pull up serve esclusivamente come indicazione al sistema

dell’avvenuto attach del bus e il piedino in questione viene denominato pin sense.

Figura 22: Modalità Self-Power Only


28

Nella modalità dual power con predominanza di self-power, si nota che l’alimentazione fornita

da Vbus entra in gioco solamente nel caso in cui Vself non sia più in grado di alimentare il

circuito, ovvero quando la propria tensione nominale scenda al di sotto della soglia tale da

portare in conduzione il transistor pnp (consuetamente nota come caduta di diodo). Questa

soluzione è indicata in situazioni in cui la alimentazione provenga da una batteria che, una

volta esausta, abbassa il valore della propria fem. Nella Figura 23 inoltre si vede che Vbus

conserva sempre la propria funzione di pull up sul pin sense per indicare al sistema la

presenza di un attach del bus.

Figura 23: Modalità Dual Power

L’analisi di queste tre configurazioni di base inerenti alla gestione della potenza da fornire

al circuito, mette in luce la diversa natura della periferica. Infatti se si vuole progettare una

periferica, ad esempio, che sia in grado di comunicare con l’esterno solo attraverso la porta

USB e che non abbia particolari pretese per l’assorbimento di corrente, è utile ricorrere allo

schema di Figura 21.

Se si prevede, invece, che il sistema possa fungere sia da periferica USB che dà sistema stand

alone, poiché dotato di proprie porte di comunicazione con l’esterno, è conveniente ricorrere

allo schema di Figura 22.Per altre tipologie, come ad esempio sistemi alimentati da batterie

che abbiano caratteristiche appartenenti ad entrambe le tipologie precedenti si può ricorrere

allo schema di Figura 23.

Questa presentazione delle possibili configurazioni di alimentazione metto in rilievo non

solo un problema riguardante la progettazione hardware, ma anche la progettazione

firmware. Infatti, se si pensa di realizzare un sistema che svolga unicamente la funzione di

periferica USB sarà necessario che il sistema generi un polling (interrogazione infinita) sino

a che la periferica non venga enumerata (riconosciuta da sistema operativo) in quanto

sarebbe inutile iniziare a inviare dati se non possono essere ricevuti.

Se invece si intende realizzare un sistema che possa fungere sia da periferica USB che dà

sistema stand alone, è inutile che il sistema si inchiodi su un polling aspettando di essere

riconosciuta dal sistema operativo, se può autonomamente elaborare dati e visualizzarli per


29

proprio conto. Sarà pertanto necessario ricorrere all’utilizzo di un interrupt sul sense pin che

gestisca l’inizializzazione del sistema solo nel momento in cui ci sia un attach del bus.

La frequenza di oscillazione del microcontrollore è determinata dal quarzo. Se si vuole

ottenere una frequenza maggiore, di quella stabilita dal valore del quarzo, è necessario usare

un quarzo con frequenza multipla di 4MHz per i motivi che seguono.

Usando ad esempio un quarzo da 20MHz connesso ai piedini osc1 e osc2, si può decidere

di mandarlo in ingresso ad un anello ad aggancio di fase (Phase Locked Loop = PLL)

impostando i bit di configurazione opportuni. Il PLL accetta solamente una frequenza di

ingresso pari a 4MHz quindi è necessario usare un prescaler che divida per 5 la frequenza

dell’oscillatore in modo da ottenere i 4MHz necessari. Il PLL genera un clock di frequenza

pari a 96MHz prendendone in ingresso una di 4MHz. Successivamente i 96MHz vengono

divisi per 2 riottenendo 48MHz. Tale frequenza di clock potrà essere usata dalla cpu e anche

da altri moduli che ne abbiano necessità. Quindi con un clock di 48MHz si può ottenere una

potenza di calcolo di 12 MIPS (Million Instructions Per Second) in quanto ogni operazione

richiede 4 cicli di clock dovuti allo svolgimento delle fasi di fetch, decode, execute e store.

4.1.4 Protocollo di comunicazione HID

Il protocollo di comunicazione scelto è quello HID. La sigla sta per Human Interface Device,

ed è quello utilizzato attualmente da quasi tutti i dispositivi USB per essere riconosciuti,

alimentati ed interfacciati ad un PC, come ad esempio Pen Drive USB, Keyboard e Mouse.

Il dispositivo viene identificato dal PC tramite due parametri che sono il Vendor ID e Product

ID. Una volta installati i driver e riconosciuto il dispositivo, la comunicazione è stabile e

sicura, molto più di altri protocolli come il CCD.

Il protocollo HID si basa su ricezione e invio di un numero prestabilito di byte. In questo

caso, la comunicazione inizia quando il primo byte del buffer è impostato a 0. Questa è

condizione necessaria e sufficiente per comunicare, quindi il primo byte non può essere

sostituito con un valore diverso da 0, e non parteciperà, nel senso stretto, allo scambio di

dati.

Il protocollo stabilito nel progetto, dopo molte prove, è quello che mantenendo la stabilità

permette di scambiare in maniera più veloce i dati e conseguentemente di campionare in

maniera più rapida.

L’implementazione è a metà tra un protocollo stimolato ed uno non stimolato. In particolare

è il PC che chiede di inviare i dati, ma mentre il PC scrive l’intero buffer ricevuto dal PIC,

manda il primo byte uguale a 0 per richiedere nuovamente dati. Il PIC riempie il buffer con

campioni presi ogni 32,8 s circa. Si ottiene quindi una frequenza di campionamento di 3.040

kHz. Tale frequenza di campionamento permette di ricostruire perfettamente l’onda quadra

uscente dal fotorivelatore e quindi di andare a fare l’elaborazione del segnale

completamente in digitale.


30

4.1.5 Porte AND

Le porte AND in tale progetto sono fondamentali per la selezione della sorgente da

accendere.

E’ noto che la porta AND restituisce un alto logico solo se entrambi gli ingressi sono alti,

mentre restituisce uno zero logico negli altri tre casi. Considerando che è stata prevista una

porta AND per ogni sorgente, e che ogni porta AND ha in uno dei due ingressi il segnale

portante, per accendere la sorgente i-esima in maniera impulsata, basterà mettere alto,

tramite il PIC, l’altro ingresso della porta AND i-esima.

Le porte AND scelte sono le CD4081, che possono essere alimentate tra 0V e 5V come tutto

il resto della scheda. La soglia per il livello alto è di 1.5V, che permette di evitare di attivare

la porta per mezzo del rumore.

Figura 24: Integrato Texas Instruments CD4081B

Inoltre come si può notare dalla figura sopra, il CD4081B contiene quattro porte AND; visto

che in tale progetto sono necessarie diciannove porte AND, l’utilizzo di questo integrato

permette di compattare la scheda.

4.1.6 Layout

La scheda elettronica di pilotaggio è stata realizzata nel laboratorio del Dipartimento di

Ingegneria Informatica, Elettronica e Telecomunicazioni.


31

Figura 25: Layout scheda di pilotaggio

La Figura 25 è una vista dall’alto della scheda di pilotaggio, le piste rosse sono quelle che si

avranno sul top, mentre le blu sul bottom. La scheda è in tecnologia double layer.

Lo spessore delle piste è di 0.4 mm per quelle con passaggio in mezzo ai pad, mentre le piste

che non passano tra i pad a 0.6mm. Sono state rispettati i parametri di progetto

convenzionali ovvero:

Le piste sono, per quanto possibile, volutamente simmetriche, per non squilibrare la

scheda a causa di effetti capacitivi e induttivi;

Le piste devono deviare al massimo di 45⁰, per evitare che ad alte frequenze,

deviazioni maggiori diventino punti di discontinuità elettrica.


32

Figura 26: Scheda di pilotaggio

In Figura 26 vi è la scheda di pilotaggio realizzata in cui si vede in alto la zona dedicata

all’alimentazione, che può essere sia esterna, sia tramite USB, con il limite che quest’ultima,

se prelevata da PC, può fornire al massimo 500 mA. Lo switch tramite le due tipologie di

alimentazione in questo prototipo avviene manualmente tramite un jumper.

In alto a sinistra sono presenti i quattro ingressi del modulo di Conversione

Analogico/Digitale; sono stati previsti quattro ingressi anziché solamente due, che sono

quelli strettamente necessari, sia per evitare che il malfunzionamento di una delle suddette

porte obblighi alla sostituzione del microcontrollore, sia perché negli sviluppi futuri c’è la

possibilità di avere un fotorivelatore sottoposto alle stesse condizioni del campione, ma non

illuminato dal fascio di sorgenti, così da utilizzare l’informazione di quest’ultimo per la

riduzione del rumore.

In basso a sinistra c’è il connettore USB per interfacciare la scheda al PC, o eventualmente

nel futuro ad una scheda di acquisizione dati preposta ed un monitor.

Il PIC è alloggiato al centro della scheda, così da facilitare lo sbroglio del layout. Sopra “la

testa” del PIC c’è un connettore per interfacciarlo alla scheda Pickit3, che una volta collegata

permette di programmare il microcontrollore senza la necessità di staccarlo e posizionarlo

su una scheda di programmazione distinta. Questo a patto di aver collegato in maniera

opportuna i cinque pins dedicati al Pickit3. Sulla destra c’è la schiera di cinque porte AND.

La scheda termina sulla destra con due rastrelliere distinte una per i LASER ed una per i

LED. Questo perché, come già detto, i segnali in uscita da questa scheda sono la portante

che sequenzialmente accende le sorgenti.


33

Nei paragrafi seguenti verranno descritte le schede di polarizzazione che accendono le

sorgenti con la portante impostata e le polarizzano al giusto valore di corrente.

4.2 Alimentazione

Per l’alimentazione delle schede, si è utilizzato un alimentatore stabilizzato che permette di

avere un voltaggio di 8.8V ed un massimo di 0.65A. Di seguito si riporta una foto

dell’alimentatore.

Figura 27: Alimentatore del sistema

4.3 LASER driver EU-42

Per la polarizzazione dei LASER, si sono utilizzati i driver per LASER generici EU-42 della

Roithner.

La scelta del driver è stata presa per garantire un’affidabilità nella polarizzazione della

sorgente, con un basso rischio di rottura dello stesso che potrebbe essere anche molto

costoso.


34

Figura 28: LASER driver EU-42

I driver EU-42 possono essere alimentati tra 0V e 5V, quindi sono perfettamente integrabili

nella scheda di pilotaggio. Hanno una corrente massima erogabile di 120mA, e il segnale

uscente dalla scheda si collega al modulation input, così da accendere il LASER con una

portante. La frequenza massima di commutazione del driver è di 1MHz, ben al di sopra delle

richieste del progetto.

Il driver però, anche se il modulation input viene posto a tensione nulla, è in grado di erogare

delle correnti dell’ordine di alcune decine di mA. Questo ha fatto sì che il suo utilizzo sia

stato limitato alle sole sorgenti LASER che richiedono un’elevata corrente come le due

sorgenti con lunghezza d’onda a 1064 nm e 532 nm.

Questo perché le altre sorgenti LASER, se pilotate con le basse correnti fornite dal driver a

tensione nulla non si accendono come LASER ma si potrebbero accendere ed emettere come

LED, introducendo un errore di misura non trascurabile.

Per tale motivo è stato utilizzato uno stadio di transconduttanza per polarizzare le altre

sorgenti.

4.4 Transconduttanza

La necessità di polarizzare 19 sorgenti diverse, ha rappresentato una specifica di progetto

da valutare con attenzione. Infatti dall’analisi dei datasheet delle sorgenti, si nota subito che

non si può polarizzarle tutte con lo stesso circuito e quindi con la stessa corrente. Si

rischierebbe la rottura di alcune e il malfunzionamento di altre. Ciò è vero a maggior ragione

se si considera che i LASER in genere richiedono una corrente di polarizzazione molto


35

maggiore dei LED e che gli stessi LASER, se polarizzato con una corrente bassa, si

comportano da LED.

In particolare si nota che:

I LED UV hanno cadute di potenziale maggiori (3V), dei LED nel visibile(2.5V),

ma stessa corrente di polarizzazione ovvero circa 20mA;

I LED nell’infrarosso hanno cadute di potenziale minore (1V), dei LED nel

visibile(2.5V) e correnti di polarizzazione di circa 50mA;

I LASER hanno cadute di potenziale di circa 3V, e correnti di polarizzazione di norma

superiori ai 50mA.

Per la polarizzazione sia dei LED che dei LASER si è scelto di utilizzare uno stadio di

transconduttanza rappresentato in Figura 29.

Figura 29: Stadio di transconduttanza

E’ stato scelto tale schema perché, partizionando il segnale in ingresso con un trimmer e

mettendo in Rf sempre un trimmer, si ottiene una configurazione molto versatile che

permette di polarizzare ai giusti valori di corrente tutte le sorgenti, nonostante le diverse

cadute di potenziale, inoltre si evita di mandare in saturazione sia l’operazionale che il BJT.

Circuitalmente, le considerazioni da fare per lo stadio di transconduttanza, riguardano i

livelli di alimentazione e del segnale in ingresso per evitare la saturazione di uno dei due

componenti.

Alimentando l’operazionale a 0V-5V, al massimo in uscita posso avere 5V. Dal circuito si

nota che l’uscita dell’operazionale, grazie alla massa virtuale tra i suoi morsetti di ingresso,

è pari a:

𝑉𝑜𝑢𝑡 = 𝑉𝑖𝑛 + 𝑉𝑏𝑒 Equazione 23


36

E’ evidente che, avendo il BJT una Vbe = 0.7 V circa, se l’onda quadra uscente dal PIC di 5V

non venisse partizionata, l’operazionale non lavorerebbe in zona lineare. Si è deciso quindi

di partizionare l’onda quadra in modo da far ricadere sulla resistenza Rf sempre 1V.

A questo punto bisogna considerare che il BJT, per lavorare in zona attiva e non in

saturazione, deve avere Vce > 0.3 V. La Vce può essere facilmente calcolata come:

𝑉𝑐𝑒 = 𝑉𝑐𝑐 − 𝑉𝑠𝑜𝑟𝑔𝑒𝑛𝑡𝑒 − 𝑉𝑖𝑛𝑔 Equazione 24

Con Vcc = 5V, e una Vsorgente massima di 3.6V, avendo imposto una tensione di 1V sulla

resistenza c’è la certezza di verificare la condizione Vce > 0.3V e quindi di far lavorare il BJT

in saturazione per tutte le sorgenti. La corrente di polarizzazione può essere calcolata come:

𝐼𝑝𝑜𝑙 = 𝑉𝑖𝑛𝑔

𝑅𝑓 Equazione 25

Ovviamente, partizionando l’onda in ingresso con un trimmer, per le sorgenti con caduta di

tensione minore, si può alzare il livello di tensione sulla resistenza Rf, e a parità di resistenza

si noterà un aumento della corrente di polarizzazione.

In Figura 30 si riporta il layout della scheda con le transconduttanze relative alla

polarizzazione di otto sorgenti nel visibile. Per la polarizzazione delle restanti undici

sorgenti nell’infrarosso è stata realizzata un’altra scheda analoga, adattata per un numero

di sorgenti maggiore.

Figura 30: Layout scheda di polarizzazione

Nelle Figura 30 e Figura 31 si riportano le foto delle scheda realizzata, su cui sono state

scritte le lunghezze d’onda che controllano i vari trimmer per comodità di utilizzo.


37

Figura 31: Scheda di polarizzazione delle sorgenti visibili

Figura 32: Scheda di polarizzazione delle sorgenti infrarosse


38

4.5 Transimpedenza

Il segnale in corrente uscente dalla cella in esame e dal detector, deve essere convertito in un

segnale di tensione. Questa operazione viene effettuata da uno stadio a transimpedenza.

Il segnale uscente dalla transimpedenza sarà:

𝑉𝑜𝑢𝑡 = 𝐼𝑝ℎ × 𝑅 Equazione 26

dove R è la resistenza che si trova tra il pin negativo e l’uscita dell’operazionale, che è ancora

una volta il rail-to-rail.

Impostando il valore di R e conoscendo l’ordine di grandezza della Iph, si ricalcola la tensione

in uscita dalla transimpedenza. E’ facile, sapendo che la dinamica a disposizione è 0V÷5V,

scegliere il valore di resistenza adatto a rimanere all’interno della dinamica.

Da un altro punto di vista, R è l’elemento che determina l’amplificazione del segnale: più è

grande R e più sarà grande il valore di tensione. Si deve porre attenzione però al fatto che R

non amplifica solo il segnale utile, ma anche il rumore e quest’ultimo potrebbe saturare il

segnale portando fuori dinamica l’operazione e rendendo la misura illeggibile.

Tale problema è stato risolto schermando fotorivelatore e detector con materiali scuri dotati

di riflettanza molto bassa.

Si ricorda che il rumore in un fotorivelatore è proporzionale all’area totale, mentre il segnale

utile è proporzionale all’area della porzione illuminata.

Figura 33: Blocco di transimpedenza

Capitolo 5. L’ottimizzazione del sistema

39


Il sistema descritto in precedenza è la prima versione funzionante di un sistema complesso

strutturato da diverse parti che si devono interconnettere tra loro. È facile intuire come la

struttura iniziale di questo sistema sia poco robusta (nonostante alcune precauzioni già

prese) e facilmente soggetta a problemi di falsi contatti e di errori di riconoscimento tra le

varie schede elettroniche.

Non è stato infatti immediato ottenere una misura di quantum efficiency poiché inizialmente

dal computer era possibile pilotare solo alcune delle sorgenti, in quanto due LASER infatti

non erano funzionanti. Inoltre risultava alterato lo stadio di transimpedenza appena

descritto che forniva in uscita valori nulli. È stato quindi necessario andare a ripristinare

alcune parti del dispositivo ed allo stesso tempo si è cercato di ottimizzare il tutto,

sostituendo alcuni blocchi funzionali con elementi meglio performanti.

5.1 L’ottimizzazione della testa

Per il corretto funzionamento del dispositivo è stato necessario ripristinare alcuni LASER

sulla testa che non erano più funzionanti. Prima di effettuare una sostituzione si è provato

ad alimentare i due LASER danneggiati tramite un’alimentazione esterna per escludere che

il problema fosse legato alle interconnessioni del sistema o a qualche integrato.

Verificato che le sorgenti erano effettivamente non funzionanti si sono seguite le linee guida

del progetto iniziale e si sono sostituite con LASER dello stesso tipo.

Prima della sostituzione dei LASER danneggiati si è effettuata un’analisi su tutte le correnti

che pilotavano i LASER. Una volta verificato che tutte queste correnti erano corrette, ossia

pari a quelle di funzionamento riportate dal datasheet, si è proceduto con la sostituzione delle

sorgenti, dando la colpa del danneggiamento ad un probabile picco di corrente dovuto a

qualche falso contatto o all’invecchiamento.

Figura 34: Testa sorgenti con LASER sostituiti


40

L’operazione di sostituzione è stata molto complicata poiché i LASER sostituiti sono due

LASER che si trovano al centro della testa. Per arrivare con il saldatore al centro della testa

è stato necessario attraversare tutti i fili che connettono gli altri LASER, facendo particolare

attenzione a non bruciarli.

Una volta sostituite le sorgenti, la testa è rimasta pressoché inalterata rispetto quella di

partenza, avendo posizionato i nuovi LASER nella medesima posizione di quelli

danneggiati.

Dopo aver ricontrollato tutti i collegamenti si è proceduto con l’alimentare le sorgenti per

verificare che queste emettessero come previsto ma una volta alimentate, le nuove sorgenti

rimanevano ancora spente.

Si è intuito a questo punto che il problema non era legato solamente alle due sorgenti

danneggiate ma anche all’integrato che le pilotava. Si è effettuata una sostituzione tra due

integrati dello stesso tipo sulla scheda per verificare in maniera rapida che il problema fosse

quello e si è visto immediatamente che le nuove sorgenti iniziavano ad emettere.

A questo punto si è rimpiazzato l’integrato danneggiato con uno nuovo dello stesso tipo

dando la colpa della rottura delle sorgenti all’integrato in questione che probabilmente avrà

fornito valori eccessivi di corrette al momento della rottura andando a danneggiare anche

le sorgenti.

Si è poi rimontata la testa delle sorgenti sul sistema, iniziando a curare l’allineamento delle

sorgenti con la guida in plexiglass e la sfera.

Figura 35: Collaudo delle sorgenti sostituite


41

5.1.1 L’allineamento delle sorgenti

Per ottenere un segnale in uscita sufficientemente alto è necessario che il fascio uscente dalle

sorgenti e guidato dalla guida d’onda in plexiglass incida la cella posta dal lato opposto

della sfera. Per fare ciò è stato necessario trovare il corretto posizionamento della testa e

della guida in plexiglass. In questo caso, oltre a trovare la corretta angolazione delle varie

componenti si è anche cercato di ottimizzare il posizionamento per far coincidere la focale

della lente in ingresso alla sfera sulla cella da misurare, per garantire che la maggior parte

della potenza radiante delle sorgenti vada a finire sulla cella.

Figura 36: Accoppiamento in ingresso della testa con la sfera

Figura 37: Operazione di allineamento delle sorgenti


42

5.2 L’ottimizzazione della transimpedenza

Durante la prima prova di misura si riportavano in uscita valori nulli. Inizialmente si era

pensato ad un problema relativo alla cella o ai suoi contatti, si è quindi eseguito un collaudo

delle singole componenti tramite tester e si è visto che queste funzionavano in maniera

corretta.

Si è analizzata la transimpedenza del detector e si è deciso di lavorare inizialmente su questa,

non perché fosse effettivamente lei la causa del problema ma perché comunque era

costituita da un integrato caratterizzato da molto rumore che sicuramente era causa di errori

di misura.

Il compito della transimpedenza, come detto in precedenza, è di trasformare il segnale di

corrente proveniente dalla cella o dal detector in un segnale di tensione rilevabile ed

elaborabile dal PIC.

Questo stadio è stato ottimizzato utilizzando un integrato più performante in termini di

rumore e qualità dell’amplificazione rispetto a quello presente come l’OPA656U. È stato

quindi realizzato il circuito su millefori seguendo le istruzioni riportate sul datasheet del

dispositivo per farlo funzionare al meglio come transimpedenza ed è stato realizzato il

circuito riportato di seguito dove sono riportate con IN ed OUT i segnali e con + e - le

alimentazioni.

Figura 38: Transimpedenza OPA656

Un inconveniente di questo nuovo integrato è che per farlo funzionare con singola

alimentazione è necessario alimentarlo tra 0 V e 12 V. E’ stato quindi necessario l’utilizzo di

un generatore esterno essendo il PIC in grado di alimentare solo tra 0 V e 5 V.

Una volta ottenuto in laboratorio l’alimentatore necessario si è eseguito il collaudo del

nuovo stadio che è stato realizzato con una resistenza da 1,5 MΩ per garantire una


43

trasformazione da correnti dell’ordine dei microampere a tensioni dell’ordine dei V (in

particolare tra 1 e 5 V per la dinamica che il PIC riesce a gestire). Una volta testato e quindi

garantito il funzionamento è stata inserita la nuova scheda elettronica al posto di quella

presente inizialmente.

Le misure effettuate dal detector con la nuova transimpedenza erano però affette da un

rumore non trascurabile e presentavano un’amplificazione non sufficientemente elevata per

sfruttare tutta la dinamica del PIC, per cui è stato necessario andare a realizzarne un’altra

ancora più performante per il detector e quella appena realizzata è stata utilizzata per

rilevare il segnale uscente dalla cella dopo aver sostituito la resistenza di amplificazione da

1,5 MΩ con una da 100kΩ (sufficiente per sfruttare la dinamica del PIC per i segnali uscenti

dalla cella).

Dopo un accurata analisi dei vari integrati candidati come transimpedenza si è scelto di

usare un LMP7721 della TEXAS INSTRUMENTS. La scelta è ricaduta su questo integrato

poiché è quello tipicamente usato in università per amplificazioni a transimpedenza a

bassissimo rumore. Non è un integrato economico, il suo costo si aggira intorno ai 10 €, ma

è sicuramente il meno rumoroso in commercio per cui la spesa è giustificata dall’elevata

sensibilità richiesta.

Per ottimizzare le performance e sfruttare a pieno le qualità dell’integrato si è realizzato un

circuito stampato tramite il software Altium Designer così da integrare la scheda elettronica

in uno spazio minimo e ridurre al minimo i disturbi.

Si è deciso anche di utilizzare una resistenza da 10 MΩ per amplificare i segnali di uscita in

maniera sufficiente da sfruttare tutta la dinamica di conversione a disposizione del

microcontrollore.

Figura 39: Schematico della transimpedenza LMP7721 realizzata


44

Figura 40: Stampato transimpedenza LMP7721

La realizzazione di questa scheda è stata effettuata nei laboratori dell’università La Sapienza

di Roma, nel dipartimento di Ingengeria dell’Informazione, Elettronica e

Telecomunicazioni. Una volta realizzata e stampata è stata immediatamente collaudata per

verificarne il corretto funzionamento.

Prima di applicare la scheda alla sfera è stata inserita in un box metallico per ridurre al

minimo il rumore elettromagnetico ed è stata alimentata tramite batteria per ridurre anche

il rumore proveniente dall’alimentazione. Si è ottenuto il circuito riportato in Figura 41.


45

Figura 41: Transimpedenza LMP7721

Una volta testata sulla sfera si è visto che questa struttura di transimpedenza è molto più

performante in termini di rumore rispetto a quelle utilizzate in precedenza.

Si è proceduto quindi nella realizzazione di un'altra transimpedenza analoga per rilevare il

segnale proveniente dalla cella, in questo caso si è utilizzata una resistenza pari ad 100 kΩ

per sfruttare al meglio la dinamica del PIC. Si è inserita anche questa all’interno della scatola

metallica e si è ottenuta una struttura come quella riportata in Figura 42.

Figura 42: Transimpedenza LMP7721 completa


46

5.3 L’ottimizzazione della guida ottica

Il segnale rilevato dalla transimpedenza è estremamente basso, per ottenere un segnale utile

è necessario fare in modo che le sorgenti luminose abbiano una intensità maggiore. Si è

deciso di realizzare, dopo un’accurata riprogettazione, una guida ottica in plexiglass più

lunga che presenta un incavo dove è possibile incastrare la testa delle sorgenti (Figura 43),

così da fornire anche una stabilità meccanica.

Una volta che la nuova guida è stata montata sul sistema è stato necessario effettuare un

nuovo allineamento per garantire che lo spot uscente incidesse esattamente sulla cella o sul

motore mobile. Garantita questa condizione si è andato a misurare il nuovo segnale rilevato

dalla transimpedenza per verificare che effettivamente la nuova guida abbia portato un

aumento dell’intensità e si è visto che il segnale rilevato è effettivamente aumentato.

Figura 43: Realizzazione della nuova guida ottica al tornio

Ci si aspettava però un aumento più consistente, con la nuova guida infatti il segnale in

uscita è quasi raddoppiato, il che non è male, ma si è deciso di effettuare una metallizzazione

esterna per collimare in maniera ancora più efficiente la radiazione luminosa proveniente

dalla testa delle sorgenti. Una volta metallizzata si è ottenuta una struttura come quella

riportata in Figura 44.


47

Figura 44: Guida ottica metallizzata

Per collimare al meglio il fascio uscente da questa nuova guida ottica e limitare le perdite,

si è utilizzato un sistema di lenti in cascata. Questa soluzione non è stata utilizzata con la

guida ottica precedente poiché il sistema di lenti va a modificare la divergenza del fascio e

non permetteva la focalizzazione sulla cella.

Con la nuova guida però, grazie ad un fascio più omogeneo, l’utilizzo delle lenti non

compromette la completa focalizzazione all’interno dell’apertura riservata alla cella da

misurare.

Si è quindi realizzato un carrello su cui fissare l’ottica e si è ottenuto il sistema riportato in

Figura 45.

Figura 45: Sistema di misura completo


48

5.4 L’ottimizzazione del software

Per quanto riguarda il software si è innanzitutto realizzato un firmware per il PIC ed

un’interfaccia in Visual Studio C++ per effettuare il debug, successivamente si è realizzato un

nuovo firmware ed una nuova interfaccia (questa volta in Visual Basic per motivi di

compatibilità con le librerie USB) ad hoc per effettuare la misura.

Tutti i codici (Visual Studio, Visual basic ed i relativi firmware del PIC) sono stati

adeguatamente commentati per garantirne una buona leggibilità così da permettere

modifiche future con facilità, inoltre è stato realizzato un file di testo esterno in cui vengono

spiegate le scelte prese nella stesura dei vari codici.

5.4.1 Il software di debug

La Figura 46 mostra l’interfaccia del software di debug realizzata, mentre il relativo codice è

interamente riportato nelle appendici e ne verrà tenuta una copia in una pen-drive insieme

alla sfera così che chiunque andrà a mettere le mani in futuro sul software avrà tutto il

materiale a disposizione per apportare delle modifiche.

Per poter testare tutte le varie parti del sistema sono stati realizzati vari firmware per il PIC

e varie interfacce di debug. Il firmware più completo per il debug verrà riportato in appendice.

Figura 46: Interfaccia di debug


49

Dalla Figura 46 si vede come tramite questa interfaccia sia possibile andare a testare le

sorgenti. In particolare è possibile andare ad accendere in maniera specifica una particolare

sorgente o più di una. È anche possibile andare ad accendere più sorgenti a frequenze

diverse fino ad un massimo di 5 frequenze diverse che possono essere impostate tramite i

Timer.

L’interfaccia permette poi di muovere l’equipaggio mobile per spostare la direzione del

fascio dalla cella al sidewall e di andare a misurare il segnale in uscita rilevato da uno dei

canali del PIC tramite l’ADC. In particolare sarà possibile scrivere il valore misurato su di

una textbox o di andare a scriverlo su un file esterno che eventualmente può essere

concatenato con successive misure su di altre sorgenti o con altre frequenze.

5.4.2 Il software per la misura

Per quanto riguarda il firmware per la misura si è realizzato un codice che esegue in

automatico tutti gli step necessari per effettuare una misura completa.

Il firmware in MPLab per il controllo del PIC riceve in ingresso dall’interfaccia i parametri

relativi alla frequenza di analisi, al numero di lampeggi da effettuare ad ogni sorgente, alle

eventuali sorgenti che si tengono accese fisse come bias.

Una volta ricevuti questi parametri inizia in maniera ciclica a far lampeggiare le sorgenti

richieste (tutte tranne quelle impostate come bias), dopo aver posizionato lo shutter in modo

tale che il fascio luminoso incida inizialmente il sidewall (così da misurare prima la EQE).

Durante il lampeggio delle sorgenti, il PIC riceve, dalle due transimpedenza, i valori di

tensione che rileva dalla cella in esame e dal detector in maniera alternata. Tramite il modulo

ADC converte in digitale il valore di tensione che invia immediatamente all’interfaccia in

Visual Basic che crea due array (uno per i valori acquisiti dalla cella, l’altro per i valori del

detector) dove tiene salvati i valori ottenuti e li elabora in maniera tale da misurare i valori

di EQE della cella in esame per ogni lunghezza d’onda che ha ricevuto.

L’acquisizione in maniera alternata tra detector e cella è fondamentale per la qualità della

misura di EQE, questo tipo di acquisizione infatti garantisce che il fascio luminoso risulti

esattamente identico tra i due dispositivi durante la misura ed evita di ottenere valori di

misura sbagliati dovuti alla deriva che possono avere le sorgenti nel tempo.

Una volta terminata la prima parte della misura (con lo shutter che riflette sul sidewall) e

misurata la EQE, procede con lo spostamento dell’equipaggio mobile per fare in modo che

il fascio luminoso vada ad incidere la cella solare in esame e va a misurare, facendo

lampeggiare nuovamente le sorgenti richieste, solamente il segnale ricevuto dal detector

quando il fascio incide la cella sotto misura.

Durante questo secondo ciclo si inviano i dati all’interfaccia in Visual Basic che elabora, al

termine del lampeggio di ogni sorgente, i valori ottenuti sulla cella con quelli

precedentemente salvati relativi alla misura sul detector, con il fascio incidente il sidewall.

Tramite questa coppia di array calcola il valore della riflettanza che messo in relazione con

la EQE precedentemente misurata consente di ottenere il valore di IQE per ogni lunghezza

d’onda e lo va a graficare su di una nuova finestra.


50

Il firmware scritto in MPLab basa il suo funzionamento sull’utilizzo del Timer interno al PIC.

Questo fa in modo che le sorgenti lampeggiano sempre con la stessa frequenza che gli viene

impostata dall’interfaccia esterna.

Al di fuori della sezione relativa al Timer (che si occupa come detto solo del lampeggio delle

sorgenti) ci sono varie sezioni come: l’inizializzazione del PIC (prima routine ad essere

eseguita), la ricezione e l’invio di istruzioni e valori tramite USB (ovvero la comunicazione

tra MPLab e Visual Basic) la gestione delle sorgenti da tenere accese in continua ed il

movimento dell’equipaggio mobile.

Il firmware di misura sarà quello che resterà scritto nella memoria del PIC, e verrà sostituito

con quello relativo al debug solo quando si riscontreranno dei mal funzionamenti e sarà

necessario andare a testare le singole sorgenti.

Figura 47: Interfaccia di misura

In Figura 47 è riportata l’interfaccia del software di misura, il relativo codice Visual Basic ed

il firmware MPLab sono riportati in appendice.


51

5.5 I risultati

Di seguito sono riportate le misure di riflettanza, EQE ed IQE ottenute con lo strumento

ottimizzato.

5.5.1 Riflettanza

Per quanto riguarda la misura di riflettanza, in Figura 48 i punti mostrano i valori discreti

ottenuti con la sfera su di una cella campione in silicio policristallino (punti neri), e su di

una cella di silicio cristallino (punti rossi). Le linee continue invece rappresentano le curve

di misura ottenute con lo spettrofotometro presente in laboratorio.

Figura 48: Misura di riflettanza

Dalla si evince una difficoltà del setup di misura nei punti a 360 nm e 1200 nm, che non sono

stati acquisiti correttamente. Il valore a 1200 nm è inaffidabile in quanto il LED ha una banda

troppo larga ed il detector ha una bassa sensibilità su quella lunghezza d’onda, il valore a

360nm è affetto da errore abbastanza grande in quanto la sorgente è molto debole e tende a

produrre fluorescenza anche sulle ottiche.

Gli errori sulle altre lunghezze d’onda invece sono da attribuire alle sorgenti LED utilizzate

che presentano un allargamento spettrale maggiore rispetto ai LASER.

400 600 800 1000 12000.0

0.1

0.2

0.3

0.4

0.5

refl mc-Si spectrophotometer

refl mc-Si sfera

refl c-Si spectrophotometer

refl c-Si sfera

Re

fle

cta

nc

e

Wavelength (nm)


52

5.5.2 Efficienza quantica esterna

Per quanto riguarda la EQE, in maniera analoga alla riflettanza, i punti mostrano i valori

discreti ottenuti con la sfera su di una cella campione in silicio policristallino (punti neri) e

su di una cella di silicio cristallino (punti rossi). Le linee continue invece rappresentano le

curva di misura ottenute con lo spettrofotometro presente in laboratorio.

Figura 49: Misura di EQE

Anche in questo caso gli errori principali sono riportati nei punti a 1200 nm e 360 nm, per

gli stessi motivi della riflettanza.

5.5.3 Efficienza quantica interna

Andando ad effettuare le opportune operazioni sui valori di EQE e di riflettanza si ottiene

il grafico della IQE riportato in Figura 50.

400 600 800 1000 12000.0

0.2

0.4

0.6

0.8

1.0

EQE mc-Si

EQE mc-Si sfera

EQE c-Si

EQE c-Si sfera

EQ

E

Wavelength (nm)


53

Figura 50: Misura di IQE

Si è stimato un errore totale dell’ordine del 3%.

400 600 800 1000 12000.0

0.2

0.4

0.6

0.8

1.0

IQE mc-Si

IQE mc-Si sfera

EQE c-Si

IQE c-Si sfera

IQ

E

Wavelength (nm)

Capitolo 6. La stesura del brevetto

54


Il brevetto (o più propriamente brevetto per invenzione) è un titolo giuridico in forza del

quale al titolare viene conferito un diritto esclusivo di sfruttamento dell'invenzione, in un

territorio e per un periodo ben determinati, e che consente di impedire ad altri di produrre,

vendere o utilizzare l'invenzione senza autorizzazione.

Per invenzione si intende una soluzione nuova ed originale ad un certo problema tecnico.

Essa può riguardare un prodotto o un processo (metodo, procedimento).

Un brevetto tutela e valorizza un’innovazione tecnica, ovvero un prodotto o un processo

che fornisce una nuova soluzione a un determinato problema tecnico. È un titolo in forza

del quale viene conferito un monopolio temporaneo di sfruttamento sull’oggetto del

brevetto stesso, consistente nel diritto esclusivo di realizzarlo, di disporne e di farne un uso

commerciale, vietando tali attività ad altri soggetti non autorizzati.

In particolare, il brevetto conferisce al titolare:

Nel caso in cui l’oggetto del brevetto sia un prodotto, il diritto di vietare ai terzi, salvo

consenso del titolare, di produrre, usare, mettere in commercio, vendere o importare

a tali fini il prodotto in questione;

Nel caso in cui l’oggetto del brevetto sia un procedimento, il diritto di vietare ai terzi,

salvo consenso del titolare, di applicare il procedimento, nonché di usare, mettere in

commercio, vendere o importare a tali fini il prodotto direttamente ottenuto con il

procedimento in questione.

È importante notare che un brevetto non attribuisce al titolare la “libertà di uso” o il diritto

di sfruttare la tecnologia coperta dal brevetto, ma solo il diritto di escludere dall’utilizzo

dello stesso altri soggetti [ministero sviluppo economico].

6.1 I vantaggi di un brevetto

Il brevetto è un formidabile strumento commerciale per le imprese, che consente loro:

Di proteggere i propri investimenti in ricerca e innovazione, evitando che altri utilizzino

gratuitamente il frutto di tali attività

Di acquisire risorse economiche supplementari attraverso la gestione economica dei suoi

diritti di uso.

Un asset da proteggere

Oggi il valore di molte aziende è costituito al 90% dai cosiddetti intangibile assets, costituiti

in maggior parte da diritti di proprietà industriale. Con la protezione brevettuale è possibile

impedire ad altri di brevettare invenzioni identiche o simili e anche di violare i diritti d’uso

(produzione e commercializzazione) oggetto del brevetto. Possedere un brevetto forte

fornisce concrete possibilità di ottenere successo nelle azioni legali contro coloro che

copiano l’invenzione protetta.


55

Una risorsa da valorizzare

Un buon portafoglio brevetti può essere percepito dai partner commerciali, dagli investitori,

dagli azionisti e dai clienti come una dimostrazione dell’alto livello di qualità,

specializzazione e capacità tecnologica dell’azienda, elevandone l’immagine positiva.

Utilizzando il brevetto non solo per disporre di un diritto esclusivo sul mercato, ma anche

come una normale proprietà o bene, è possibile ottenere i seguenti vantaggi economici e

competitivi:

Profitti supplementari derivanti dalla concessione di licenze d’uso o

dall’assegnazione del brevetto: il titolare di un brevetto può cederne l’uso a terzi in

cambio di un compenso pecuniario e/o del pagamento di “royalty”, in modo da

produrre profitti supplementari per la propria impresa; la vendita (o l’assegnazione)

di un brevetto implica il trasferimento della proprietà sullo stesso, mentre la licenza

di un brevetto comporta la sola possibilità di servirsi dell’invenzione brevettata a

specifiche condizioni;

Profitti più alti o utili sugli investimenti: se l’impresa ha investito una quantità

significativa di denaro e di tempo in R&S, la protezione brevettuale derivante

dall’invenzione può rivelarsi uno strumento economico e finanziario per un ritorno

degli investimenti;

Accesso alla tecnologia mediante licenze incrociate: qualora l’impresa fosse

interessata a una tecnologia di proprietà di un’altra impresa, potrà utilizzare i propri

brevetti al fine di negoziare un accordo in base al quale le due imprese potranno

utilizzare, nel rispetto delle condizioni previste dall’accordo stesso, uno o più dei

rispettivi brevetti;

Accesso a nuovi mercati: la concessione a terzi di una licenza su un brevetto può

determinare l’accesso a nuovi mercati che sarebbero altrimenti inaccessibili; in questo

caso è consigliabile proteggere l’invenzione anche nel mercato straniero d’interesse;

Maggiori possibilità di ottenere contributi finanziari dai soggetti intermediari a

fronte della titolarità di un asset intangibile: la proprietà di brevetti (ovvero la licenza

d’uso di brevetti posseduti da altri) può rivelarsi essenziale per ottenere risorse

finanziarie integrative in sede di produzione e commercializzazione dei propri

prodotti; in alcuni settori, come ad esempio quello delle biotecnologie, spesso è

necessario disporre di un importante portafoglio di brevetti per attirare investitori

pronti a finanziare progetti ambiziosi.

In pratica un brevetto determina un concreto arricchimento di un’azienda, oltre che

accrescerne la posizione di forza sul mercato.


56

6.2 Quando depositare la domanda di brevetto

In genere, è preferibile ricorrere alla protezione brevettuale non appena si hanno tutte le

informazioni necessarie per redigere la relativa domanda. Tuttavia, grazie ad una serie di

fattori, è possibile per il richiedente individuare il momento migliore per depositare una

domanda di brevetto.

In Italia, come in molti Paesi, i brevetti sono concessi in base al principio della priorità, il

cosiddetto “first to file”, che prevede che sia il legittimo titolare colui che per primo procede

al deposito della domanda. Pertanto, la tempestività del deposito è un fattore determinante

per il riconoscimento della titolarità, al contrario di quanto avviene negli Stati Uniti, dove

vige il principio del “first to invent”, secondo cui nel caso di richieste di brevetti simili

depositati, il brevetto sarà concesso a colui che per primo ha ideato e realizzato l’invenzione,

indipendentemente da chi per primo abbia presentato la domanda di brevetto.

Talvolta, però, il deposito troppo prematuro può rivelarsi controproducente. Infatti:

Se si procede troppo presto al deposito della domanda di brevetto, considerando che

la domanda rimane segreta per 18 mesi, il richiedente ha sì la possibilità di riflettere

circa l’opportunità di dare seguito alla procedura di esame, ma non può apportare

cambiamenti sostanziali alla descrizione originariamente depositata;

l’Italia è membro della Convenzione di Parigi e pertanto, una volta depositata la

domanda, sono previsti ulteriori 12 mesi per depositare la domanda relativa alla

stessa invenzione in tutti quei Paesi che possono, a vario titolo, essere interessati al

campo di applicazione a cui si riferisce l’invenzione godendo, in questo modo, nei

confronti dei medesimi Paesi, dei benefici che derivano dalla data di deposito della

prima domanda.

Non è possibile chiedere in Italia un brevetto provvisorio, a differenza di alcuni altri Paesi,

come ad esempio gli Stati Uniti.

6.3 La vita di un brevetto

La vita del brevetto non si ferma con la sua concessione. Al contrario, è appena cominciata.

I brevetti per invenzione sono infatti protetti da un utilizzo non autorizzato per un periodo

di 20 anni (e quelli per modelli di utilità per 10) a partire dalla data di deposito degli stessi,

come pure le privative per nuove varietà vegetali sono tutelate per 20 anni a partire dalla

data di concessione, ma solo a condizione che i diritti di mantenimento in vita siano

puntualmente pagati e, durante tale periodo, non venga accolta nessuna richiesta di

invalidità o di revoca.

Nel medesimo periodo, il titolare del brevetto o della privativa può attivare tutte le azioni

in tutela dei propri diritti esclusivi.

Ma se questo si riferisce alla vita legale di un brevetto, la vita commerciale o economica dello

stesso prevede la possibilità di concessione di licenze, di vendita e altre modalità di

sfruttamento, che il titolare dei diritti deve regolarmente notificare; come pure, se la

tecnologia coperta diventa obsoleta, se non può essere commercializzata o se il prodotto su


57

cui si basa non riscontra successo nel mercato, il titolare del brevetto può decidere di non

rinnovarlo, lasciando che esso perda validità prima della scadenza del termine di protezione

e rendendo il trovato libero da vincoli di produzione e di commercializzazione da parte di

terzi.

Capitolo 7. Conclusioni e considerazioni

58

Capitolo 7. Conclusioni e considerazioni

In conclusione il sistema è stato ottimizzato in alcune sue parti e risulta in grado di effettuare

misure di Efficienza Quantica Interna, così come ci si proponeva di fare.

Tra gli sviluppi futuri si può sicuramente annoverare l’ottimizzazione della testa e la

realizzazione di una scheda elettronica integrata su cui sistemare in maniera più compatta

le sorgenti, così da ottenere un fascio più omogeneo e ridurre le perdite per garantire misure

precise ed affidabili anche per quelle sorgenti che si sono mostrate più soggette ad errori di

misura.

Risulta poi importante andare a calcolare dei parametri correttivi da introdurre per ridurre

l’errore percentuale della misura. Non è invece di primaria necessità la miniaturizzazione

delle schede elettroniche, che di per se sono molto meno ingombranti, compresa la sfera

integratrice, degli attuali strumenti di misura presenti in laboratorio.

Si provvederà ad effettuare la stesura di un brevetto sul sistema realizzato, dati i caratteri

innovativi del sistema stesso che presenta alcuni vantaggi rispetto altri sistemi di misura già

presenti come:

Un ingombro fortemente limitato;

Un costo estremamente contenuto;

La possibilità di avere un grafico di IQE in pochi minuti.

Queste caratteristiche lo rendono un’ottima scelta come strumento di misura all’interno di

una catena di produzione, così da poter testare le celle che si stanno realizzando senza

rallentarla ed ottenere informazioni complete su tutti i parametri relativi alla cella, dando la

possibilità di individuare immediatamente eventuali problemi.

Appendici

59

Appendici

A - Firmware di misura PIC 18F4553

#include <p18f4553.h> #include <delays.h> #include <stdio.h> #include <timers.h> #include <adc.h> #include <math.h> #include "usb.h" #pragma config FOSC = HSPLL_HS #pragma config PLLDIV = 5 #pragma config CPUDIV = OSC1_PLL2 #pragma config USBDIV = 2 #pragma config WDT = OFF #pragma config IESO=OFF, PWRT=OFF, BOR=ON_ACTIVE, BORV=3, VREGEN=ON #pragma config MCLRE=OFF, PBADEN=OFF, CCP2MX=OFF, STVREN=ON, LVP=OFF, XINST=OFF, DEBUG=OFF #define LED1 LATAbits.LATA4 #define PULSE LATCbits.LATC2 #define SORG1 LATBbits.LATB5 #define SORG2 LATBbits.LATB4 #define SORG3 LATBbits.LATB3 #define SORG4 LATBbits.LATB2 #define SORG5 LATBbits.LATB1 #define SORG6 LATBbits.LATB0 #define SORG7 LATDbits.LATD7 #define SORG8 LATDbits.LATD6 #define SORG9 LATDbits.LATD5 #define SORG10 LATDbits.LATD4 #define SORG11 LATCbits.LATC7 #define SORG12 LATCbits.LATC6 #define SORG13 LATDbits.LATD3 #define SORG14 LATDbits.LATD2 #define SORG15 LATEbits.LATE2 #define SORG16 LATCbits.LATC0 #define SORG17 LATCbits.LATC1 #define SORG18 LATDbits.LATD1 #define SORG19 LATDbits.LATD0 #define CLK_48MHZ 1 //************************************************************ // Dichiarazione Variabili Globali //************************************************************ volatile unsigned char HIDFeatureBuffer[HID_FEATURE_REPORT_BYTES]; unsigned int n_cycles = 0, lambda = 1; unsigned int p=0, i=0,b=0, stop=1, fase = 0; unsigned char periodi = 1; // Usiamo un array per considerare le sorgenti da saltare unsigned short saltasorgente[] = 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0; //************************************************************ // Dichiarazione Prototipi di funzione interrupt //************************************************************ void Low_Int_Event (void); // Prototipo di funzione per bassa priorità void High_Int_Event (void); // Prototipo di funzione per alta priorità // //************************************************************ // Template per USB //************************************************************ volatile unsigned char HIDFeatureBuffer[HID_FEATURE_REPORT_BYTES]; #pragma code

Appendici

60

char txBuffer[HID_INPUT_REPORT_BYTES]; char rxBuffer[HID_OUTPUT_REPORT_BYTES]; extern byte transferType; void SetupFeatureReport(byte reportID) if (reportID == 0) inPtr = (byte*)&HIDFeatureBuffer; void SetFeatureReport(byte reportID) if (reportID == 0) void GetFeatureReport(byte reportID) if (reportID == 0) outPtr = (byte *)&HIDFeatureBuffer; wCount = HID_FEATURE_REPORT_BYTES; transferType=0; void SetupOutputReport(byte reportID) if (reportID == 0) inPtr = (byte*)&HIDRxBuffer; void SetOutputReport(byte reportID) if (reportID != 0) return; void GetInputReport(byte reportID) if (reportID == 0) outPtr = (byte *)&HIDTxBuffer; wCount = HID_INPUT_REPORT_BYTES; transferType=0; //************************************************************ // Dichiarazione Prototipi di funzione utente //************************************************************ void spegnimento (void) LED1=0; SORG1=0; SORG2=0; SORG3=0; SORG4=0; SORG5=0; SORG6=0; SORG7=0; SORG8=0; SORG9=0; SORG10=0; SORG11=0; SORG12=0; SORG13=0; SORG14=0; SORG15=0; SORG16=0; SORG17=0; SORG18=0; SORG19=0; PULSE=0; // void cella (void) // Fa incidere il fascio sulla cella int i; LED1=1; for (i=0;i<90;i++) LATEbits.LATE1 = 1; Delay1KTCYx(9); LATEbits.LATE1 = 0; Delay10KTCYx(30); LED1=0; //

Appendici

61

void sidewall (void) // Fa incidere il fascio sul sidewall int i; LED1=1; for (i=0;i<90;i++) LATEbits.LATE1 = 1; Delay10KTCYx(6); LATEbits.LATE1 = 0; Delay10KTCYx(24); LED1=0; // void timer0do (void) WriteTimer0(n_cycles); // Setta il numero di cicli nel timer INTCONbits.TMR0IF = 0; // Abbassa il FLAG stop = 0; // Attiva trasmissione PULSE = 1; // Consente il lampeggio delle sorgenti // Verifica se la sorgente da far lampeggiare è attiva come BIAS // In questo caso vai alla sorgente successiva if(saltasorgente[0] && lambda==1) lambda=2; if(saltasorgente[1] && lambda==2) lambda=3; if(saltasorgente[2] && lambda==3) lambda=4; if(saltasorgente[3] && lambda==4) lambda=5; if(saltasorgente[4] && lambda==5) lambda=6; if(saltasorgente[5] && lambda==6) lambda=7; if(saltasorgente[6] && lambda==7) lambda=8; if(saltasorgente[7] && lambda==8) lambda=9; if(saltasorgente[8] && lambda==9) lambda=10; if(saltasorgente[9] && lambda==10) lambda=11; if(saltasorgente[10] && lambda==11) lambda=12; if(saltasorgente[11] && lambda==12) lambda=13; if(saltasorgente[12] && lambda==13) lambda=14; if(saltasorgente[13] && lambda==14) lambda=15; if(saltasorgente[14] && lambda==15) lambda=16; if(saltasorgente[15] && lambda==16) lambda=17; if(saltasorgente[16] && lambda==17) lambda=18; if(saltasorgente[17] && lambda==18) lambda=19; if(saltasorgente[18] && lambda==19) lambda++; // Lampeggia il LED esterno con la stessa frequenza delle sorgenti LED1 =~ LED1; if (lambda==1) SORG1=~SORG1; if (lambda==2) SORG2=~SORG2; if (lambda==3) SORG3=~SORG3; if (lambda==4) SORG4=~SORG4; if (lambda==5) SORG5=~SORG5; if (lambda==6) SORG6=~SORG6; if (lambda==7) SORG7=~SORG7; if (lambda==8) SORG8=~SORG8; if (lambda==9) SORG9=~SORG9; if (lambda==10) SORG10=~SORG10; if (lambda==11) SORG11=~SORG11; if (lambda==12) SORG12=~SORG12; if (lambda==13) SORG13=~SORG13; if (lambda==14) SORG14=~SORG14; if (lambda==15) SORG15=~SORG15; if (lambda==16) SORG16=~SORG16; if (lambda==17) SORG17=~SORG17; if (lambda==18) SORG18=~SORG18; if (lambda==19) SORG19=~SORG19; p++; //Incremento contatore periodi // Si usa il doppio dei periodi perchè per ogni p una volta // è acceso ed una vola è spenta la sorgente // Una volta terminati i periodi con una sorgente esegui if(p>(periodi*2)) // Spengo il timer per dare tempo all'elaborazione T0CONbits.TMR0ON = 0; // Blocco trasmissione

Appendici

62

stop=1; // Spengo la SOLA sorgente che sta elaborando if (lambda==1) SORG1=0; if (lambda==2) SORG2=0; if (lambda==3) SORG3=0; if (lambda==4) SORG4=0; if (lambda==5) SORG5=0; if (lambda==6) SORG6=0; if (lambda==7) SORG7=0; if (lambda==8) SORG8=0; if (lambda==9) SORG9=0; if (lambda==10) SORG10=0; if (lambda==11) SORG11=0; if (lambda==12) SORG12=0; if (lambda==13) SORG13=0; if (lambda==14) SORG14=0; if (lambda==15) SORG15=0; if (lambda==16) SORG16=0; if (lambda==17) SORG17=0; if (lambda==18) SORG18=0; if (lambda==19) SORG19=0; LED1 = 0; // Inizializzo per la sorgente seguente lambda++; p=0; // Scrivo su USB che ho terminato con una sorgente txBuffer[63] = 159; // Attendi e trasmetti il valore Delay10KTCYx(1); HIDTxReport(txBuffer, HID_OUTPUT_REPORT_BYTES); // void ProcessIO(void) byte rxCnt; unsigned char operation; unsigned int frequenza = 10, value=0; // //----------------trasmette------------------------------------------------ // if (stop==0) // Riempi il vettore da txBuffer[0] a txBuffer [59] = 60 valori for (i=0;i<57;i=i+4) ADCON0bits.CHS0 = 0; // Seleziono il canale AN0 ADCON0bits.CHS1 = 0; ADCON0bits.CHS2 = 0; ADCON0bits.CHS3 = 0; ADCON0bits.GO_DONE = 1; // Avvio conversione while (ADCON0bits.GO_DONE == 1) // Polling sul bit GO_DONE txBuffer[i]=ADRESL; // Scrivo sul buffer txBuffer[i+1]=ADRESH; ADCON0bits.ADON = 0; // Misuro la cella solo quando misuro la EQE if (fase == 0) ADCON0bits.CHS0 = 1; // Seleziono il canale AN1 ADCON0bits.CHS1 = 0; ADCON0bits.CHS2 = 0; ADCON0bits.CHS3 = 0; ADCON0bits.ADON = 1;

Appendici

63

ADCON0bits.GO_DONE = 1; // Avvio conversione while (ADCON0bits.GO_DONE == 1) // Polling sul bit GO_DONE txBuffer[i+2]=ADRESL; // Scrivo sul buffer txBuffer[i+3]=ADRESH; txBuffer[63]=149; // Invio istruzione per dire che ho riempito il buffer if (stop==0) HIDTxReport(txBuffer, HID_OUTPUT_REPORT_BYTES); // //-----------------------riceve-------------------------------- // Legge se Visual Basic o Visual Studio han mandato istruzioni. rxCnt = HIDRxReport(rxBuffer, HID_INPUT_REPORT_BYTES); operation = rxBuffer[0]; //Variabile relativa all'istruzione ricevuta // //START // if (operation == 161) rxBuffer[0] = 0; // Resatta il buffer INTCONbits.GIEH = 1; // Attiva gli interrupt INTCONbits.GIEL = 1; // frequenza = rxBuffer[1]; // Valori variabili esterne visual basic periodi = rxBuffer[2]; txBuffer[63] = 0; // Calcola la frequenza per il Timer n_cycles = 65535 - (float)(46875/frequenza); // Muovi equipaggio mobile sidewall(); Delay10KTCYx(65000); //Attendi assestamento shutter Delay10KTCYx(65000); Delay10KTCYx(65000); Delay10KTCYx(65000); INTCONbits.TMR0IE = 1; // Attiva interrupt del TMR T0CONbits.TMR0ON = 1; // Accende il Timer WriteTimer0(n_cycles); // Setta i cicli necessari nel Timer // // STOP // if (operation == 162) T0CONbits.TMR0ON = 0; // Spegni il Timer rxBuffer[0] = 0; // Resetta il buffer txBuffer[63] = 0; INTCONbits.TMR0IF = 0; // Abbassa il FLAG INTCONbits.TMR0IE = 0; // Disattiva interrupt del TMR spegnimento(); // Spegne tutte le sorgenti ADCON0bits.ADON = 0; // Spengo l' ADC stop=1; // Blocca trasmissione lambda=1; // Rinizia sorgente // //CONTROLLO EQUIPAGGIO MOBILE // if(operation==163) rxBuffer[0] = 0; // Resatta il buffer cella(); if(operation==164) rxBuffer[0] = 0; // Resatta il buffer sidewall(); //

Appendici

64

//CAMBIO SORGENTE // if (operation==165) rxBuffer[0] = 0; txBuffer[63] =0; // Inizializza il TMR per la sorgente successiva if(lambda<20) T0CONbits.TMR0ON = 1; WriteTimer0(n_cycles); // Setta i cicli necessari nel Timer else T0CONbits.TMR0ON = 0; // Se hai finito le sorgenti, spegni lambda=1; // Inizializza per la prima sorgente fase = 1; // Inizializza per misura riflettanza cella(); // Sposto il motore Delay10KTCYx(65000); //Attendi assestamento shutter Delay10KTCYx(65000); Delay10KTCYx(65000); Delay10KTCYx(65000); T0CONbits.TMR0ON = 1; // Accendi il TMR // //CONTROLLO SORGENTI IN CONTINUA - BIAS // //360 if(operation==1) rxBuffer[0] = 0; // Resetta il Buffer PULSE=1; // Accendi SORG1 =~ SORG1; // La sorgente specifica saltasorgente[0] =~ saltasorgente[0]; // E forniscine il numero di sorgente da saltare //405 if(operation==2) rxBuffer[0] = 0; PULSE=1; SORG2 =~ SORG2; saltasorgente[1]=~ saltasorgente[1]; //430 if(operation==3) rxBuffer[0] = 0; PULSE=1; SORG3 =~ SORG3; saltasorgente[2] =~ saltasorgente[2]; //470 if(operation==4) rxBuffer[0] = 0; PULSE=1; SORG4 =~ SORG4; saltasorgente[3]=~ saltasorgente[3]; //532 if(operation==5) rxBuffer[0] = 0; PULSE=1; SORG5 =~ SORG5; saltasorgente[4] =~ saltasorgente[4]; //605 if(operation==6) rxBuffer[0] = 0; PULSE=1; SORG6 =~ SORG6; saltasorgente[5]=~ saltasorgente[5]; //635 if(operation==7) rxBuffer[0] = 0; PULSE=1;

Appendici

65

SORG7 =~ SORG7; saltasorgente[6] =~ saltasorgente[6]; //670 if(operation==8) rxBuffer[0] = 0; PULSE=1; SORG8 =~ SORG8; saltasorgente[7] =~ saltasorgente[7]; //780 if(operation==9) rxBuffer[0] = 0; PULSE=1; SORG9 =~ SORG9; saltasorgente[8] =~ saltasorgente[8]; //808 if(operation==10) rxBuffer[0] = 0; PULSE=1; SORG10 =~ SORG10; saltasorgente[9] =~ saltasorgente[9]; //830 if(operation==11) rxBuffer[0] = 0; PULSE=1; SORG11 =~ SORG11; saltasorgente[10]=~ saltasorgente[10]; //850 if(operation==12) rxBuffer[0] = 0; PULSE=1; SORG12 =~ SORG12; saltasorgente[11] =~ saltasorgente[11]; //880 if(operation==13) rxBuffer[0] = 0; PULSE=1; SORG13 =~ SORG13; saltasorgente[12]=~ saltasorgente[12]; //904 if(operation==14) rxBuffer[0] = 0; PULSE=1; SORG14 =~ SORG14; saltasorgente[13] =~ saltasorgente[13]; //980 if(operation==15) rxBuffer[0] = 0; PULSE=1; SORG15 =~ SORG15; saltasorgente[14] =~ saltasorgente[14]; //995 if(operation==16) rxBuffer[0] = 0; PULSE=1; SORG16 =~ SORG16; saltasorgente[15] =~ saltasorgente[15]; //1020 if(operation==17) rxBuffer[0] = 0; PULSE=1; SORG17 =~ SORG17; saltasorgente[16] =~ saltasorgente[16]; //1064 if(operation==18) rxBuffer[0] = 0;

Appendici

66

PULSE=1; SORG18 =~ SORG18; saltasorgente[17] =~ saltasorgente[17]; //1200 if(operation==19) rxBuffer[0] = 0; PULSE=1; SORG19 =~ SORG19; saltasorgente[18] =~ saltasorgente[18]; // Spegni tutte le sorgenti in continua if(operation==20) PULSE = 0; //Azzera gli elementi dell'array for (i=0;i<19;i++) saltasorgente[i]=0; // //************************************************************ // Impostazione e Gestione priorità bassa (non utilizzata) //************************************************************ #pragma code low_vector = 0x18 //Vettore di intterupt a bassa priorità void low_interrupt (void) _asm GOTO Low_Int_Event _endasm // Salto per la gestione dell'interrupt a bassa priorità #pragma code #pragma interruptlow Low_Int_Event void Low_Int_Event (void) // Funzione per la gestione dell'interruzione a bassa priorità //Disattiva attiva interrupt INTCONbits.GIEH=0; INTCONbits.GIEL=0; INTCONbits.GIEH=1; INTCONbits.GIEL=1; // //************************************************************ // Impostazione e Gestione priorità alta //************************************************************ #pragma code high_vector = 0x08 void high_interrupt (void) _asm GOTO High_Int_Event _endasm // Salto per la gestione dell'interrupt ad alta priorità #pragma code #pragma interrupt High_Int_Event void High_Int_Event (void) // Funzione dell'interruzione ad alta priorità (generati da Timer) INTCONbits.GIEH=0; //Disattiva gli interrupt INTCONbits.GIEL=0; if (INTCONbits.TMR0IF == 1) //Se ti arriva un FLAG esegui timer0do(); //Esegui funzione INTCONbits.GIEH=1; //Riabilita gli interrupt INTCONbits.GIEL=1; // //************************************************************ // Inizializzazione del PIC //************************************************************ void UserInit(void) // Inizializzo i pin a valore 0 LATA = 0; LATB = 0; LATC = 0; LATD = 0; LATE = 0; // Inizializzo i pin come IN/OUT TRISA = 0b00001111; // Imposto i canali per conversione A/D AN0 & AN1 // AN2 & AN3 per tensione riferimento convertitore

Appendici

67

// Tutti gli altri come OUT TRISB = 0; TRISC = 0; TRISD = 0; TRISE = 0; // Abilitazione di priorità agli interrupt RCONbits.IPEN = 1; INTCONbits.GIEH = 0; INTCONbits.GIEL = 0; // Impostazioni del timer 0 T0CONbits.T08BIT = 0; // Modalità a 16 bit T0CONbits.T0CS = 0; // Clock interno 5 Mhz (interno Fosc/4) T0CONbits.PSA = 0; // Abilito Prescaler T0CONbits.T0PS2 = 1; // Prescaler 1:128 T0CONbits.T0PS1 = 1; // T0CONbits.T0PS0 = 0; // T0CONbits.TMR0ON = 0; // Spegni il Timer INTCONbits.TMR0IE = 1; // Abilito gli interrupt dal Timer0 INTCON2bits.TMR0IP = 1; // Abilito gli interrupt del Timer0 come alta priorità // Impostazioni ADC ADCON1 = 0x0B; // Imposto AN0 e AN1 come ingressi analogici e setto gli altri bit a zero ADCON2 = 0x8A; // Giustifico a DX setto Tad=0 ed Frc= RC dell'oscillatore ADCON0bits.ADON = 1; // Accendo l' ADC // Setta tutti i byte a zero tranne il primo for (i=1;i<64;i++) txBuffer[i] = 0; // //************************************************************ // Entry point of the firmware //************************************************************ void main(void) UCFG = 0x14; // Initialize USB deviceState = DETACHED; remoteWakeup = 0x00; currentConfiguration = 0x00; UserInit(); // Richiama la funzione di inizializzazione while(1) EnableUSBModule(); // Ensure USB module is available if(UCFGbits.UTEYE != 1) ProcessUSBTransactions(); ProcessIO(); // Esegue la routine principale

Appendici

68

B - Firmware di debug PIC 18F4553

#include <stdio.h> #include <stdlib.h> #include <p18f4553.h> #include <delays.h> #include <timers.h> #include <adc.h> #include <math.h> #include "usb.h" #pragma config FOSC = HSPLL_HS #pragma config PLLDIV = 5 // = 1 se si lavora su scheda LUCA - = 5 su sfera #pragma config CPUDIV = OSC1_PLL2 #pragma config USBDIV = 2 #pragma config WDT = OFF #pragma config IESO = OFF #pragma config PWRT = OFF #pragma config BOR = ON_ACTIVE #pragma config BORV = 3 #pragma config VREGEN = ON #pragma config MCLRE = OFF #pragma config PBADEN = OFF #pragma config CCP2MX = OFF #pragma config STVREN = ON #pragma config LVP = OFF #pragma config XINST = OFF #pragma config DEBUG = OFF // Note: there are timing related problems associated with GET_FEATURE // when run at less than 48 MHz #define CLK_48MHZ 1 #define LED1 LATAbits.LATA4 //LED presente su scheda #define PULSE LATCbits.LATC2 //Impulso di clock #define SORG1 LATBbits.LATB5 //360 #define SORG2 LATBbits.LATB4 //405 #define SORG3 LATBbits.LATB3 //430 #define SORG4 LATBbits.LATB2 //470 #define SORG5 LATBbits.LATB1 //532 #define SORG6 LATBbits.LATB0 //605 #define SORG7 LATDbits.LATD7 //635 #define SORG8 LATDbits.LATD6 //670 #define SORG9 LATDbits.LATD5 //780 #define SORG10 LATDbits.LATD4 //808 #define SORG11 LATCbits.LATC7 //830 #define SORG12 LATCbits.LATC6 //850 #define SORG13 LATDbits.LATD3 //880 #define SORG14 LATDbits.LATD2 //904 #define SORG15 LATEbits.LATE2 //980 #define SORG16 LATCbits.LATC0 //995 #define SORG17 LATCbits.LATC1 //1020 #define SORG18 LATDbits.LATD1 //1064 #define SORG19 LATDbits.LATD0 //1200 //Inizializza variabili conteggio e controllo globali unsigned int i=0; double x, y; unsigned double on = 250; unsigned double off = 250; unsigned double duty_cicle = 0.5; unsigned double frequenza = 2; // variabile in cui ricompongo il mio numero a 16 bit unsigned char operation; unsigned char operationcontinua; unsigned char operationtimer0; unsigned char operationtimer1; unsigned char operationtimer2; unsigned char operationtimer3; //Variabili di scomposizione numero a 16 bit in due da 8 bit unsigned char BL = 0x00; unsigned char BH = 0x00;

Appendici

69

/****************Funzioni di appoggio******************/ void delay (void) Delay1KTCYx (12); //delay 1 ms void cella (void) //sposta il motore sulla cella for (i=0;i<100;i++) LATEbits.LATE1 = 1; Delay1KTCYx(9); LATEbits.LATE1 = 0; Delay10KTCYx(30); void sidewall (void) //sposta il motore su sidewall for (i=0;i<100;i++) LATEbits.LATE1 = 1; Delay10KTCYx(6); LATEbits.LATE1 = 0; Delay10KTCYx(24); void spegnimento (void) LATB=0; LATC=0; LATD=0; LATE=0; PULSE = 0; void timer0 (void) //Selezione sorgente del timer0 (la sorgente si setta nel processIO) //360 if(operationtimer0==0xA1)SORG1 =~ SORG1; //405 if(operationtimer0==0xA2)SORG2 =~ SORG2; //430 if(operationtimer0==0xA3)SORG3 =~ SORG3; //470 if(operationtimer0==0xA4)SORG4 =~ SORG4; //532 if(operationtimer0==0xA5)SORG5 =~ SORG5; //605 if(operationtimer0==0xA6)SORG6 =~ SORG6; //635 if(operationtimer0==0xA7)SORG7 =~ SORG7; //670 if(operationtimer0==0xA8)SORG8 =~ SORG8; //780 if(operationtimer0==0xA9)SORG9 =~ SORG9; //808 if(operationtimer0==0xB0)SORG10 =~ SORG10; //830 if(operationtimer0==0xB1)SORG11 =~ SORG11; //850 if(operationtimer0==0xB2)SORG12 =~ SORG12; //880 if(operationtimer0==0xB3)SORG13 =~ SORG13; //904 if(operationtimer0==0xB4)SORG14 =~ SORG14; //980 if(operationtimer0==0xB5)SORG15 =~ SORG15; //995 if(operationtimer0==0xB6)SORG16 =~ SORG16; //1020 if(operationtimer0==0xB7)SORG17 =~ SORG17; //1064 if(operationtimer0==0xB8)SORG18 =~ SORG18; //1200 if(operationtimer0==0xB9)SORG19 =~ SORG19; void timer1 (void) //Selezione sorgente del timer1 (la sorgente si setta nel processIO) //360 if(operationtimer1==0xA1)SORG1 =~ SORG1; //405 if(operationtimer1==0xA2)SORG2 =~ SORG2;

Appendici

70

//430 if(operationtimer1==0xA3)SORG3 =~ SORG3; //470 if(operationtimer1==0xA4)SORG4 =~ SORG4; //532 if(operationtimer1==0xA5)SORG5 =~ SORG5; //605 if(operationtimer1==0xA6)SORG6 =~ SORG6; //635 if(operationtimer1==0xA7)SORG7 =~ SORG7; //670 if(operationtimer1==0xA8)SORG8 =~ SORG8; //780 if(operationtimer1==0xA9)SORG9 =~ SORG9; //808 if(operationtimer1==0xB0)SORG10 =~ SORG10; //830 if(operationtimer1==0xB1)SORG11 =~ SORG11; //850 if(operationtimer1==0xB2)SORG12 =~ SORG12; //880 if(operationtimer1==0xB3)SORG13 =~ SORG13; //904 if(operationtimer1==0xB4)SORG14 =~ SORG14; //980 if(operationtimer1==0xB5)SORG15 =~ SORG15; //995 if(operationtimer1==0xB6)SORG16 =~ SORG16; //1020 if(operationtimer1==0xB7)SORG17 =~ SORG17; //1064 if(operationtimer1==0xB8)SORG18 =~ SORG18; //1200 if(operationtimer1==0xB9)SORG19 =~ SORG19; void timer2 (void) //Selezione sorgente del timer2 (la sorgente si setta nel processIO) //360 if(operationtimer2==0xA1)SORG1 =~ SORG1; //405 if(operationtimer2==0xA2)SORG2 =~ SORG2; //430 if(operationtimer2==0xA3)SORG3 =~ SORG3; //470 if(operationtimer2==0xA4)SORG4 =~ SORG4; //532 if(operationtimer2==0xA5)SORG5 =~ SORG5; //605 if(operationtimer2==0xA6)SORG6 =~ SORG6; //635 if(operationtimer2==0xA7)SORG7 =~ SORG7; //670 if(operationtimer2==0xA8)SORG8 =~ SORG8; //780 if(operationtimer2==0xA9)SORG9 =~ SORG9; //808 if(operationtimer2==0xB0)SORG10 =~ SORG10; //830 if(operationtimer2==0xB1)SORG11 =~ SORG11; //850 if(operationtimer2==0xB2)SORG12 =~ SORG12; //880 if(operationtimer2==0xB3)SORG13 =~ SORG13; //904 if(operationtimer2==0xB4)SORG14 =~ SORG14; //980 if(operationtimer2==0xB5)SORG15 =~ SORG15; //995 if(operationtimer2==0xB6)SORG16 =~ SORG16; //1020 if(operationtimer2==0xB7)SORG17 =~ SORG17; //1064 if(operationtimer2==0xB8)SORG18 =~ SORG18; //1200 if(operationtimer2==0xB9)SORG19 =~ SORG19;

Appendici

71

void timer3 (void) //Selezione sorgente del timer3 (la sorgente si setta nel processIO) //360 if(operationtimer3==0xA1)SORG1 =~ SORG1; //405 if(operationtimer3==0xA2)SORG2 =~ SORG2; //430 if(operationtimer3==0xA3)SORG3 =~ SORG3; //470 if(operationtimer3==0xA4)SORG4 =~ SORG4; //532 if(operationtimer3==0xA5)SORG5 =~ SORG5; //605 if(operationtimer3==0xA6)SORG6 =~ SORG6; //635 if(operationtimer3==0xA7)SORG7 =~ SORG7; //670 if(operationtimer3==0xA8)SORG8 =~ SORG8; //780 if(operationtimer3==0xA9)SORG9 =~ SORG9; //808 if(operationtimer3==0xB0)SORG10 =~ SORG10; //830 if(operationtimer3==0xB1)SORG11 =~ SORG11; //850 if(operationtimer3==0xB2)SORG12 =~ SORG12; //880 if(operationtimer3==0xB3)SORG13 =~ SORG13; //904 if(operationtimer3==0xB4)SORG14 =~ SORG14; //980 if(operationtimer3==0xB5)SORG15 =~ SORG15; //995 if(operationtimer3==0xB6)SORG16 =~ SORG16; //1020 if(operationtimer3==0xB7)SORG17 =~ SORG17; //1064 if(operationtimer3==0xB8)SORG18 =~ SORG18; //1200 if(operationtimer3==0xB9)SORG19 =~ SORG19; //************************************************************ // Dichiarazione Prototipi di funzione interrupt //************************************************************ // Prototipo di funzione per bassa priorità void Low_Int_Event (void); // Prototipo di funzione per alta priorità void High_Int_Event (void); //************************************************************ // Impostazione e Gestione priorità alta //************************************************************ #pragma code high_vector = 0x08 void high_interrupt (void) // Salto per la gestione dell'interrupt ad alta priorità _asm GOTO High_Int_Event _endasm #pragma code #pragma interrupt High_Int_Event // Funzione dell'interruzione ad alta priorità (generati da Timer) void High_Int_Event (void) // Avvia la funzione che e stata richiamata dall'interrupt // e disabilita l'interrupt generato // Interrupt da Timer 0 if (INTCONbits.TMR0IF == 1) INTCONbits.TMR0IF = 0; timer0(); // Interrupt da Timer 1 if (PIR1bits.TMR1IF == 1) PIR1bits.TMR1IF = 0; timer1(); // Interrupt da Timer 2 if (PIR1bits.TMR2IF == 1) PIR1bits.TMR2IF = 0;

Appendici

72

timer2(); // Interrupt da Timer 3 if (PIR2bits.TMR3IF == 1) PIR2bits.TMR3IF = 0; timer3(); //************************************************************ // Impostazione e Gestione priorità bassa //************************************************************ #pragma code low_vector = 0x18 void low_interrupt (void) // Salto per la gestione dell'interrupt a bassa priorità _asm GOTO Low_Int_Event _endasm #pragma code #pragma interruptlow Low_Int_Event // Funzione per la gestione dell'interruzione a bassa priorità void Low_Int_Event (void) // Prototipi di funzioni di interrupt // Interrupt da Timer 0 if (INTCONbits.TMR0IF == 1 ) INTCONbits.TMR0IF = 0; if (INTCONbits.TMR0IF == 1) INTCONbits.TMR0IF = 0; // Interrupt da Timer 1 if (PIR1bits.TMR1IF == 1) PIR1bits.TMR1IF = 0; // Interrupt da Timer 2 if (PIR1bits.TMR2IF == 1) PIR1bits.TMR2IF = 0; // Interrupt da Timer 3 if (PIR2bits.TMR3IF == 1) PIR2bits.TMR3IF = 0; /***********************template***********************/ volatile unsigned char HIDFeatureBuffer[HID_FEATURE_REPORT_BYTES]; #pragma code char txBuffer[HID_INPUT_REPORT_BYTES]; char rxBuffer[HID_OUTPUT_REPORT_BYTES]; extern byte transferType; void SetupFeatureReport(byte reportID) if (reportID == 0) inPtr = (byte*)&HIDFeatureBuffer; void SetFeatureReport(byte reportID) if (reportID == 0) void GetFeatureReport(byte reportID) if (reportID == 0) outPtr = (byte *)&HIDFeatureBuffer; wCount = HID_FEATURE_REPORT_BYTES; transferType=0; void SetupOutputReport(byte reportID) if (reportID == 0) inPtr = (byte*)&HIDRxBuffer; void SetOutputReport(byte reportID) if (reportID != 0) return; void GetInputReport(byte reportID) if (reportID == 0) outPtr = (byte *)&HIDTxBuffer;

Appendici

73

wCount = HID_INPUT_REPORT_BYTES; transferType=0; //Inizializzazione del PIC */ void UserInit(void) //Inizializzo i pin a valore 0 LATA = 0; LATB = 0; LATC = 0; LATD = 0; LATE = 0; //Inizializzo i pin come IN/OUT TRISA = 0b00000011; //Imposto tutti output eccetto i canali di conversione A/D //Tutti gli altri come OUT TRISB = 0; TRISC = 0; TRISD = 0; TRISE = 0; //Abilitazione interrupt RCONbits.IPEN = 1; //Abilita i libelli di priorità agli interrupt INTCONbits.GIE_GIEH = 1; //Abilita gli interrupt //Impostazioni timer 0 T0CONbits.T08BIT = 0; // Modalità a 16 bit T0CONbits.T0CS = 0; // Clock interno 1 Mhz (interno Fosc/4) T0CONbits.PSA = 0; // Abilito Prescaler T0CONbits.T0PS0 = 0; // Prescaler 1:2 T0CONbits.T0PS1 = 1; // T0CONbits.T0PS2 = 1; // INTCONbits.TMR0IE = 1; // Abilito le interruzioni del Timer0 INTCON2bits.TMR0IP = 1; // Abilito le interruzioni del Timer0 come alta priorità //Impostazioni timer 1 PIE1bits.TMR1IE = 1; // Abilito le interruzioni del Timer1 IPR1bits.TMR1IP = 1; // Abilito le interruzioni del Timer1 come alta priorità T1CONbits.T1OSCEN = 0; // Oscillatore timer1 spento T1CONbits.TMR1CS = 0; // Clock interno 1 Mhz (interno Fosc/4) T1CONbits.T1CKPS1 = 1; // Abilito Prescaler as 1:8 T1CONbits.T1CKPS0 = 1; //Impostazioni timer 2 T2CONbits.T2CKPS1 = 1; // Abilito Prescaler as 1:16 T2CONbits.T2CKPS0 = 1; T2CONbits.T2OUTPS3 = 1; // Abilito postscale 1:16 T2CONbits.T2OUTPS2 = 1; // T2CONbits.T2OUTPS1 = 1; // T2CONbits.T2OUTPS0 = 1; // PR2 = 200; // Valore di un ulteriore post scaler PIE1bits.TMR2IE = 1; // Abilito le interruzioni del Timer2 IPR1bits.TMR2IP = 1; // Abilito le interruzioni del Timer2 come alta priorità //Impostazioni timer 3 PIE2bits.TMR3IE = 1; // Abilito le interruzioni del Timer3 IPR2bits.TMR3IP = 1; // Abilito le interruzioni del Timer3 come alta priorità T3CONbits.T3CKPS1 = 1; // Abilito Prescaler a 1:8 T3CONbits.T3CKPS0 = 1; // T3CONbits.TMR3CS = 0; //Utilizza il clock interno a 1 MHz per timer 3 //Abilitazione di tutti i timer T0CONbits.TMR0ON = 1; // Abilito il Timer0 T1CONbits.TMR1ON = 1; // Abilito il Timer1 T2CONbits.TMR2ON = 1; // Abilito il Timer2 T3CONbits.TMR3ON = 1; // Abilito il Timer3

Appendici

74

//Impostazioni ADC ADCON1 = 0x0D; //imposto AN0 e AN1 come ingressi analogici e setto gli altri bit a zero ADCON2 = 0x8A; //Giustifico a DX setto Tad=0 ed Frc= RC dell'oscillatore ADCON0bits.ADON = 1; //accendo l' ADC ADCON1bits.VCFG0=0; //imposto riferimento su Vcc void ProcessIO(void) /***************template di lettura*****************/ byte rxCnt; rxCnt = HIDRxReport(rxBuffer, HID_OUTPUT_REPORT_BYTES); if (rxCnt == 0)return; //If no bytes in, then nothing to do /****************************************************/ //Assegnazione valore ricevuto operation=rxBuffer[0]; //Controllo in alternata delle sorgenti //Accendo le porte AND PULSE = 1; //360 if(operation==0xC1) while(1) rxCnt = HIDRxReport(rxBuffer, HID_OUTPUT_REPORT_BYTES); operation=rxBuffer[0]; if (operation != 0xC1) return; for(y=0;y<off;y++) delay(); SORG1 =~ SORG1; for(y=0;y<on;y++) delay(); SORG1 =~ SORG1; //405 if(operation==0xC2) while(1) rxCnt = HIDRxReport(rxBuffer, HID_OUTPUT_REPORT_BYTES); operation=rxBuffer[0]; if (operation != 0xC2) return; for(y=0;y<off;y++) delay(); SORG2 =~ SORG2; for(y=0;y<on;y++) delay(); SORG2 =~ SORG2; //430 if(operation==0xC3) while(1) rxCnt = HIDRxReport(rxBuffer, HID_OUTPUT_REPORT_BYTES); operation=rxBuffer[0]; if (operation != 0xC3) return; for(y=0;y<off;y++) delay(); SORG3 =~ SORG3; for(y=0;y<on;y++) delay(); SORG3 =~ SORG3; //470 if(operation==0xC4) while(1) rxCnt = HIDRxReport(rxBuffer, HID_OUTPUT_REPORT_BYTES); operation=rxBuffer[0]; if (operation != 0xC4) return; for(y=0;y<off;y++) delay(); SORG4 =~ SORG4; for(y=0;y<on;y++) delay(); SORG4 =~ SORG4;

Appendici

75

//532 if(operation==0xC5) while(1) rxCnt = HIDRxReport(rxBuffer, HID_OUTPUT_REPORT_BYTES); operation=rxBuffer[0]; if (operation != 0xC5) return; for(y=0;y<off;y++) delay(); SORG5 =~ SORG5; for(y=0;y<on;y++) delay(); SORG5 =~ SORG5; //605 if(operation==0xC6) while(1) rxCnt = HIDRxReport(rxBuffer, HID_OUTPUT_REPORT_BYTES); operation=rxBuffer[0]; if (operation != 0xC6) return; for(y=0;y<off;y++) delay(); SORG6 =~ SORG6; for(y=0;y<on;y++) delay(); SORG6 =~ SORG6; //635 if(operation==0xC7) while(1) rxCnt = HIDRxReport(rxBuffer, HID_OUTPUT_REPORT_BYTES); operation=rxBuffer[0]; if (operation != 0xC7) return; for(y=0;y<off;y++) delay(); SORG7 =~ SORG7; for(y=0;y<on;y++) delay(); SORG7 =~ SORG7; //670 if(operation==0xC8) while(1) rxCnt = HIDRxReport(rxBuffer, HID_OUTPUT_REPORT_BYTES); operation=rxBuffer[0]; if (operation != 0xC8) return; for(y=0;y<off;y++) delay(); SORG8 =~ SORG8; for(y=0;y<on;y++) delay(); SORG8 =~ SORG8; //780 if(operation==0xC9) while(1) rxCnt = HIDRxReport(rxBuffer, HID_OUTPUT_REPORT_BYTES); operation=rxBuffer[0]; if (operation != 0xC9) return; for(y=0;y<off;y++) delay(); SORG9 =~ SORG9; for(y=0;y<on;y++) delay(); SORG9 =~ SORG9; //808 if(operation==0xD0) while(1) rxCnt = HIDRxReport(rxBuffer, HID_OUTPUT_REPORT_BYTES); operation=rxBuffer[0]; if (operation != 0xD0) return; for(y=0;y<off;y++) delay(); SORG10 =~ SORG10;

Appendici

76

for(y=0;y<on;y++) delay(); SORG10 =~ SORG10; //830 if(operation==0xD1) while(1) rxCnt = HIDRxReport(rxBuffer, HID_OUTPUT_REPORT_BYTES); operation=rxBuffer[0]; if (operation != 0XD1) return; for(y=0;y<off;y++) delay(); SORG11 =~ SORG11; for(y=0;y<on;y++) delay(); SORG11 =~ SORG11; //850 if(operation==0xD2) while(1) rxCnt = HIDRxReport(rxBuffer, HID_OUTPUT_REPORT_BYTES); operation=rxBuffer[0]; if (operation != 0xD2) return; for(y=0;y<off;y++) delay(); SORG12 =~ SORG12; for(y=0;y<on;y++) delay(); SORG12 =~ SORG12; //880 if(operation==0xD3) while(1) rxCnt = HIDRxReport(rxBuffer, HID_OUTPUT_REPORT_BYTES); operation=rxBuffer[0]; if (operation != 0xD3) return; for(y=0;y<off;y++) delay(); SORG13 =~ SORG13; for(y=0;y<on;y++) delay(); SORG13 =~ SORG13; //904 if(operation==0xD4) while(1) rxCnt = HIDRxReport(rxBuffer, HID_OUTPUT_REPORT_BYTES); operation=rxBuffer[0]; if (operation != 0xD4) return; for(y=0;y<off;y++) delay(); SORG14 =~ SORG14; for(y=0;y<on;y++) delay(); SORG14 =~ SORG14; //980 if(operation==0xD5) while(1) rxCnt = HIDRxReport(rxBuffer, HID_OUTPUT_REPORT_BYTES); operation=rxBuffer[0]; if (operation != 0xD5) return; for(y=0;y<off;y++) delay(); SORG15 =~ SORG15; for(y=0;y<on;y++) delay(); SORG15 =~ SORG15; //995 if(operation==0xD6) while(1) rxCnt = HIDRxReport(rxBuffer, HID_OUTPUT_REPORT_BYTES); operation=rxBuffer[0]; if (operation != 0xD6) return;

Appendici

77

for(y=0;y<off;y++) delay(); SORG16 =~ SORG16; for(y=0;y<on;y++) delay(); SORG16 =~ SORG16; //1020 if(operation==0xD7) while(1) rxCnt = HIDRxReport(rxBuffer, HID_OUTPUT_REPORT_BYTES); operation=rxBuffer[0]; if (operation != 0xD7) return; for(y=0;y<off;y++) delay(); SORG17 =~ SORG17; for(y=0;y<on;y++) delay(); SORG17 =~ SORG17; //1064 if(operation==0xD8) while(1) rxCnt = HIDRxReport(rxBuffer, HID_OUTPUT_REPORT_BYTES); operation=rxBuffer[0]; if (operation != 0xD8) return; for(y=0;y<off;y++) delay(); SORG18 =~ SORG18; for(y=0;y<on;y++) delay(); SORG18 =~ SORG18; //1200 if(operation==0xD9) while(1) rxCnt = HIDRxReport(rxBuffer, HID_OUTPUT_REPORT_BYTES); operation=rxBuffer[0]; if (operation != 0xD9) return; for(y=0;y<off;y++) delay(); SORG19 =~ SORG19; for(y=0;y<on;y++) delay(); SORG19 =~ SORG19; //**************Controllo in Continua***************// if(operation==0xF4) while(1) // Operazione di lettura rxCnt = HIDRxReport(rxBuffer, HID_OUTPUT_REPORT_BYTES); // Assegnazione valori ricevuti operationcontinua=rxBuffer[1]; operation=rxBuffer[0]; // Accendo-Spengo la sorgente selezionata if (operation!=0xF4) //Attiva sorgente ed esce dal ciclo //360 if(operationcontinua==0xA1)SORG1 =~ SORG1; //405 if(operationcontinua==0xA2)SORG2 =~ SORG2; //430 if(operationcontinua==0xA3)SORG3 =~ SORG3; //470 if(operationcontinua==0xA4)SORG4 =~ SORG4; //532 if(operationcontinua==0xA5)SORG5 =~ SORG5; //605 if(operationcontinua==0xA6)SORG6 =~ SORG6; //635 if(operationcontinua==0xA7)SORG7 =~ SORG7; //670 if(operationcontinua==0xA8)SORG8 =~ SORG8; //780

Appendici

78

if(operationcontinua==0xA9)SORG9 =~ SORG9; //808 if(operationcontinua==0xB0)SORG10 =~ SORG10; //830 if(operationcontinua==0xB1)SORG11 =~ SORG11; //850 if(operationcontinua==0xB2)SORG12 =~ SORG12; //880 if(operationcontinua==0xB3)SORG13 =~ SORG13; //904 if(operationcontinua==0xB4)SORG14 =~ SORG14; //980 if(operationcontinua==0xB5)SORG15 =~ SORG15; //995 if(operationcontinua==0xB6)SORG16 =~ SORG16; //1020 if(operationcontinua==0xB7)SORG17 =~ SORG17; //1064 if(operationcontinua==0xB8)SORG18 =~ SORG18; //1200 if(operationcontinua==0xB9)SORG19 =~ SORG19; return; //****************Controllo timer0*****************// if(operation==0xF0) while(1) //Operazione di lettura rxCnt = HIDRxReport(rxBuffer, HID_OUTPUT_REPORT_BYTES); //Assegnazione valori ricevuti operation=rxBuffer[0]; operationtimer0=rxBuffer[2]; //Attiva il timer0 INTCONbits.TMR0IE =~ INTCONbits.TMR0IE; if (operation!=0xF0)return; //esce dal ciclo //****************Controllo timer1*****************// if(operation==0xF1) while(1) //Operazione di lettura rxCnt = HIDRxReport(rxBuffer, HID_OUTPUT_REPORT_BYTES); //Assegnazione valori ricevuti operation=rxBuffer[0]; operationtimer1=rxBuffer[3]; //Attiva il timer1 PIE1bits.TMR1IE =~ PIE1bits.TMR1IE; if (operation!=0xF1)return; //esce dal ciclo //****************Controllo timer2*****************// if(operation==0xF2) while(1) //Operazione di lettura rxCnt = HIDRxReport(rxBuffer, HID_OUTPUT_REPORT_BYTES); //Assegnazione valori ricevuti operation=rxBuffer[0]; operationtimer2=rxBuffer[4]; //Attiva il timer2 PIE1bits.TMR2IE =~ PIE1bits.TMR2IE; if (operation!=0xF2)return; //esce dal ciclo //****************Controllo timer3*****************// if(operation==0xF3) while(1) //Operazione di lettura rxCnt = HIDRxReport(rxBuffer, HID_OUTPUT_REPORT_BYTES); //Assegnazione valori ricevuti operation=rxBuffer[0]; operationtimer3=rxBuffer[5];

Appendici

79

//Attiva il timer3 PIE2bits.TMR3IE =~ PIE2bits.TMR3IE; if (operation!=0xF3)return; //esce dal ciclo //**************Operazioni di appoggio***************// //Spegimento if(operation==0xF5) spegnimento(); //Controllo motore if(operation==0xF6) cella(); if(operation==0xF7) sidewall(); //Ricezione valori frequenza e duty cicle if(operation==0xF8) BL = rxBuffer[1]; //Riceve la coppia LOW di esadecimali BH = rxBuffer[2]; //Riceve la coppia HIGH di esadecimali frequenza = BL + (BH*256); //Ricompone le coppie di esadecimali in un numero duty_cicle = rxBuffer[3]; duty_cicle = duty_cicle/100; on = (1000*duty_cicle)/frequenza; //normalizzo in millisecondi off = (1000/frequenza) - on; //normalizzato in millisecondi //Conversione ADC su AN0 if(operation==0xF9) byte rxCnt, i; unsigned char valueLSB, valueMSB; unsigned int value=0; ADCON0bits.CHS3 = 0; //imposto i 4 bit di selezione del canale su AN0 ADCON0bits.CHS2 = 0; // ADCON0bits.CHS1 = 0; // ADCON0bits.CHS0 = 0; // ConvertADC(); // Avvia conversione while( BusyADC() ); // Attende completamento value = ReadADC(); valueLSB=value; valueMSB=value>>8; //Prepara il buffer di trasmissione txBuffer[0]=valueLSB; txBuffer[1]=valueMSB; //Conversione ADC su AN1 if(operation==0xFA) byte rxCnt, i; unsigned char valueLSB, valueMSB; unsigned int value=0; ADCON0bits.CHS3 = 0; //imposto i 4 bit di selezione del canale su AN1 ADCON0bits.CHS2 = 0; // ADCON0bits.CHS1 = 0; // ADCON0bits.CHS0 = 1; // ConvertADC(); // Avvia conversione while( BusyADC() ); // Attende completamento value = ReadADC(); valueLSB=value; valueMSB=value>>8; //Prepara il buffer di trasmissione txBuffer[0]=valueLSB; txBuffer[1]=valueMSB;

Appendici

80

/*************************template************************/ while (ep1Bi.Stat & UOWN) /*As long as the SIE iS owned by the processor,we let USB tasks continue*/ ProcessUSBTransactions(); /*The report will be sent in the next interrupt IN transfer*/ HIDTxReport(txBuffer, HID_INPUT_REPORT_BYTES); /**********************************************************/ /*************************template*************************/ //Entry point of the firmware void main(void) ADCON1 |= 0x0F; //Set all I/O pins to digital UCFG = 0x14; //Initialize USB deviceState = DETACHED; remoteWakeup = 0x00; currentConfiguration = 0x00; UserInit(); //Richiama la funzione di inizializzazione while(1) EnableUSBModule(); //Ensure USB module is available if(UCFGbits.UTEYE != 1) ProcessUSBTransactions(); ProcessIO(); //Esegue la routine principale

Appendici

81

C - Interfaccia Visual Basic per la misura

' vendor and product IDs Private Const VendorID = 1240 Private Const ProductID = 511 Private Const BufferInSize = 64 Private Const BufferOutSize = 64 Dim BufferIn(0 To BufferInSize) As Byte Dim BufferOut(0 To BufferOutSize) As Byte ' Dim frequenza As String Dim n Dim frequency As Double ' Attenzione la dimensione dell' array dipende dal numero di campioni che prendo Dim array1() As Double Dim array2() As Double Dim sidsorg1() As Double Dim sidsorg2() As Double Dim sidsorg3() As Double Dim sidsorg4() As Double Dim sidsorg5() As Double Dim sidsorg6() As Double Dim sidsorg7() As Double Dim sidsorg8() As Double Dim sidsorg9() As Double Dim sidsorg10() As Double Dim sidsorg11() As Double Dim sidsorg12() As Double Dim sidsorg13() As Double Dim sidsorg14() As Double Dim sidsorg15() As Double Dim sidsorg16() As Double Dim sidsorg17() As Double Dim sidsorg18() As Double Dim sidsorg19() As Double Dim sorg1 As Integer Dim sorg2 As Integer Dim sorg3 As Integer Dim sorg4 As Integer Dim sorg5 As Integer Dim sorg6 As Integer Dim sorg7 As Integer Dim sorg8 As Integer Dim sorg9 As Integer Dim sorg10 As Integer Dim sorg11 As Integer Dim sorg12 As Integer Dim sorg13 As Integer Dim sorg14 As Integer Dim sorg15 As Integer Dim sorg16 As Integer Dim sorg17 As Integer Dim sorg18 As Integer Dim sorg19 As Integer Dim fase As Integer Dim i As Long Dim k As Integer Dim x() As Double Dim ndat ' Plotto un grafico con i valori calcolati Private Sub Command25_Click() Dim QY(0 To 1, 1 To 20) As Double Dim lam(19) As Double lam(1) = 360: QY(1, 1) = 0.3

Appendici

82

lam(2) = 405: QY(1, 2) = 0.45 lam(3) = 430: QY(1, 3) = 0.6 lam(4) = 470: QY(1, 4) = 0.75 lam(5) = 532: QY(1, 5) = 0.93 lam(6) = 605: QY(1, 6) = 0.94 lam(7) = 635: QY(1, 7) = 0.95 lam(8) = 670: QY(1, 8) = 0.95 lam(9) = 780: QY(1, 9) = 0.95 lam(10) = 808: QY(1, 10) = 0.95 lam(11) = 830: QY(1, 11) = 0.952 lam(12) = 850: QY(1, 12) = 0.94 lam(13) = 880: QY(1, 13) = 0.91 lam(14) = 904: QY(1, 14) = 0.9 lam(15) = 980: QY(1, 15) = 0.75 lam(16) = 995: QY(1, 16) = 0.7 lam(17) = 1020: QY(1, 17) = 0.5 lam(18) = 1064: QY(1, 18) = 0.3 lam(19) = 1200: QY(1, 19) = 0.01 For t = 1 To 19 QY(0, t) = lam(t) Next CWGraph4.PlotXY QY End Sub '**************************************************************** ' Inizializzazione del FORM '**************************************************************** Private Sub Form_Load() i = 1 k = 1 sorg1 = 0 sorg2 = 0 sorg3 = 0 sorg4 = 0 sorg5 = 0 sorg6 = 0 sorg7 = 0 srog8 = 0 sorg9 = 0 sorg10 = 0 sorg11 = 0 sorg12 = 0 sorg13 = 0 sorg14 = 0 srog15 = 0 sorg16 = 0 sorg17 = 0 sorg18 = 0 sorg19 = 0 fase = 0 'ConnectToHID (Me.hwnd) 'MsgBox hidGetHandle(VendorID, ProductID) 'MsgBox hidGetItemCount 'MsgBox hidGetOutputReportLength(hidGetHandle(VendorID, ProductID)) End Sub 'Pulizia textbox Private Sub Command23_Click() Text2.Text = "" Text4.Text = "" Text7.Text = "" Text12.Text = "" Text13.Text = "" CWGraph1.Refresh CWGraph2.Refresh CWGraph3.Refresh CWGraph5.Refresh End Sub 'Quit Button

Appendici

83

Private Sub Command27_Click() End End Sub ' Pulsante START Private Sub Start_Click() DisconnectFromHID ConnectToHID (Me.hwnd) BufferOut(0) = 0 ' first by is always the report ID frequency = CByte(Val(Text3.Text)) n = CByte(Val(Text5.Text)) 'Inizializza il file di testo su cui salvare gli array Open Text8.Text For Output As #1 Print #1, Date; vbTab; Time; vbNewLine; vbNewLine; Print #1, "Frequenza:" & frequency & "Hz"; vbTab; vbTab; "Periodi:" & n; vbNewLine; "Commento:" & " " & Text9.Text; vbNewLine; vbNewLine; Print #1, "Cella"; vbTab; vbTab; vbTab; vbTab; "Detector"; vbNewLine; vbNewLine; Close #1 BufferOut(1) = 161 BufferOut(2) = frequency BufferOut(3) = n hidWriteEx VendorID, ProductID, BufferOut(0) End Sub '**************************************************************** ' Gestione dei grafici '**************************************************************** Private Sub CWGraph1_dblClick() CWGraph1.Axes(1).AutoScaleNow CWGraph1.Axes(2).AutoScaleNow End Sub Sub CWGraph3_dblClick() CWGraph3.Axes(1).AutoScaleNow CWGraph3.Axes(2).AutoScaleNow End Sub Private Sub CWGraph5_dblClick() CWGraph5.Axes(1).AutoScaleNow CWGraph5.Axes(2).AutoScaleNow End Sub ' Pulsante STOP Private Sub stop_Click() DisconnectFromHID ConnectToHID (Me.hwnd) BufferOut(0) = 0 BufferOut(1) = 162 hidWriteEx VendorID, ProductID, BufferOut(0) DisconnectFromHID End Sub ' Spot su CELLA Private Sub Command2_Click() ConnectToHID (Me.hwnd) BufferOut(0) = 0 BufferOut(1) = 164 hidWriteEx VendorID, ProductID, BufferOut(0) DisconnectFromHID End Sub ' Spot su CAMPIONE Private Sub Command1_Click() ConnectToHID (Me.hwnd) BufferOut(0) = 0 BufferOut(1) = 163 hidWriteEx VendorID, ProductID, BufferOut(0) DisconnectFromHID

Appendici

84

End Sub ' Sorgente seguente Private Sub Command3_Click() DisconnectFromHID ConnectToHID (Me.hwnd) BufferOut(0) = 0 ' first by is always the report ID BufferOut(1) = 165 'Inizializza il file di testo su cui salvare gli array Open Text8.Text For Output As #1 Print #1, Date; vbTab; Time; vbNewLine; vbNewLine; Print #1, "Frequenza:" & frequency & "Hz"; vbTab; vbTab; "Periodi:" & n; vbNewLine; "Commento:" & " " & Text9.Text; vbNewLine; vbNewLine; Print #1, "Cella"; vbTab; vbTab; vbTab; vbTab; "Detector"; vbNewLine; vbNewLine; Close #1 hidWriteEx VendorID, ProductID, BufferOut(0) End Sub '360 Private Sub Command4_Click() DisconnectFromHID ConnectToHID (Me.hwnd) sorg1 = 1 BufferOut(0) = 0 ' first by is always the report ID BufferOut(1) = 1 hidWriteEx VendorID, ProductID, BufferOut(0) DisconnectFromHID End Sub '405 Private Sub Command5_Click() sorg2 = 1 DisconnectFromHID ConnectToHID (Me.hwnd) BufferOut(0) = 0 ' first by is always the report ID BufferOut(1) = 2 hidWriteEx VendorID, ProductID, BufferOut(0) DisconnectFromHID End Sub '430 Private Sub Command6_Click() sorg3 = 1 DisconnectFromHID ConnectToHID (Me.hwnd) BufferOut(0) = 0 ' first by is always the report ID BufferOut(1) = 3 hidWriteEx VendorID, ProductID, BufferOut(0) DisconnectFromHID End Sub '470 Private Sub Command7_Click() sorg4 = 1 DisconnectFromHID ConnectToHID (Me.hwnd) BufferOut(0) = 0 ' first by is always the report ID BufferOut(1) = 4 hidWriteEx VendorID, ProductID, BufferOut(0) DisconnectFromHID End Sub '532 Private Sub Command8_Click() sorg5 = 1 DisconnectFromHID ConnectToHID (Me.hwnd) BufferOut(0) = 0 ' first by is always the report ID BufferOut(1) = 5 hidWriteEx VendorID, ProductID, BufferOut(0) DisconnectFromHID End Sub

Appendici

85

'605 Private Sub Command9_Click() sorg6 = 1 DisconnectFromHID ConnectToHID (Me.hwnd) BufferOut(0) = 0 ' first by is always the report ID BufferOut(1) = 6 hidWriteEx VendorID, ProductID, BufferOut(0) DisconnectFromHID End Sub '635 Private Sub Command10_Click() sorg7 = 1 DisconnectFromHID ConnectToHID (Me.hwnd) BufferOut(0) = 0 ' first by is always the report ID BufferOut(1) = 7 hidWriteEx VendorID, ProductID, BufferOut(0) DisconnectFromHID End Sub '670 Private Sub Command11_Click() sorg8 = 1 DisconnectFromHID ConnectToHID (Me.hwnd) BufferOut(0) = 0 ' first by is always the report ID BufferOut(1) = 8 hidWriteEx VendorID, ProductID, BufferOut(0) DisconnectFromHID End Sub '780 Private Sub Command12_Click() sorg9 = 1 DisconnectFromHID ConnectToHID (Me.hwnd) BufferOut(0) = 0 ' first by is always the report ID BufferOut(1) = 9 hidWriteEx VendorID, ProductID, BufferOut(0) DisconnectFromHID End Sub '808 Private Sub Command13_Click() sorg10 = 1 DisconnectFromHID ConnectToHID (Me.hwnd) BufferOut(0) = 0 ' first by is always the report ID BufferOut(1) = 10 hidWriteEx VendorID, ProductID, BufferOut(0) DisconnectFromHID End Sub '830 Private Sub Command14_Click() sorg11 = 1 DisconnectFromHID ConnectToHID (Me.hwnd) BufferOut(0) = 0 ' first by is always the report ID BufferOut(1) = 11 hidWriteEx VendorID, ProductID, BufferOut(0) DisconnectFromHID End Sub '850 Private Sub Command15_Click() sorg12 = 1 DisconnectFromHID ConnectToHID (Me.hwnd) BufferOut(0) = 0 ' first by is always the report ID BufferOut(1) = 12 hidWriteEx VendorID, ProductID, BufferOut(0) DisconnectFromHID End Sub

Appendici

86

'880 Private Sub Command16_Click() sorg13 = 1 DisconnectFromHID ConnectToHID (Me.hwnd) BufferOut(0) = 0 ' first by is always the report ID BufferOut(1) = 13 hidWriteEx VendorID, ProductID, BufferOut(0) DisconnectFromHID End Sub '904 Private Sub Command17_Click() sorg14 = 1 DisconnectFromHID ConnectToHID (Me.hwnd) BufferOut(0) = 0 ' first by is always the report ID BufferOut(1) = 14 hidWriteEx VendorID, ProductID, BufferOut(0) DisconnectFromHID End Sub '980 Private Sub Command18_Click() sorg15 = 1 DisconnectFromHID ConnectToHID (Me.hwnd) BufferOut(0) = 0 ' first by is always the report ID BufferOut(1) = 15 hidWriteEx VendorID, ProductID, BufferOut(0) DisconnectFromHID End Sub '995 Private Sub Command19_Click() sorg16 = 1 DisconnectFromHID ConnectToHID (Me.hwnd) BufferOut(0) = 0 ' first by is always the report ID BufferOut(1) = 16 hidWriteEx VendorID, ProductID, BufferOut(0) DisconnectFromHID End Sub '1020 Private Sub Command20_Click() sorg17 = 1 DisconnectFromHID ConnectToHID (Me.hwnd) BufferOut(0) = 0 ' first by is always the report ID2256 BufferOut(1) = 17 hidWriteEx VendorID, ProductID, BufferOut(0) DisconnectFromHID End Sub '1064 Private Sub Command21_Click() sorg18 = 1 DisconnectFromHID ConnectToHID (Me.hwnd) BufferOut(0) = 0 ' first by is always the report ID BufferOut(1) = 18 hidWriteEx VendorID, ProductID, BufferOut(0) DisconnectFromHID End Sub '1200 Private Sub Command22_Click() sorg19 = 1 DisconnectFromHID ConnectToHID (Me.hwnd) BufferOut(0) = 0 ' first by is always the report ID BufferOut(1) = 19 hidWriteEx VendorID, ProductID, BufferOut(0)

Appendici

87

DisconnectFromHID End Sub 'Spegni tutte le sorgenti in continua Private Sub Command24_Click() DisconnectFromHID ConnectToHID (Me.hwnd) sorg1 = 0 sorg2 = 0 sorg3 = 0 sorg4 = 0 sorg5 = 0 sorg6 = 0 sorg7 = 0 srog8 = 0 sorg9 = 0 sorg10 = 0 sorg11 = 0 sorg12 = 0 sorg13 = 0 sorg14 = 0 srog15 = 0 sorg16 = 0 sorg17 = 0 sorg18 = 0 sorg19 = 0 BufferOut(0) = 0 ' first by is always the report ID BufferOut(1) = 20 hidWriteEx VendorID, ProductID, BufferOut(0) DisconnectFromHID End Sub '***************************************************************** ' disconnect from the HID controller... '***************************************************************** Private Sub Form_Unload(Cancel As Integer) DisconnectFromHID End Sub '***************************************************************** ' a HID device has been plugged in... '***************************************************************** Public Sub OnPlugged(ByVal pHandle As Long) If hidGetVendorID(pHandle) = VendorID And hidGetProductID(pHandle) = ProductID Then ' ** YOUR CODE HERE ** End If End Sub '***************************************************************** ' a HID device has been unplugged... '***************************************************************** Public Sub OnUnplugged(ByVal pHandle As Long) If hidGetVendorID(pHandle) = VendorID And hidGetProductID(pHandle) = ProductID Then ' ** YOUR CODE HERE ** End If End Sub '***************************************************************** ' controller changed notification - calLED ' after ALL HID devices are plugged or unplugged '***************************************************************** Public Sub OnChanged() Dim DeviceHandle As Long ' get the handle of the device we are interested in, then set ' its read notify flag to true - this ensures you get a read ' notification message when there is some data to read... DeviceHandle = hidGetHandle(VendorID, ProductID) hidSetReadNotify DeviceHandle, True End Sub '***************************************************************** ' on read event... '***************************************************************** Public Sub OnRead(ByVal pHandle As Long) Dim j As Integer, k As Integer, z As Long Dim stringa As Integer

Appendici

88

Dim varap1 As Byte, varap2 As Byte Dim varap3 As Byte, varap4 As Byte Dim df As Variant ' Indice per il buffer j = 0 ' Indice per comunicazione PIC stringa = 0 If (hidRead(pHandle, BufferIn(0))) Then ' Salva il valore proveniente dal PIC stringa = BufferIn(64) ' Se il PIC invia istruzione di elaborazione If stringa = 149 Then ' Aggiungo un gruppo di casella ai miei array senza ' cancellare i dati per inserire i successivi dati ' che sto trasmettendo ReDim Preserve array1(i + 14) As Double ReDim Preserve array2(i + 14) As Double ' Scrivo i dati che ricevo negli array For j = 1 To 60 Step 4 ' Legge il numero di passi di conversione varap1 = BufferIn(j) varap2 = BufferIn(j + 1) varap3 = BufferIn(j + 2) varap4 = BufferIn(j + 3) ' Calcola in TENSIONE la lettura array1(i) = (varap1 + varap2 * 256) * (4.95 / 4.095) array2(i) = (varap3 + varap4 * 256) * (4.95 / 4.095) ' Salva su di un altro array i valori della sorgente ' sul detector su sidewall che stai misurando If k = 1 And sorg1 = 0 Then sidsorg1(i) = array1(i) Else k = k + 1 End If If k = 2 And sorg2 = 0 Then sidsorg2(i) = array1(i) Else k = k + 1 End If If k = 3 And sorg3 = 0 Then sidsorg3(i) = array1(i) Else k = k + 1 End If If k = 4 And sorg4 = 0 Then sidsorg4(i) = array1(i) Else k = k + 1 End If If k = 5 And sorg5 = 0 Then sidsorg5(i) = array1(i) Else k = k + 1 End If If k = 6 And sorg6 = 0 Then sidsorg6(i) = array1(i) Else k = k + 1 End If If k = 7 And sorg7 = 0 Then sidsorg7(i) = array1(i) Else k = k + 1 End If

Appendici

89

If k = 8 And sorg8 = 0 Then sidsorg8(i) = array1(i) Else k = k + 1 End If If k = 9 And sorg9 = 0 Then sidsorg9(i) = array1(i) Else k = k + 1 End If If k = 10 And sorg10 = 0 Then sidsorg5(i) = array1(i) Else k = k + 1 End If If k = 11 And sorg11 = 0 Then sidsorg11(i) = array1(i) Else k = k + 1 End If If k = 12 And sorg12 = 0 Then sidsorg12(i) = array1(i) Else k = k + 1 End If If k = 13 And sorg13 = 0 Then sidsorg13(i) = array1(i) Else k = k + 1 End If If k = 14 And sorg14 = 0 Then sidsorg14(i) = array1(i) Else k = k + 1 End If If k = 15 And sorg15 = 0 Then sidsorg15(i) = array1(i) Else k = k + 1 End If If k = 16 And sorg16 = 0 Then sidsorg16(i) = array1(i) Else k = k + 1 End If If k = 17 And sorg17 = 0 Then sidsorg17(i) = array1(i) Else k = k + 1 End If If k = 18 And sorg18 = 0 Then sidsorg18(i) = array1(i) Else k = k + 1 End If If k = 19 And sorg19 = 0 Then sidsorg19(i) = array1(i) fase = 1 Else k = k + 1 fase = 1 End If ' Sposta l'indice dell' array per la prossima casella i = i + 1

Appendici

90

Next j End If ' Se ho terminato con una sorgente If (stringa = 159) Then ' Elabori i dati salvati sull'array Text12.Text = "stop sorgente" Text2.Text = i ' Visualizzo la dimensione array ' Grafico il segnale che sto ricevendo dei due canali CWGraph1.PlotY array1 CWGraph2.PlotY array2 '****************************************** ' Elaborazione dei dati '****************************************** m = 0 While 2 ^ m < i m = m + 1 Wend ndat = 2 ^ (m - 1) ReDim x(ndat - 1) For m = 0 To ndat - 1 x(m) = array1(m) Next ' Passo di campionamento dt = (n / frequency) / i Text13.Text = dt CWDSP1.AutoPowerSpectrum x, dt, mgPowerSpectrumReal, df CWDSP1.AmpPhaseSpectrum x, 0, dt, ampspectr, phasespectr, df ReDim disegno(0 To 1, 0 To ndat / 2 - 1) maxAmp2 = 0 For m = 0 To ndat / 2 - 1 disegno(0, m) = df * (m) disegno(1, m) = mgPowerSpectrumReal(m) If disegno(0, m) > (frequency - frequency / 3) Then If disegno(1, m) > maxAmp2 Then maxAmp2 = disegno(1, m) End If If disegno(0, m) < (frequency + frequency / 3) Then If disegno(1, m) > maxAmp2 Then maxAmp2 = disegno(1, m) End If Next CWGraph3.Plots(1).PlotXY disegno maxAmp1 = 0 For m = 0 To ndat / 2 - 1 disegno(0, m) = df * (m) disegno(1, m) = ampspectr(m) If disegno(0, m) > (frequency - frequency / 3) Then If disegno(1, m) > maxAmp1 Then maxAmp1 = disegno(1, m) End If If disegno(0, m) < (frequency + frequency / 3) Then If disegno(1, m) > maxAmp1 Then maxAmp1 = disegno(1, m) End If Next CWGraph5.Plots(1).PlotXY disegno ' Reinizializzo i per la prossima sorgente i = 1 'Vado alla sorgente successiva k = k + 1 End If End If End Sub

Appendici

91

D - Interfaccia Visual Studio per il debug

#pragma once #include <iostream> // std::cout #include <fstream> #include <string> // std::string, std::stoi #include <windows.h> #include <stdio.h> namespace provainterfaccia2 using namespace System; using namespace System::ComponentModel; using namespace System::Collections; using namespace System::Windows::Forms; using namespace System::Data; using namespace System::Drawing; using namespace System::IO; unsigned int i=0; unsigned char a=0; /**************************************************************************************************/ // // IL TEMPLATE DEL FORM NON È STATO INSERITO PER COMODITÀ // /**************************************************************************************************/ private: System::Void button1_Click(System::Object^ sender, System::EventArgs^ e) unsigned char OutputPacketBuffer[65]; unsigned char BL = 0; //byte basso (due valori esadecimali) unsigned char BH = 0; //byte alto (due valori esadecimali) // Assegna a frequenza e duty cicle il valore inserito nella textbox convertendolo in INT32 System::Int32 frequenza = System::Convert::ToInt32(textBox1->Text); System::Int32 duty = System::Convert::ToInt32(textBox2->Text); //Algorirtmo di scomposizione lampeggi in due coppie di esadecimali; BH = frequenza>>8; //shift a destra di 8 posizioni BL = frequenza & 0xFF; // metto a zero gli 8 bit più a sinistra //Assegno il valore ottenuto ad un Output e gli do un identificativo da inviare a MPLAB OutputPacketBuffer[1] = 0xF8; //Invia il codice identificativo dell'invio della frequenza

OutputPacketBuffer[2] = BL; //Assegna il numero di lampeggi all OutputPacketBuffer 2 in MPLAP = 1 OutputPacketBuffer[3] = BH; //Assegna il numero di lampeggi all OutputPacketBuffer 3 in MPLAP = 2 OutputPacketBuffer[4] = duty; //Assegna il valore di frequenza all OutputPacketBuffer 2 if (!hidUSBmoduleControl1->Write(OutputPacketBuffer)) return; //quando invii ti invia tutto l array di byte conpresa la frequenza che andreai a leggere dall altra parte private: System::Void button2_Click(System::Object^ sender, System::EventArgs^ e) //Spegnimento unsigned char OutputPacketBuffer[65]; OutputPacketBuffer[1]=0xF5; if (!hidUSBmoduleControl1->Write(OutputPacketBuffer)) return; private: System::Void textBox1_TextChanged(System::Object^ sender, System::EventArgs^ e) private: System::Void Form1_Load(System::Object^ sender, System::EventArgs^ e) private: System::Void button3_Click(System::Object^ sender, System::EventArgs^ e) unsigned char OutputPacketBuffer[65]; //Cella

Appendici

92

OutputPacketBuffer[1]=0xF6; if (!hidUSBmoduleControl1->Write(OutputPacketBuffer)) return; private: System::Void button4_Click(System::Object^ sender, System::EventArgs^ e) unsigned char OutputPacketBuffer[65]; //Sidewall OutputPacketBuffer[1]=0xF7; if (!hidUSBmoduleControl1->Write(OutputPacketBuffer)) return; private: System::Void button5_Click(System::Object^ sender, System::EventArgs^ e) unsigned char OutputPacketBuffer[65]; unsigned char* InputPacketBuffer; double Vdec=0; //LETTURA ADC AN1 for(int i=0;i<10;i++) OutputPacketBuffer[1]=0xFA; if (!hidUSBmoduleControl1->Write(OutputPacketBuffer)) return; InputPacketBuffer=hidUSBmoduleControl1->Read(); Vdec+=((double)((((unsigned int)(InputPacketBuffer[2]))<<8)|((unsigned int)(InputPacketBuffer[1]))))*4.95/1023; Vdec=Vdec/10; textBox3->Text=String::Format("0:N3",Vdec); private: System::Void button6_Click(System::Object^ sender, System::EventArgs^ e) unsigned char OutputPacketBuffer[65]; unsigned char* InputPacketBuffer; double Vdec=0; //LETTURA ADC AN0 or(int i=0; i<10; i++) OutputPacketBuffer[1]=0xF9; if (!hidUSBmoduleControl1->Write(OutputPacketBuffer)) return; InputPacketBuffer=hidUSBmoduleControl1->Read(); Vdec+=((double)((((unsigned int)(InputPacketBuffer[2]))<<8)|((unsigned int)(InputPacketBuffer[1]))))*4.95/1023; Vdec=Vdec/10; textBox3->Text=String::Format("0:N3",Vdec); private: System::Void button9_Click(System::Object^ sender, System::EventArgs^ e) unsigned char OutputPacketBuffer[65]; //Timer 1 OutputPacketBuffer[1]=0xF1; if (!hidUSBmoduleControl1->Write(OutputPacketBuffer)) return; private: System::Void button11_Click(System::Object^ sender, System::EventArgs^ e) unsigned char OutputPacketBuffer[65]; //360 OutputPacketBuffer[1]=0xC1; OutputPacketBuffer[2]=0xA1; OutputPacketBuffer[3]=0xA1; OutputPacketBuffer[4]=0xA1; OutputPacketBuffer[5]=0xA1; OutputPacketBuffer[6]=0xA1; if (!hidUSBmoduleControl1->Write(OutputPacketBuffer)) return; private: System::Void button12_Click(System::Object^ sender, System::EventArgs^ e) unsigned char OutputPacketBuffer[65]; //405 OutputPacketBuffer[1]=0xC2; OutputPacketBuffer[2]=0xA2; OutputPacketBuffer[3]=0xA2; OutputPacketBuffer[4]=0xA2; OutputPacketBuffer[5]=0xA2; OutputPacketBuffer[6]=0xA2; if (!hidUSBmoduleControl1->Write(OutputPacketBuffer)) return; private: System::Void button13_Click(System::Object^ sender, System::EventArgs^ e) unsigned char OutputPacketBuffer[65];

Appendici

93

//430 OutputPacketBuffer[1]=0xC3; OutputPacketBuffer[2]=0xA3; OutputPacketBuffer[3]=0xA3; OutputPacketBuffer[4]=0xA3; OutputPacketBuffer[5]=0xA3; OutputPacketBuffer[6]=0xA3; if (!hidUSBmoduleControl1->Write(OutputPacketBuffer)) return; private: System::Void button14_Click(System::Object^ sender, System::EventArgs^ e) unsigned char OutputPacketBuffer[65]; //470 OutputPacketBuffer[1]=0xC4; OutputPacketBuffer[2]=0xA4; OutputPacketBuffer[3]=0xA4; OutputPacketBuffer[4]=0xA4; OutputPacketBuffer[5]=0xA4; OutputPacketBuffer[6]=0xA4; if (!hidUSBmoduleControl1->Write(OutputPacketBuffer)) return; private: System::Void button15_Click(System::Object^ sender, System::EventArgs^ e) unsigned char OutputPacketBuffer[65]; //532 OutputPacketBuffer[1]=0xC5; OutputPacketBuffer[2]=0xA5; OutputPacketBuffer[3]=0xA5; OutputPacketBuffer[4]=0xA5; OutputPacketBuffer[5]=0xA5; OutputPacketBuffer[6]=0xA5; if (!hidUSBmoduleControl1->Write(OutputPacketBuffer)) return; private: System::Void button16_Click(System::Object^ sender, System::EventArgs^ e) unsigned char OutputPacketBuffer[65]; //605 OutputPacketBuffer[1]=0xC6; OutputPacketBuffer[2]=0xA6; OutputPacketBuffer[3]=0xA6; OutputPacketBuffer[4]=0xA6; OutputPacketBuffer[5]=0xA6; OutputPacketBuffer[6]=0xA6; if (!hidUSBmoduleControl1->Write(OutputPacketBuffer)) return; private: System::Void button17_Click(System::Object^ sender, System::EventArgs^ e) unsigned char OutputPacketBuffer[65]; //635 OutputPacketBuffer[1]=0xC7; OutputPacketBuffer[2]=0xA7; OutputPacketBuffer[3]=0xA7; OutputPacketBuffer[4]=0xA7; OutputPacketBuffer[5]=0xA7; OutputPacketBuffer[6]=0xA7; if (!hidUSBmoduleControl1->Write(OutputPacketBuffer)) return; private: System::Void button18_Click(System::Object^ sender, System::EventArgs^ e) unsigned char OutputPacketBuffer[65]; //670 OutputPacketBuffer[1]=0xC8; OutputPacketBuffer[2]=0xA8; OutputPacketBuffer[3]=0xA8; OutputPacketBuffer[4]=0xA8; OutputPacketBuffer[5]=0xA8; OutputPacketBuffer[6]=0xA8; if (!hidUSBmoduleControl1->Write(OutputPacketBuffer)) return; private: System::Void button19_Click(System::Object^ sender, System::EventArgs^ e) //780 unsigned char OutputPacketBuffer[65]; OutputPacketBuffer[1]=0xC9; OutputPacketBuffer[2]=0xA9; OutputPacketBuffer[3]=0xA9;

Appendici

94

OutputPacketBuffer[4]=0xA9; OutputPacketBuffer[5]=0xA9; OutputPacketBuffer[6]=0xA9; if (!hidUSBmoduleControl1->Write(OutputPacketBuffer)) return; private: System::Void button20_Click(System::Object^ sender, System::EventArgs^ e) unsigned char OutputPacketBuffer[65]; //808 OutputPacketBuffer[1]=0xD0; OutputPacketBuffer[2]=0xB0; OutputPacketBuffer[3]=0xB0; OutputPacketBuffer[4]=0xB0; OutputPacketBuffer[5]=0xB0; OutputPacketBuffer[6]=0xB0; if (!hidUSBmoduleControl1->Write(OutputPacketBuffer)) return; private: System::Void button21_Click(System::Object^ sender, System::EventArgs^ e) unsigned char OutputPacketBuffer[65]; //830 OutputPacketBuffer[1]=0xD1; OutputPacketBuffer[2]=0xB1; OutputPacketBuffer[3]=0xB1; OutputPacketBuffer[4]=0xB1; OutputPacketBuffer[5]=0xB1; OutputPacketBuffer[6]=0xB1; if (!hidUSBmoduleControl1->Write(OutputPacketBuffer)) return; private: System::Void button22_Click(System::Object^ sender, System::EventArgs^ e) unsigned char OutputPacketBuffer[65]; //850 OutputPacketBuffer[1]=0xD2; OutputPacketBuffer[2]=0xB2; OutputPacketBuffer[3]=0xB2; OutputPacketBuffer[4]=0xB2; OutputPacketBuffer[5]=0xB2; OutputPacketBuffer[6]=0xB2; if (!hidUSBmoduleControl1->Write(OutputPacketBuffer)) return; private: System::Void button23_Click(System::Object^ sender, System::EventArgs^ e) unsigned char OutputPacketBuffer[65]; //880 OutputPacketBuffer[1]=0xD3; OutputPacketBuffer[2]=0xB3; OutputPacketBuffer[3]=0xB3; OutputPacketBuffer[4]=0xB3; OutputPacketBuffer[5]=0xB3; OutputPacketBuffer[6]=0xB3; if (!hidUSBmoduleControl1->Write(OutputPacketBuffer)) return; private: System::Void button24_Click(System::Object^ sender, System::EventArgs^ e) unsigned char OutputPacketBuffer[65]; //904 OutputPacketBuffer[1]=0xD4; OutputPacketBuffer[2]=0xB4; OutputPacketBuffer[3]=0xB4; OutputPacketBuffer[4]=0xB4; OutputPacketBuffer[5]=0xB4; OutputPacketBuffer[6]=0xB4; if (!hidUSBmoduleControl1->Write(OutputPacketBuffer)) return; private: System::Void button25_Click(System::Object^ sender, System::EventArgs^ e) unsigned char OutputPacketBuffer[65]; //980 OutputPacketBuffer[1]=0xD5; OutputPacketBuffer[2]=0xB5; OutputPacketBuffer[3]=0xB5; OutputPacketBuffer[4]=0xB5; OutputPacketBuffer[5]=0xB5; OutputPacketBuffer[6]=0xB5; if (!hidUSBmoduleControl1->Write(OutputPacketBuffer))

Appendici

95

return; private: System::Void button26_Click(System::Object^ sender, System::EventArgs^ e) unsigned char OutputPacketBuffer[65]; //995 OutputPacketBuffer[1]=0xD6; OutputPacketBuffer[2]=0xB6; OutputPacketBuffer[3]=0xB6; OutputPacketBuffer[4]=0xB6; OutputPacketBuffer[5]=0xB6; OutputPacketBuffer[6]=0xB6; if (!hidUSBmoduleControl1->Write(OutputPacketBuffer)) return; private: System::Void button27_Click(System::Object^ sender, System::EventArgs^ e) unsigned char OutputPacketBuffer[65]; //1020 OutputPacketBuffer[1]=0xD7; OutputPacketBuffer[2]=0xB7; OutputPacketBuffer[3]=0xB7; OutputPacketBuffer[4]=0xB7; OutputPacketBuffer[5]=0xB7; OutputPacketBuffer[6]=0xB7; if (!hidUSBmoduleControl1->Write(OutputPacketBuffer)) return; private: System::Void button28_Click(System::Object^ sender, System::EventArgs^ e) unsigned char OutputPacketBuffer[65]; //1064 OutputPacketBuffer[1]=0xD8; OutputPacketBuffer[2]=0xB8; OutputPacketBuffer[3]=0xB8; OutputPacketBuffer[4]=0xB8; OutputPacketBuffer[5]=0xB8; OutputPacketBuffer[6]=0xB8; if (!hidUSBmoduleControl1->Write(OutputPacketBuffer)) return; private: System::Void button29_Click(System::Object^ sender, System::EventArgs^ e) unsigned char OutputPacketBuffer[65]; //1200 OutputPacketBuffer[1]=0xD9; OutputPacketBuffer[2]=0xB9; OutputPacketBuffer[3]=0xB9; OutputPacketBuffer[4]=0xB9; OutputPacketBuffer[5]=0xB9; OutputPacketBuffer[6]=0xB9; if (!hidUSBmoduleControl1->Write(OutputPacketBuffer)) return; private: System::Void button7_Click(System::Object^ sender, System::EventArgs^ e) unsigned char OutputPacketBuffer[65]; //Selezione sorgente in continua OutputPacketBuffer[1]=0xF4; if (!hidUSBmoduleControl1->Write(OutputPacketBuffer)) return; private: System::Void button8_Click(System::Object^ sender, System::EventArgs^ e) unsigned char OutputPacketBuffer[65]; //Timer 0 OutputPacketBuffer[1]=0xF0; if (!hidUSBmoduleControl1->Write(OutputPacketBuffer)) return; private: System::Void button10_Click(System::Object^ sender, System::EventArgs^ e) unsigned char OutputPacketBuffer[65]; //Timer 2 OutputPacketBuffer[1]=0xF2; if (!hidUSBmoduleControl1->Write(OutputPacketBuffer)) return; private: System::Void button30_Click(System::Object^ sender, System::EventArgs^ e) unsigned char OutputPacketBuffer[65]; //Timer 3 OutputPacketBuffer[1]=0xF3; if (!hidUSBmoduleControl1->Write(OutputPacketBuffer))

Appendici

96

return; private: System::Void button31_Click(System::Object^ sender, System::EventArgs^ e) String^ path = "C:\\Users\\Stefano\\Desktop\\Misura.txt"; // This text is added only once to the file. if ( !File::Exists( path ) ) // Create a file to write to. StreamWriter^ sw = File::CreateText( path ); try sw->Write("Data di misura: "); sw->WriteLine(DateTime::Now); finally if ( sw ) delete (IDisposable^)sw; //Concatenazione // This text is always added, making the file longer over time // if it is not deleted. StreamWriter^ sw = File::AppendText( path ); try sw->WriteLine( "This" ); sw->WriteLine( "is Extra" ); sw->WriteLine( "Text" ); finally if ( sw ) delete (IDisposable^)sw; // Open the file to read from. StreamReader^ sr = File::OpenText( path ); try String^ s = ""; while ( s = sr->ReadLine() ) textBox1->Text= s ; finally if ( sr ) delete (IDisposable^)sr; ;

97

Bibliografia

Sfera Integratrice:

[1] David G. Goebel, “A guide to integrating sphere radiometry and photometry” (2015)

[2] David G. Goebel, “A guide to integrating sphere theory and applications” (2015)

[3] Leonard M. Hanssen, Keith A. Snail, “Integrating Spheres for Mid- and Near-infrared Reflection

Spectroscopy”

[4] Leonard Hanssen, “Integrating-sphere system and method for absolute measurement of

transmittance, reflectance, and absorptance of specular samples”

[5] A.H.Taylor, “The measurement of diffuse reflection factors and a new absolute reflectometer”

[6] Labsphere, “A Guide to Integrating Sphere Theory and Applications”

Elettronica:

Microchip; PIC18F4553-PIC18F4550, datasheet;

Texas Instruments; CD4081B, datasheet;

Texas Instruments; OPA656U, datasheet;

Texas Instruments; LMP7721, datasheet;

National Semiconductor; LMC660, datasheet;

Roithner LASERtechnick; DL-3146-151, LASER Diode datasheet;

Roithner LASERtechnick; QL63D4SA, LASER Diode datasheet;

Roithner LASERtechnick; S6705MG, LASER Diode datasheet;

Roithner LASERtechnick; QL78D6SA, LASER Diode datasheet;

Roithner LASERtechnick; RLT80805MGS, LASER Diode datasheet;


Roithner LASERtechnick; QL85F6SA, LASER Diode datasheet;


Roithner LASERtechnick; RLT904-05MG, LASER Diode datasheet;


Roithner LASERtechnick; RLT995-5MG, LASER Diode datasheet;

Roithner LASERtechnick; XSL-360-3E, LED datasheet;

Roithner LASERtechnick; LED430-33, LED datasheet;

98

Roithner LASERtechnick; B3B-447-IX, LED datasheet;

Roithner LASERtechnick; B3B-445-30S, LED datasheet;

Roithner LASERtechnick; ELD-1020-525, LED datasheet;

Roithner LASERtechnick; LED1200-06, LED datasheet.

Ottica ed altro:

www.roithner-LASER.com

Photovoltaic CDROM of Photovoltaics Special Research Centre.

Software utilizzati:

Microsoft Office 2013.

Microsoft Visual Studio 2010.

MICROCHIP MPLAB IDE v8.84.

Altium Designer v14.3.

Programmazione:

Microchip; MPLAB C18 C Complier User’s Guide.

Microchip; MPLAB C18 C Compiler Getting Started.

Microchip; PIC18 Peripheral Library Help Document.

C18 Step By Step Seconda Edizione; Mauro Laurenti.

Manuale Visual Studio C++ 2010.

Manuale Altium Deisgner 14.

http://www.roithner-laser.com/

http://www.roithner-laser.com/

99

Ringraziamenti

Desidero ringraziare la Prof. Rita Asquini, per avermi dato la possibilità di svolgere la mia

esperienza di tesi sotto la sua supervisione e per avermi dato la possibilità di andare a

svolgerla presso il Centro di Ricerche ENEA di Casaccia.

Ringrazio l’Ing. Dr. Mario Tucci, che mi ha accolto nel Centro di Ricerche ENEA e mi ha

dato la possibilità di lavorare su un progetto totalmente innovativo quale la realizzazione

di un sistema di misura prototipale. Lo ringrazio per la sua presenza ed il suo aiuto oltre

che per il suo approccio estremamente umano che ha reso la mia esperienza di tesi

un’esperienza stimolante e proficua.

Ringrazio Luca Martini, per l’aiuto fornitomi durante il lavoro sia teorico che pratico, per la

pazienza nei miei confronti e le chiacchierate durante i viaggi che ci riportavano verso casa

dopo lunghe e stancanti giornate in laboratorio (a volte anche prive di risultati).

Ringrazio tutti i componenti dell’Unità Tecnica di Fonti Rinnovabili del Centro Ricerche

ENEA per la loro cordialità e disponibilità, di cui tengo a nominare gli elementi che più mi

hanno guidato all’arrivo nell’adattarmi al nuovo ambiente quali Alberto Mittiga, Massimo

Izzi, Claudia Malerba, Rosa Chierchia e Luca Serenelli.

Ringrazio poi Lorenzo Imbimbo, altro tesista presente nel dipartimento nonché ormai ex-

compagno di corso di studi, per le chiacchierate, l’aiuto ed i confronti sul proprio lavoro.

Non posso poi non ringraziare i miei genitori, Juan e Daniela, mio fratello Manuel ed i miei

nonni Renato e Grazia per il sostegno in questi lunghi anni da studente universitario e

perché sono la mia famiglia più vicina, intendendo con tale termine non solo un aggregato

di persone legate da vincoli parentali e costretti in abituali incontri ma un riferimento

concreto e sempre presente.

Un particolare ringraziamento va a mio padre, che oltre al suo ruolo di genitore mi ha

aiutato concretamente nella stesura del software necessario per il funzionamento del

sistema, essendo lui esperto nel settore, dandomi una mano per la scrittura di alcune linee

di codice, oltre ad idee per ottimizzarlo e materiale da cui attingere per ulteriori

informazioni.

Per ultima, ma sicuramente non per importanza, un infinito grazie va alla persona che amo

da diversi anni ormai, Angela, che con il suo amore rende ogni giorno speciale, ti amo.

Sviluppo ed ottimizzazione di un sistema innovativo per la misura di efficienza quantica interna di...

Documents

Transcript of Sviluppo ed ottimizzazione di un sistema innovativo per la misura di efficienza quantica interna di...