sistemi complessi adattativi

Page 1

UNIVERSITA’ DEGLI STUDI DI CATANIA

Corso di Laurea in Ingegneria dell’ Automazione e Controllo dei sistemi complessi

Sistemi complessi adattativi Anno 2008/09

Prof. Ing. L. Fortuna

Di Mauro Gianluca Patti Giuseppe

Ing. M.Frasca Ing. A.Buscarino Ing. C. Camerano

1

Sommario 1 Introduzione…………………………………………………………………………………pag. 4 2 Il Caos……………………………………………………………………………..….………..pag. 5 2.1 Sensitività alle condizioni iniziali ………….…………………………….pag.6 2.1.1 Esponenti di Lyapunov …………………………………………..pag.7 2.1.2 D∞………………………………………………………………………….pag.8 2.2 Sistemi caotici………………………………………………………………….pag.10 2.2.1 Sistema di lorenz ……………………………………………….…pag.10 2.2.2 Sistema di Rossler……………………………………………….…pag.12 2.2.3 Circuito di Chua ……………………………………………………pag.16 2.3 Le Spiral waves…………………………………………………………………pag.18 2.3.1 B-Z Reaction……………………………………………………….…pag.18 2.3.2 Modello si FitzHugh-Nagumo………………………….…....pag.20 2.3.2.1 Autoonde tramite FitzHugh-Nagumo…………pag.21 3 Il Software…………………………………………………………………………….....….pag.24 3.1 Mplab……………………………………………………………………………….pag.24 3.2 Pic Kit 2……………………………………………………………………….…...pag.25 3.3 Tool Matlab………………………………………………………………………pag.26 3.3.1 Chaotic Dynamic……………………………………………………pag.27 3.3.2 II Sezione….………………………………………………………..…pag.34 2

4 Hardware………………………………………………………………………………….…pag.36 4.1 la led Matrix…………………………………………………………………..…pag.36 4.2 La DemoBoard………………………………………………………………….pag.38 4.2.1 Il PIC………………………………………………………………………pag.39 4.3 Il Programmatore…………………………………………………………..…pag.42 5 Simulazioni………………………………………………………………………………..…pag.45 5.1 Il sistema di Lorenz………………………………………………………..…pag.45 5.2 Il sistema di Rossler…….…………………………………………………….pag.47 5.3 Il circuito di Chua……………………………………………………………...pag.50 5.4 La BZ reaction…………………………………………………………………..pag.52 5.5 Autowaves FitzHugh-Nagumo………………………………………….pag.53 APPENDICE A…………………………………………………………………………….……pag.56 APPENDICE B………………………………………………………….…………………….…pag.77

3

1. Introduzione Overview

Scopo della tesina di sistemi adattativi è stato lo sviluppo di un tool per la visualizzazione di argomenti di interesse affrontati durante il corso. Lo studio è stato incentrato principalmente sulla rappresentazione dei sistemi caotici quali: Lorenz, Chua, Rossler e sulla BZ-reaction, al sistema di visualizzazione software, ottenuto con l’ausilio di Matlab, è stato affiancato l’uso di una led matrix, sistema di visualizzazione mediante led, già in uso in molti pannelli informativi. Sulla matrice è possibile la visualizzazione di più frame in sequenza dei sistemi prima esposti.

Fig.1 esempio di visualizzazione tramite led matrix.

4

2. Il Caos

Il concetto di caos e' usato sempre piĂš spesso nella letteratura divulgativa e nel linguaggio comune. In realtĂ non esiste una definizione universalmente accettata, anche se comunemente viene definito caos il comportamento aperiodico a lungo termine in un sistema deterministico che mostra sensibile dipendenza alle condizioni iniziali. Con questo termine, viene quindi indicata una classe di sistemi dinamici che hanno un comportamento intermedio tra un andamento regolare, periodico o quasi periodico, ed un andamento stocastico e del tutto imprevedibile.

In particolare, l’evoluzione di un sistema caotico è determinata da un sistema di equazioni differenziali (del III ordine se continuo e II se discreto) non lineari del tipo đ?‘‘đ?‘‘đ?‘‘đ?‘‘ (đ?‘Ąđ?‘Ą)

nel caso continuo,

đ?‘‘đ?‘‘đ?‘‘đ?‘‘

=F(x(t))

đ?‘‹đ?‘‹(đ?‘Ąđ?‘Ą + 1) = đ??šđ??š(đ?‘Ľđ?‘Ľ (đ?‘Ąđ?‘Ą))

(2.1)

(2.2)

nel caso discreto. Inoltre le orbite descritte dal punto x(t), che all’ aumentare del tempo t tendono ad occupare un sottoinsieme dello spazio delle fasi, detto attrattore, sono caratterizzate :da un’elevata complessitĂ , dall’assenza di periodicitĂ , dalla dipendenza (come si vedrĂ esponenziale ) dalle condizioni iniziali. In realtĂ , è bene precisare, che a differenza di un sistema regolare, in cui l’attrattore può essere rappresentato da un punto, un’orbita periodica o quasi periodica, invece, nel caso di un sistema caotico si parlerĂ di attrattore strano (Strange attractor), in 5

quanto le traiettorie passanti da punti anche molto vicini finiscono per divergere, perchè fortemente dipendenti dalle condizioni iniziali.

2.1 Sensitività alle condizioni iniziali, Esponenti di Lyapunov e D∞ Se un sistema è deterministico, come è lecito immaginarsi, ad ogni condizione iniziale corrisponde una singola traiettoria e, a condizioni iniziali diverse corrispondono traiettorie diverse. Secoli di scienza basata su modelli lineari o linearizzati ci hanno indotto a pensare che solo la presenza di eventi casuali, cioè non deterministici, e soprattutto macroscopici, può giustificare risultati molto diversi a partire da condizioni iniziali simili tra loro. Viene spontaneo pensare che, qualsiasi piccola perturbazione dello stato iniziale di un sistema, corrisponda necessariamente a variazioni altrettanto piccole nel comportamento finale. Ciò nel caso di sistemi caotici non è vero, infatti, anche piccolissime variazioni nelle condizioni iniziali possono portare due identici sistemi caotici, posti a confronto in stati totalmente diversi a un tempo determinato. Dunque potrà capitare che, dopo un breve periodo in cui le due situazioni sono molto simili, le traiettorie si allontanino, pur restando ovviamente, confinate all’interno dell’attrattore. Poiché questa proprietà, come accennato in precedenza, rappresenta per molti la definizione stessa di sistema caotico, è stato necessario trovare un metodo che permettesse di quantificare questa dipendenza, dando una misura della “caoticità” e quindi imprevedibilità di un sistema ; tale misura è resa disponibile grazie, essenzialmente, a due parametri, gli esponenti di Lyapunov e D∞ .

6

2.1.1 Esponenti di Lyapunov

Gli esponenti di Lyapunov di un sistema dinamico in un punto p danno una misura di quanto le orbite del sistema siano dipendenti dai dati iniziali e rappresentino, dunque, degli indicatori della presenza di dinamiche caotiche. Ciò che essi misurano è, in particolare, la velocità media di allontanamento delle orbite dei punti vicini a p dall'orbita di p e per tempi sufficientemente lunghi. PiÚ precisamente: ad un punto p sono associati un numero di esponenti di Lyapunov pari alla dimensione dello spazio, se l' esponente di Lyapunov massimo è Ν e la distanza tra p ed un punto vicino è abbastanza piccola, ( tale distanza avrà , inoltre un'evoluzione nel tempo che per tempi t grandi sarà circa

) ne deduciamo che, se il massimo esponente

di Lyapunov del sistema è positivo ,allora ,il sistema presenta una dipendenza sensibile dai dati iniziali (in modo esponenziale) ed è, quindi, caotico. Fatta questa breve introduzione, si passi a calcolare codesti esponenti . Considerando con đ??¸đ??¸đ?‘–đ?‘– l’errore all’i-esimo passo, che si ha tra due traiettorie, è possibile scrivere che :

|đ??¸đ??¸đ?‘›đ?‘› |

|

=

|đ??¸đ??¸đ?‘›đ?‘› |

|đ??¸đ??¸0 | |đ??¸đ??¸đ??¸đ??¸ −1|

∗

|đ??¸đ??¸đ?‘›đ?‘› −1|

|đ??¸đ??¸đ?‘›đ?‘› −2 |

∗ ‌ . .∗

Da cui usando una rappresentazione logaritmica 1

��

đ??¸đ??¸

ln đ?‘›đ?‘› =∑đ?‘›đ?‘›đ?‘˜đ?‘˜ đ?‘™đ?‘™đ?‘™đ?‘™ đ??¸đ??¸0

|đ??¸đ??¸1 |

|đ??¸đ??¸0 |

đ??¸đ??¸đ?‘˜đ?‘˜

đ??¸đ??¸đ?‘˜đ?‘˜âˆ’1

(2.3)

(2.4)

Facendo ora il lim per nďƒ âˆž , se esiste, avremo la misura di quanto l’errore si sia

propagato in infiniti passi, inoltre, facendo tendere la perturbazione đ??¸đ??¸0 a zero avremo 1

đ?œ†đ?œ†(đ?‘Ľđ?‘Ľ0 )=limđ?‘›đ?‘›â†’∞ limđ??¸đ??¸0 →0 ∑đ?‘›đ?‘›đ?‘˜đ?‘˜ đ?‘›đ?‘›

đ??¸đ??¸đ?‘˜đ?‘˜

đ??¸đ??¸đ?‘˜đ?‘˜âˆ’1

1

=limđ?‘›đ?‘›â†’∞ ∑đ?‘›đ?‘›đ?‘˜đ?‘˜ |đ?‘“đ?‘“′(đ?‘Ľđ?‘Ľđ?‘˜đ?‘˜âˆ’1 )| đ?‘›đ?‘›

(2.5)

7

(Considerando che x(k)=x(k-1) +đ??¸đ??¸đ?‘˜đ?‘˜âˆ’1 e đ??¸đ??¸đ?‘˜đ?‘˜ = đ?‘“đ?‘“(đ?‘Ľđ?‘Ľđ?‘˜đ?‘˜ ) − đ?‘“đ?‘“(đ?‘Ľđ?‘Ľđ?‘˜đ?‘˜âˆ’1 ))

Che rappresenta l’esponente di Lyapunov.

2.1.2 D∞

Per quanto riguarda la D∞, che dĂ informazioni su come le traiettorie divergono nel tempo, si supponga di considerare due traiettorie, a tal fine si chiamino d(t), la distanza tra queste traiettorie nel tempo e δ(t), la norma di tale distanza (||d(t)||).

Fig. 2.1 Divergenza delle traiettorie.

Se ne osservi ora la dinamica e si consideri il fatto che,ogni sistema caotico è generalmente causato dalla presenza di processi, spesso in competizione, che generano fenomeni di stretching e folding delle traiettorie, si otterrĂ : δ(ṫ ) =đ?œ†đ?œ† δ(t)+kδ(t) 2

(2.6)

8

Da ciò, se il sistema avrĂ un comportamento caotico, la distanza tra le traiettorie, confinate in una regione limitata, dopo molto tempo (tďƒ âˆž) tenderĂ ad essere una quantitĂ costante (δ(ṫ ) =0) .

Chiamando D∞= δ(t) si avrĂ Îť D∞ + kD∞ 2 =0

(2.7)

Da cui D∞=

Îť

đ?‘˜đ?‘˜

(2.8)

Ciò significa che, se le traiettorie derivano da un sistema non caotico, D∞=0.

9

2.1 I Sistemi caotici 2.2.1 Il sistema di Lorenz

Il modello di Lorenz nasce nel 1963, da alcune radicali semplificazioni delle equazioni di Navier- Stokes sulla descrizione del comportamento dinamico di uno strato di fluido, che presenta moti convettivi, a causa di una differenza di temperatura applicata , fra la superficie inferiore e quella superiore. Il modello è costituito da un sistema di tre equazioni differenziali di primo ordine in forma normale nelle variabili x, y e z:

⎧ ⎪ ⎨ ⎪ ⎊

đ?‘‘đ?‘‘đ?‘‘đ?‘‘

đ?‘‘đ?‘‘đ?‘‘đ?‘‘ đ?‘‘đ?‘‘đ?‘‘đ?‘‘

đ?‘‘đ?‘‘đ?‘‘đ?‘‘

= đ?œŽđ?œŽ(đ?‘Śđ?‘Ś − đ?‘Ľđ?‘Ľ)

= −đ?‘Ľđ?‘Ľđ?‘Ľđ?‘Ľ + đ?‘&#x;đ?‘&#x;đ?‘&#x;đ?‘&#x; − đ?‘Śđ?‘Ś

đ?‘‘đ?‘‘đ?‘‘đ?‘‘ đ?‘‘đ?‘‘đ?‘‘đ?‘‘

(2.9)

= đ?‘Ľđ?‘Ľđ?‘Ľđ?‘Ľ − đ?‘?đ?‘?đ?‘?đ?‘?

Lo spazio delle fasi è tridimensionale, e le variabili (x, y, z) non sono variabili spaziali: la variabile x è legata al campo di velocitĂ del fluido, la variabile y è proporzionale alla differenza di temperatura tra le correnti ascendenti e quelle discendenti, e z è proporzionale alla distorsione dalla linearitĂ del profilo verticale di temperatura; Ďƒ, b ed r sono parametri idrodinamici, che possono assumere solo valori positivi. Il parametro r è il numero di Rayleigh relativo al suo valore critico: r=Ra/Rc.

10

Durante lo studio del sistema, Lorenz si accorse di un andamento non periodico, mentre allora, si riteneva che il comportamento tipico di un sistema di equazioni differenziali fosse quello periodico. Volendo ricontrollare i dati ottenuti fino all’istante T, decise di ripetere l’integrazione numerica, e per risparmiare tempo non scelse la condizione iniziale (x(0), y(0), z(0)), ma un punto intermedio t’<T, le cui coordinate erano già state stampate dal calcolatore. Ovviamente si aspettava di ritrovare gli stessi punti già ottenuti nell’intervallo [t’,T], ciò che osservò fu, invece, che le due traiettorie si sovrapponevano per un certo tempo, per poi divergere progressivamente e diventare completamente diverse. Con suo grande stupore constatò che la causa di questa discrepanza non era attribuibile a errori di integrazione, ma soltanto a valori iniziali leggermente diversi.

Il regime dinamico maggiormente studiato è quello i cui parametri hanno i valori adottati da Lorenz stesso, e cioè: σ = 10. b = 8/3. r = 28. I risultati ottenuti con tali parametri possono essere osservati dalle figure 2.2, 2.3.

Fig.2.2 Rappresentazione 2D dell’attrattore di Lorenz.

11

Fig. 2.3 Rappresentazione 3D dell’attrattore di Lorenz.

2.2.2 Il sistema di Rossler

Il sistema di Rossler è il piÚ semplice sistema di terzo ordine capace di manifestare comportamenti di tipo caotico (ne esiste anche una versione del quarto ordine).

⎧ ⎪

đ?‘‘đ?‘‘đ?‘‘đ?‘‘

đ?‘‘đ?‘‘đ?‘‘đ?‘‘ đ?‘‘đ?‘‘đ?‘‘đ?‘‘

= −đ?‘Śđ?‘Ś − đ?‘§đ?‘§

= đ?‘Ľđ?‘Ľ + đ?‘Žđ?‘Žđ?‘Žđ?‘Ž ⎨đ?‘‘đ?‘‘đ?‘‘đ?‘‘ đ?‘‘đ?‘‘đ?‘‘đ?‘‘ ⎪ = đ?‘?đ?‘? + đ?‘§đ?‘§(đ?‘Ľđ?‘Ľ − đ?‘?đ?‘?) ⎊ đ?‘‘đ?‘‘đ?‘‘đ?‘‘

(2.10)

Questo sistema presenta un solo termine non lineare, il prodotto tra z e x nella terza equazione, il quale è parte fondamentale del processo di stretching and folding tipico dei sistemi caotici.

Vedendo il tutto in tre dimensioni, ciò significa che traiettorie vicine al piano (x, y) saranno respinte in maniera spiraliforme dall’origine. Questo 12

genera il dispiegamento delle traiettorie adiacenti, il quale è il primo ingrediente del caos. Tutto ciò è generato solo da termini lineari, ma questo non basta per ottenere un comportamento caotico perché, se l’intero sistema fosse lineare, l’effetto di stretching continuerebbe fino a far divergere le traiettorie all’infinito. Per confinare l’azione di allontanamento all’interno di una regione di spazio limitata, il termine non lineare è necessario. Il parametro c nella terza equazione agisce da soglia per attivare l’azione non lineare di ripiegamento o folding. Considerando solamente la terza equazione si nota che, quando il valore di x è minore della costante c, il coefficiente di z è negativo, il sottosistema z è stabile e tende a riportare z a valori prossimi a −b (x − c). D’altro canto, se x supera c allora z appare nella terza equazione, moltiplicato per un fattore positivo e il precedente sistema stabile diverge. Scegliendo b>0 la divergenza avviene nel senso positivo degli z, come è possibile vedere nelle figure 2.4 e 2.5.

Fig.2.4 Rappresentazione 2D dell’attrattore di Rossler.

13

Fig.2.5 Rappresentazione 3D dell’attrattore di Rossler.

2.2.3 Il Circuito di Chua

Fu introdotto da Leon O. Chua nel 1983 e rappresenta il più semplice circuito elettronico capace di esibire un comportamento caotico. Questa sua facilità implementativa, combinata alla presenza di un accurato modello teorico, ha fatto di tale circuito uno dei più largamente usati per studiare la teoria del Caos. Ricordando una delle condizioni fondamentali per la nascita di comportamenti caotici, ossia che un sistema autonomo debba essere almeno del III ordine, e traducendo il tutto in criteri atti a trasferire questo concetto in ambito elettronico, si può affermare che, affinché un circuito autonomo composto da componenti standard, quali resistori capacitori ed induttori, possa generare dinamiche caotiche deve avere: • Uno o più elementi non lineari. • Uno o più resistori localmente attivi. 14

• Tre o più elementi capaci di immagazzinare energia (capacitori e/o induttori). Da ciò si esplica quanto detto in precedenza, cioè che codesto circuito è il più semplice tra quelli che riescono a generare comportamenti caotici. Infatti, come mostrato dalla foto sottostante, si trovano: • 2 capacitori e un induttore •

una resistenza attiva

•

un resistore non lineare, creato tramite 2 resistori lineari e 2 diodi.

Fig.2.6 Circuito di Chua.

Aggiungendo poi un resistore lineare in serie all’induttore, si ottiene l’oscillatore di Chua (Fig. 2.7). Questo circuito è in grado di generare un numero ancora più elevato di fenomeni caotici.

15

Fig.2.7 Oscillatore di Chua.

Tale circuito, inoltre, può essere accuratamente modellato da un sistema di tre equazioni differenziali non lineari nelle variabili x(t) y(t) e z(t), che rappresentano il voltaggio, per i condensatori e la corrente, per l’induttore.

(2.11)

La funzione f(x) descrive la risposta elettrica del resistore non lineare, mentre, i parametri α e β sono determinati dai valori dei componenti. L’attrattore generato dal circuito viene chiamato “The Double Scroll" e può essere visto nella figura 2.8. (questo perché il sistema cerca di oscillare attorno a una delle due traiettorie, fin quando non riceve dal componente non lineare l’energia per saltare 16

nell’altra traiettoria e vice versa. Il circuito ha un comportamento intermittente e imprevedibile, vi sono valori di R per cui ha un single scroll ).

Fig.2.8 L’attrattore di Chua.

17

2.3 Le spiral waves

2.3.1 La BZ-reaction

Una reazione di Belousov–Zhabotinsky, o più comunemente chiamata BZ reaction , fa parte di una più ampia famiglia di reazioni chimiche basate sul “ non equilibrio termodinamico “, che portano alla creazione dei cosiddetti “oscillatori chimici”. Queste reazioni non riescono a raggiungere uno stato di equilibrio, definendo così un interessante modello atto a spiegare le condizioni di non equilibrio dei fenomeni chimici/biologici. Un altro interessante aspetto di tali reazioni è senza dubbio la cosiddetta “eccitabilità”, infatti, sotto l’influenza di opportuni stimoli (che nel caso della BZ sono essenzialmente di natura luminosa), si nota l’emergenza dei patterns, anche molto complessi.

Fig.2.9 Formazione dei Patterns in una BZ-reaction.

La scoperta di questa reazione è stata accreditata a Boris Belousov. Infatti, negli anni ‘50, scoprì che utilizzando come catalizzatori, Ce3+/Ce4+ e come riducente, acido 18

citrico la soluzione “oscillava” tra il giallo e l’assenza di colore,con una frequenza che saliva all’incrementarsi della temperatura. Successivamente, Zhabotinsky sostituì l’acido citrico con l’acido malonico (MA) creando quella che è conosciuta come BZ reaction. Egli mostrò che l’oscillazione del colore della soluzione era causata dall’oscillazione della concentrazione del Ce4+ , inoltre, trovò che l’ossidazione del Ce3+ da parte del HBrO3 era una reazione auto catalitica e che dopo l’ accumulazione dell’acido bromo malonico(BMA), la concentrazione di Ce4+ si auto sosteneva. Suggerì altresì che la BZ reaction poteva essere essenzialmente divisa in due parti : l’ossidazione auto catalitica del Ce3+ da parte del HBrO3 e la riduzione del Ce4+ da parte del MA e dei suoi derivati. In questo schema la riduzione del Ce4+ è accompagnata dalla produzione del Br- , che è un forte inibitore per l’ossidazione del Ce3+. Un’oscillazione può essere qualitativamente descritta nel seguente modo:si supponga che vi sia un’alta concentrazione di Ce4+ nel sistema, ciò provocherà una veloce produzione di Br- , con conseguente rialzo della sua concentrazione. Come risultato si otterrà, che il processo di ossidazione del Ce3+ sarà completamente inibito e la [Ce4+] decrescerà a causa della riduzione del MA e del BMA. La concentrazione del Br- , però decresce in concomitanza di [Ce4+] e quando quest’ultima raggiunge la soglia minima la concentrazione di ioni di bromuro si abbassa improvvisamente. Inizia a questo punto, il rapido processo di ossidazione, con consecutivo incremento di [Ce4+]; in seguito quando questa concentrazione supera una soglia massima la [Br-] si incrementa e va ad inibire l’ossidazione del Ce3+ , ricominciando il ciclo. L’oscillazione e l’eccitabilità di tale reazione vengono egregiamente descritte dal cosiddetto Oregonator, modello matematico sviluppato nel 1974 da Filed e Noyes e in cui le variabili sono le concentrazioni di HBrO2, Br-, e Ce4+.

19

đ?œ•đ?œ•đ?œ•đ?œ•

2 2 ⎧ đ?œ•đ?œ•đ?œ•đ?œ• = đ?‘Ľđ?‘Ľ + đ?‘Śđ?‘Ś − đ?›źđ?›źđ?‘Ľđ?‘Ľ − đ?‘Ľđ?‘Ľđ?‘Ľđ?‘Ľ + đ??ˇđ??ˇ1 ∇ đ?‘Ľđ?‘Ľ ⎪ đ?œ•đ?œ•đ?œ•đ?œ• = −đ?‘Śđ?‘Ś + đ??ľđ??ľđ??ľđ??ľ − đ?‘Ľđ?‘Ľđ?‘Ľđ?‘Ľ + đ??ˇđ??ˇ2 ∇2 đ?‘Śđ?‘Ś ⎨ đ?œ•đ?œ•đ?œ•đ?œ• đ?œ•đ?œ•đ?œ•đ?œ• ⎪ đ??˝đ??˝ = đ?‘Ľđ?‘Ľ − đ?‘§đ?‘§ + đ??ˇđ??ˇ3 ∇2 đ?‘§đ?‘§ ⎊ đ?œ•đ?œ•đ?œ•đ?œ•

(2.12)

Fig.2.10 Sviluppo di una spiral wave (sinistra), simulazione mediante software(destra).

2.3.2 Il Modello di FitzHugh-Nagumo Il modello di FitzHugh-Nagumo è, forse, uno dei modelli piÚ interessanti dal punto di vista matematico, tra quelli utilizzati per descrivere il processo di depolarizzazione della membrana cellulare. La rappresentazione circuitale di tale modello è rappresentata dalla figura2.11.

20

Fig.2.11 modello circuitale di un neurone secondo FitzHugh-Naguno.

Dove: •

rappresenta il potenziale di membrana;

•

è una variabile di “recupero” (in quanto serve a recuperare le condizioni di equilibrio del punto) ;

•

è l’ampiezza dello stimolo di corrente;

21

Fig. 2.12 immagine rappresentante lo spazio delle fasi e il diagramma degli stati del modello di F-N.

Inoltre, esso permette di “modellizzare” il processo di generazione degli spike, tipico del modello HH. Infatti, se il valore di

si incrementa lentamente, il neurone rimane

quiescente; così facendo l’equilibrio a riposo del sistema di F-N si sposta lentamente verso destra e e viene seguito da quello del sistema senza l’emissione di spikes. Se invece la stimolazione avviene in maniera rapida, la traiettoria non potrà andare direttamente nel nuovo stato di riposo, ma emetterà uno spike. OSS:Poiché tutti i punti spaziali sono proiettati sulle coordinate

e

, la traiettoria

dell’impulso nello spazio delle fasi sarà simile ad un cerchio.

22

2.3.2.1 Autoonde tramite FitzHugh-Nagumo

Le equazioni che reggono tale modello, inoltre, permettono di simulare egregiamente modelli basati su fenomeni di reazione-diffusione e, quindi, analizzare la propagazione di autoonde, provenienti da sistemi quali: il tessuto cardiaco o la fibra nervosa:

Osservando il modello matematico, si nota che il termine diffusivo, rappresentato da, , è la derivata seconda rispetto alla variabile spaziale X.

23

3. Il Software I software utilizzati per interagire con la led matrix sono : il pick kit 2 e l’Mplab, softaware proprietari della Microchip, e un tool sviluppato in Matlab, che permette come vedremo di sfruttare tutte le caratteristiche della sopracitata matrice; di seguito una descrizione di questi software:

3.1 MPLab L’ MPLAB è un IDE gratuito sviluppato dalla Microchip, che permette, insieme ad un opportuno compilatore, di poter scrivere e compilare in maniera abbastanza agevole il codice C necessario alla programmazione del PIC.

Fig.3.1 Interfaccia grafica del software MPlab.

Nella fattispecie il compilatore da noi utilizzato per poter generare IL codice compatibile con il PIC16F57 è quello dell’ Hi-tech, capace di supportare tutti i PIC della famiglia 16FXX. 24

3.2 Il Pic Kit2

Questo software, che viene fornito insieme al programmatore, è come una sorta di collegamento tra tutti gli altri software da noi utilizzati e il PIC, in quanto si occupa di trasferire il codice binario proveniente dalla compilazione del sorgente C all’interno dell’integrato.

Fig.3.2 Interfaccia grafica del Pic Kit2.

25

3.3 Il tool Matlab

Il presente tool sviluppato con l’ausilio di Matlab, rappresenta il fulcro del nostro lavoro, in quanto rende possibile, come sarà esplicato in seguito, sia la rappresentazione delle dinamiche caotiche, attraverso led matrix, che a sua volta genera dinamicamente il codice C, sia un vero e proprio controllo puntuale di tale matrice, lasciando così aperte nuove strade nell’ interazione con la suddetta. Fatto questa breve introduzione, è opportuno passare alla descrizione vera e propria di tale software. Questo tool si presenta con un’interfaccia grafica a finestre il cui scopo è rendere agevole la modalità d’uso. Attraverso la schermata principale (fig.3.2 ) è possibile accedere direttamente a tutte le sue funzionalità.

Fig.3.2 Interfaccia grafica del tool Matlab.

26

3.3.1 Chaotic Dynamic Questa sezione si occupa di simulare, sia sistemi caotici quali Chua, Lorenz e Rossler, sia delle vere e proprie autoonde provenienti da equazioni di reazione diffusione quali : la spiral wave e la BZ reaction.

Fig.3.3 Interfaccia grafica della pirma sezione del tool Matlab.

Per poter accedere alle diverse funzioni basterà, di volta in volta, scegliere tramite il pop-up menu(Fig.3.3.1) il sistema da simulare, impostare nelle caselle di testo presenti i valori appositi (Fig.3.3.2), scegliere il colore (Fig.3.3.3) e premere RUN/PLOT (Fig.3.3.4) in seguito il software genererà in loco l’attrattore/i patterns e creerà e compilerà dinamicamente il codice C, pronto per essere trasferito al PIC con il PIC KIT. (in alternativa è possibile il codice può essere compilato manualmente grazie all’MPLAB ) Attraverso il pulsante indicato dalla (Fig.3.3.5) è possibile passare alla seconda sezione. Analizziamo per completezza le varie simulazioni : 27

• Lorenz attractor Si inizia con la simulazione del sistema di Lorenz, impostata come simulazione di default, in tale simulazione come in tutte quelle riguardanti la generazione degli attrattori caotici, è necessario impostare di volta in volta i parametri caratteristici, che nella fattispecie si traduce nell’inserire all’interno della tabella mostrata in figura 3.4 valori desiderati.

Fig 3.4 Sezione relativa all’immissione dei parametri.

Con Y0 T0 e Tend vengono indicati i valori, rispettivamente, delle condizioni iniziali, tempo di inizio e fine integrazione, passati all’algoritmo ode45 (…), mentre B, σ ed r sono i parametri propri del sistema di Lorenz. Per quanto riguarda, invece, il campo “Numero Frame”, esso indica il numero di frame che verranno visualizzate nella Led Matrix.

28

Fig.3.5 Output della simulazione del sistema di Lorenz.

Fig.3.6 Rappresentazione finale, attraverso la led matrix, del sistema di Lorenz.

Come si può notare dalle figure 3.5 e 3.6 , la led matrix ripropone quando graficato dal tool matlab.

29

• Rossler attractor La stessa procedura è applicabile a Rossler, ottenendo i risultati mostrati in Fig. 3.7 e 3.8.

Fig.3.7 Output della simulazione del sistema di Rossler.

Fig.3.8 Rappresentazione finale, attraverso la led matrix, del sistema di Rossler.

30

• Chua attractor Per quanto riguarda Chua, poiché si è scelto di avvalersi, per la simulazione, di un modello sviluppato in simulink non vengono più presi in considerazione y0, t0 e tend , ma solo t0/end, che rappresenta l’intervallo di integrazione, oltre che, ovviamente, i parametri propri di tale sistema. I risultati di tale simulazione sono mostrati in Fig 3.9 e 3.10.

Fig.3.9 Output della simulazione del sistema di Chua.

Fig.3.10 Rappresentazione finale, attraverso la led matrix, del sistema di Chua.

31

• BZ-Reaction: La BZ-reaction, considerato il fatto che permette la generazione di pattern complessi, sviluppati attraverso la formazione di autoonde, è stata scelta come strumento capace di far visualizzare una vera e propria dinamica, rintracciabile nell’avanzamento del fronte d’onda, che difficilmente, data la risoluzione, poteva essere rappresentata dai precedenti sistemi.

Fig.3.11 Output della simulazione della BZ_reaction.

Fig.3.12Rappresentazione finale, attraverso la led matrix, della BZ-reaction.

32

• Spiral waves Analogamente a quanto detto per la BZ-reaction anche le due spiral waves, generate dal modello di FitzHugh-Nagumo modificato, vengono utilizzate per visualizzare l’evolversi di una dinamica. I risulatati di tale simulazione sono mostrati dalle Fig. 3.13 e 3.14.

Fig.3.13 Output della simulazione della spiral wave.

Fig.3.14 Rappresentazione finale, attraverso la led matrix, di una spiral wave.

33

3.3.2 II Sezione

La seconda sezione del software, che permette un controllo puntuale della matrice, si presenta con tale interfaccia grafica.

Fig.3.15 Interfaccia grafica della seconda sezione del tool Matlab.

Si nota la presenza di una matrice 8x8 (Fig.3.15.1), che riproduce un sotto blocco della led matrix. Tramite questa matrice, infatti, è possibile scegliere manualmente, in maniera selettiva, cosa far visualizzare nella matrice, suddividendola in 16 blocchi. In aggiunta a ciò, è possibile scrivere una frase, che verrà rappresentata dalla matrice (Fig. 3.15.4).

Procedura

Per poter usufruire delle funzionalità precedentemente elencate bisogna seguire una semplice procedura: • digitare nella matrice di (Fig. 3.15.1) ciò che si vuole rappresentare

34

• indicare la posizione in cui si vuol fare visualizzare il tutto, attraverso la parte indicata dalla (Fig 3.15.2) • premere i pulsanti Next Frame e Reset ripetendo la procedura sopra indicata, se si vogliono visualizzare più immagini contemporaneamente(Fig.3.15.3) • premere il pulsante “Elaborate”per creare compilare il codice da trasferire al PIC .

Fig.3.16 Esempio grafico della procedura prima spiegata.

35

4. Hardware 4.1 La Led-Matrix La Led Matrix(Fig. 4.1) rappresenta un’economica soluzione per la rappresentazione delle informazioni. Data la sua versatilità viene impiegata per molte applicazioni, e negli ambiti più svariati. Quella da noi utilizzata consta di 2048 led (32x64) bicolore (Rosso Verde, è possibile inoltre l’accensione di entrambi i colori ottenendo un terzo colore arancione) e viene pilotata mediante una demoboard SURE.

Fig.4.1 Led Matrix 32X64.

Fig.4.2 Led Matrix in funzione.

36

Scendendo nel dettaglio nella figura sottostante è presentato lo schema elettrico della suddetta matrice.

Fig.4.3 Schema circuitale della Led Matrix.

Come si può notare la matrice è suddivisa in due sottomatrici di 16 righe, inoltre ciascuna sotto matrice è pilotata da due 74HC/HCT138 3-to-8 line decoder/demultiplexer . Ogni 74HC/HCT138 permette di controllare 8 righe, la selezione della corretta regione di 8 righe è effettuata mediante la combinazione di un segnale di enable e un 4° bit (D). Quindi una combinazione di 3bit (A, B, C) più il bit (D) in END con l’ enable (En) permette di caratterizzare per righe la regione illuminata.

Fig.4.4 Tabella della verità del 74HC/HCT138 3-to-8 line decoder/demultiplexer.

Il controllo delle colonne è invece affidato a otto shift register a 8 bit. 37

4.2 La Demo Board La Demo board utilizzata per il controllo della matrice è stata prodotta dalla Sure Electronics (Fig. 4.5).

Fig.4.5 Demo Board.

Fig.4.6 Schema di collegamento della circuiteria.

Componenti Hardware della Demo Board: 1) Potenza di alimentazione: Connettore a 12v.Un LM2596 converte i 12v in ingresso in 5v permette alla corrente di raggiungere i 3A 38

2) Interfaccia con dot-matrix display connettore a 16 pin 3) Chip di controllo PIC16F57 connesso con un oscillatore a 25 MHz. 4) Interfaccia per la programmazione

4.3 Il PIC16F57

I Pic sono dei circuiti integrati prodotti dalla Microchip appartenenti alla categoria dei micro controller, ovvero quei componenti che integrano in un unico chip tutto il necessario alla realizzazione di un sistema digitale programmabile. E’ possibile individuare i seguenti elementi presenti all’interno del PIC: • CPU: con lo scopo di interpretare le istruzioni di programma. • Memoria Flash(memoria non volatile programmabile più volte):in cui sono memorizzate le istruzioni del programma da eseguire. • RAM(Random Access memory):utile per memorizzare le variabili utilizzate dal programma. • Linee di I\O :per pilotare dispositivi esterni o ricevere impulsi da sensori, pulsanti e così via. • Dispositivi ausiliari al funzionamento quali generatori di clock, bus contatori ed altro. Caratteristiche particolari del PIC16F57 (Flash-Based, 8-Bit CMOS): • • • • • • • • • •

High performance RISC CPU. On-chip Flash memory: 2048x12. General purpose Registers (SRAM) 72x8. Porte di I\O 20. Massima frequenza di operazione 20MHz. Flash program memory(x12 words) 2K. RAM data Memory (bytes) 72. Timer module TMR0. Numero di istruzioni 33. 28 pin. 39

Fig.4.7 Piedinature del PIC16F57.

Schema delle porte del Pic 16F57:

Fig.4.8 definizione porte del PIC16F57.

40

Fig.4.9 Legenda delle porte del PIC16F57.

Definizione Porte

Fig.4.10 Corrispondenza delle porte del PIC16F57.

41

4.4 Il Programmatore PicKit2 Il programmatore PicKit2 (Fig. 4.11) permette di programmare tutti i dispositivi supportati ( per maggiori informazioni consultare l’help ).

Fig.4.11 Il programmatore PICKit2.

Descrizione Nella prima fase si è lavorato allo sviluppo del codice necessario alla visualizzazione su Led Matrix di frame : Da Mplab 1) Dopo aver installato Hi-Tech compiler. 2) Aver verificato la presenza tra i compilatori (Set Language tool location) del compilatore Hi-Tech. 3) E’ stato creato un nuovo progetto, specificando l’utilizzo del pic 16F57 e si è poi passato ad una fase di stesura del codice.Il programma a questo punto è composto da un file .c e da pic.h. 4) Il codice .c contente tutte le istruzioni per il pic e le direttive per il compilatore, viene a questo punto compilato mediante Mplab e Hi-tech compiler. Il file

42

compilato è un .hex cioè esadecimale ed è possibile trasferirlo mediante il programmatore PicKit 2.0 sulla demoboard. Il Pickit è dotato di un software direttamente interfacciato con il programmatore. Il programmatore è stato utilizzato con l’alimentatore della led matrix connesso alla rete, permettendo in questo modo un aggiornamento rapido della frame visualizzata sulla matrice. Fase di trasferimento del codice sorgente sulla demoboard: Questa fase che si è dimostrata essere molto delicata verrà descritta più dettagliatamente: Prima di qualsiasi ulteriore operazione bisogna verificare che il PicKit sia connesso ad una porta USB di un Pc, ed’è necessario connettere correttamente il Pickit alla demoboard seguendo le specifiche mostrate in figura 4.12, bisogna inoltre controllare che non esistano conflitti tra il software in dotazione e il software presente sul programmatore.

Fig.4.12 Descrizione dei pin del programmatore.

A questo punto bisogna specificare la famiglia di appartenenza del Pic. Il pic16F57 è riconosciuto dal programmatore come appartenente alla famiglia dei baseline. Pickit 2.0->family device->baseline.

43

Poiché la famiglia dei baseline pic contiene diversi dispositivi, deve essere individuato nel menù a tendina successivo il modello di Pic, in questo caso 16F57. Si è poi passati all’import del file: Il codice esadecimale può essere caricato nel PicKit 2.0 selezionando File>ImportHex .Viene mostrato se tutto è andato a buon fine nella Status Window il seguente messaggio “Hex file sucessfully imported” Il codice è visualizzato sulla program memory window.E’ inoltre mostrata sulla finestra memory source la directory di origine del codice. E’ possibile adesso dal tasto Write passare alla fase di scrittura del codice, il device verrà cancellato e riscritto con il codice Hex importato. Se l’operazione di scrittura ha avuto successo verrà visualizzato “Programming sucessfull”

Fig 4.13 interfaccia del sotware PicKit2.

44

5. Le Simulazioni Le simulazioni da noi effettuate, hanno lo scopo di proporre la led matrix come strumento alternativo per la visualizzazione della dinamica dei sistemi caotici. Ragion per cui abbiamo deciso, di mostrare l’evolversi della dinamica dei sistemi precedentemente analizzati, facendone variare i parametri caratteristici, ottenendo quindi, figure non più riconducibili a degli strange attractor. Inoltre per ovvi motivi di risoluzione grafica, si è scelto di visualizzare solamente sei frame dei suddetti sistemi, scelte comunque in modo tale da evidenziarne l’evolversi della dinamica.

5.1 Sistema di Lorenz

In questa sezione sono presentate le simulazioni effettuate:

Con i seguenti parametri B= 8/3 σ=10 r=28 si sono avuti i risultati mostrati in Fig. 5.1.1.

45

Fig.5.1.1 Attrattore di Lorenz B= 8/3 Ďƒ=10 r=28.

46

Mentre i risultati che si sono avuti con B= 4 Ďƒ=9 r=23 sono mostrati in Fig. 5.1.2.

Fig.5.1.2 Attrattore di Lorenz B= 4 Ďƒ=9 r=23.

47

5.2 Il sistema di Rossler

Con i seguenti parametri a0.2 b=0.2 c=6 si sono avuti i risultati mostrati si sono avuti i risultati mostrati in Fig. 5.2.1.

Fig.5.2.1 Attrattore di Rossler a=0.2 b=0.2 c=6.

48

Mentre i risultati che si sono avuti con a01 b=1 c=6 sono mostrati in Fig. 5.2.2.

Fig.5.2.2 Attrattore di Rossler a=1 b=1 c=6.

49

5.3 Il Circuito di Chua

Con i seguenti parametri α=9 β=14.286 γ=0 si sono avuti i risultati mostrati in Fig. 5.3.1.

Fig.5.3.1 Attrattore di Chua α=9 β=14.286 γ=0.

50

Mentre i risultati che si sono avuti con con α=8 β=14 γ=0 sono mostrati in Fig. 5.3.2.

Fig.5.3.2 Attrattore di Chua α=8 β=14 γ=0

51

5.4 La BZ-reaction

Le figure 5.4.1 rappresentano i risultati ottenuti simulando l’evoluzione di una BZ reaction.

52

Fig.5.4.1 BZ reaction.

5.5 Autowave FitzHugh-Nagumo Per la realizzazione di queste spiral waves si è ricorso la modello di Fitz-Hugh Nagumo impostando come parametri: a=0.13; b=0.013; c1=0.26; c2=0.1; d=1.0 e ottenendo i risultati mostrati in Fig. 5.5.1.

53

Fig.5.5.1 Autowaves a=0.13; b=0.013; c1=0.26; c2=0.1; d=1.0.

Mentre utilizzando come parametri: a=20; b=0.91; c1=0.70; c2=0.7; d=5; i risultati ottenuti sono mostrati in Fig. 5.5.2.

54

Fig.5.5.2 Autowaves a=20; b=0.91; c1=0.70; c2=0.7; d=5.

55

APPENDICE A

Di seguito le parti di codice più significative, che compongono il tool grafico. File Tesina. Il codice presente in questo file permette, sia di visualizzare la Gui della prima sezione, sia di simulare e graficare i sistemi caotici analizzati.

FUNZIONE TESINA_OPENINGFcn (Main) function tesina_OpeningFcn(hObject, eventdata, handles, varargin) %inizializzazione della Gui handles.output = hObject; movegui(hObject,'onscreen') movegui(hObject,'center') set(handles.edit9,'Enable','off'); set(handles.edit10,'Enable','off'); set(handles.edit11,'Enable','off'); set(handles.text9,'Enable','off'); set(handles.text10,'Enable','off'); set(handles.text11,'Enable','off'); set(handles.edit1,'Enable','on'); set(handles.edit4,'Enable','on'); set(handles.edit3,'Enable','on');

…. …. xlimits = [-25 25]; ylimits = [-30 30]; zlimits = [-1 50]; ytime_limits = [-25 25]; xtime_limits = [1 40]; set(handles.display_plot,'XLim',xlimits,'YLim',ylimits,'ZLim',zlimits); set(handles.time_plot,'XLim',xtime_limits,'YLim',ytime_limits); handles.line_plot = []; handles.line_time_plot = []; handles.output = hObject; guidata(hObject, handles);

% Pulsante STOP/RUN function pushbutton1_Callback(hObject, eventdata, handles) %ASSEGNAGNAZIONE PATH path_comp='C:\Program Files\HI-TECH Software\PICC\std\9.60\bin\'; path_desk='C:\Documents and Settings\Administrator\Desktop\'; w_path=what;

56

%Assegnazione delle variabili frame=str2num(get(handles.edit12,'string')); y0=str2num(get(handles.edit1,'string')); t0=str2num(get(handles.edit3,'string')); tfinal=str2num(get(handles.edit4,'string'));

….. ……

%procedura per l'esportazione delle variabili attraverso il comando setapp %data e gettappdata data=getappdata(gcbf,'metricdata'); data.edit13=chuaa; data.edit14=chuab; data.edi15=chuag; ……. …… data.edit14=gamma; setappdata(gcbf,'metricdata',data);

popup_sel_index = get(handles.popupmenu1, 'Value'); switch popup_sel_index case 1 % Sistema di Lorenz

set(handles.time_plot,'Visible','on') if strcmp(get(handles.pushbutton1,'String'),'RUN/PLOT') set(handles.pushbutton1,'String','STOP'); cla; set(handles.display_plot,'HandleVisibility','On') set(handles.time_plot,'HandleVisibility','Off') cla; % clear figure set(gca,'UserData',1) pause(0.01) %esecuzione attraverso il comando ode 45 della funzione che permette di %simulare il sistema di Lorentz [t1,Y] = ode45(@lorenzequation,[t0 tfinal],y0); %Creazione dei plot if colore==1 ball_plot = line('XData',y(1),'YData',y(2),'ZData',y(3), ... 'Color','Green','Marker','.','Markersize',25,'Erase','Xor'); line_plot = line('XData',[],'YData',[],'YData',[],'Color','Green','LineStyle','','Erase','None');

…… ….. %Procedura per la rappresentazione "Real time" dello strange attractor Yt = [Y(:,1)];

57

plot_view = [0,90]; set(handles.display_plot,'View',plot_view); xlimits = [ceil(min(min(Y(:,1))))-5 ceil(max(max(Y(:,1))))+5]; ylimits = [ceil(min(min(Y(:,2))))-5 ceil(max(max(Y(:,2))))+5]; zlimits = [ceil(min(min(Y(:,3))))-5 ceil(max(max(Y(:,3))))+5]; set(handles.display_plot,'XLim',xlimits,'YLim',ylimits,'ZLim',zlimits,'Box','ON' ); c_mark1 = line('Xdata',[C(1)],'Ydata',[C(1)],'Marker','.','MarkerSize',25,'Color','Black') ; c_mark2 = line('Xdata',[C(2)],'Ydata',[C(2)],'Marker','.','MarkerSize',25,'Color','Black') ; c_line = line('xdata',[C(1) C(2)],'ydata',[C(1) C(2)],'LineStyle',':','Linewidth',2,'Color','Black'); set(gca,'UserData',1) while get(gca,'Userdata')==1 if t1(i) >= tfinal set(gca,'Userdata',-1); set(handles.pushbutton1,'String','RUN/PLOT'); break end

set(ball_plot,'XData',Y(i,1),'YData',Y(i,2),'ZData',Y(i,3)) set(ball_time_plot,'XData',t1(i),'YData',Yt(i)) set(line_plot,'XData',Y(1:i,1),'YData',Y(1:i,2),'ZData',Y(1:i,3)) set(line_time_plot,'XData',t1(1:i),'YData',Yt(1:i)) handles.line_plot = line_plot; handles.line_time_plot = line_time_plot; guidata(hObject, handles); drawnow; pause(0.01) i = i + 1; end

…. ….. % cancellazione frame obosoleti del=strcat(w_path.path,'\*.jpg'); delete(del); % Richiamo delle funzioni che permettono: di generare le frame ,il codice % da compilare e la sua successiva compilazione salv= mappalorentz(frame,colore,r,s,b,y0,t0,tfinal,path_desk,path_comp); compila(frame,path_comp); move(path_comp,salv); ….. …..

58

Per quanto riguarda il sistema di Rossler, la procedura è del tutto analoga a quella usata per il sistema di Lorenz. case 3 %

Sistema di Chua

set(handles.time_plot,'Visible','on') if strcmp(get(handles.pushbutton1,'String'),'RUN/PLOT') set(handles.pushbutton1,'String','STOP'); cla; set(handles.display_plot,'HandleVisibility','On') set(handles.time_plot,'HandleVisibility','Off') cla; % clear figure set(gca,'UserData',1) pause(0.01) chuaa; chuab; chuag;% time; %Esecuzione attraverso il comando sim del blocco Simulink che permette di %simulare il sistema di Chua options = simset('SrcWorkspace','current');

[t1,Y] = sim('chua_or',time,options);

Modello simulink usato per la simulazione del sistema di Chua

%Creazione dei plot

…. ….. case 4 %

Simulazione della BZ-reaction

59

set(handles.display_plot,'HandleVisibility','On') set(handles.time_plot,'HandleVisibility','Off') set(handles.line_plot,'Visible','Off') set(handles.display_plot,'HandleVisibility','Off') set(handles.time_plot,'HandleVisibility','On') set(handles.line_plot,'Visible','Off') cla ; figure xlimit = [-25 ylimit = [-30 n=16; m=64;

25]; 30];

z=zeros(n,m); cells=z; cells = (rand(n,m))<.1 ; %cells(n/2,n*.25:n*.75) = 1; %cells(n*.25:n*.75,n/2) = 1; sum=z; imh = image(cat(3,cells,z,z)); set(imh, 'erasemode', 'none') axis equal axis tight x = [2:n-1]; y = [2:m-1]; contatore=1; contatore2=10; t = 7; % center value=6; 7 makes fast pattern; 5 analiating waves t1 = 3; % center value=3 %procedura per la rappresentazione della BZ-reaction for i=1:1000

sum(x,y) = ((cells(x,y-1)>0)&(cells(x,y-1)<t)) + ((cells(x,y+1)>0)&(cells(x,y+1)<t)) + ... ((cells(x-1, y)>0)&(cells(x-1, y)<t)) + ((cells(x+1,y)>0)&(cells(x+1,y)<t)) + ... ((cells(x-1,y-1)>0)&(cells(x-1,y-1)<t)) + ((cells(x-1,y+1)>0)&(cells(x1,y+1)<t)) + ... ((cells(x+1,y-1)>0)&(cells(x+1,y-1)<t)) + ((cells(x+1,y+1)>0)&(cells(x+1,y+1)<t)); cells = ((cells==0) & (sum>=t1)) + ... 2*(cells==1) + ... 3*(cells==2) + ... 4*(cells==3) + ... 5*(cells==4) + ... 6*(cells==5) +... 7*(cells==6) +... 8*(cells==7) +... 9*(cells==8) +... 0*(cells==9);

60

set(imh, 'cdata', cat(3,z,cells/10,z) ) drawnow %creazione delle frame for k= 1:frame*3 if i==(26+k) ch=num2str(contatore); salv=strcat('output',ch); saveas(gcf, salv, 'jpg') contatore=contatore+1; end end

end %Richiamo della funzione che genera il codice da compilare e compilazione %del suddetto salv=generamappaBZ_mod(frame*3,colore,path_desk,path_comp) compila(frame,path_comp); move(path_comp,salv); del=strcat(w_path.path,'\*.jpg'); delete(del); case 5

% Spiral wave FitzH-Nagumo

passo=50; SpiralWaves1(1,1,700,passo); salv=generamappaSW1(frame,path_desk,path_comp) compila(frame,path_comp); move(path_comp,salv); del=strcat(w_path.path,'\*.jpg'); delete(del);

Stesso identico procedimento per quanto riguarda Spiral wave2 %Equazione sistema di Lorenz function dy = lorenzequation(t,y) data=getappdata(gcbf,'metricdata'); b=data.edit5; s=data.edit6; r=data.edit7; dy = zeros(3,1); dy(1) = - s*y(1) + s*y(2); dy(2) = - y(1)*y(3) + r*y(1) - y(2); dy(3) = y(1)*y(2) - b*y(3);

%Equazione Sitema di Rossler function dy=rossler(t,y)

61

data=getappdata(gcbf,'metricdata'); a=data.edit9; b=data.edit10; c=data.edit11; dy=zeros(3,1); dy(1)=-y(2) -y(3); dy(2)=y(1)+ a*y(2); dy(3)= b+y(3)*(y(1) -c);

FUNZIONE MAPPALORENTZ

Tale funzione prende in ingresso: il numero di frame da generare, i parametri relativi al sistema, i path specifici e insieme alla funzioni generaframe crea le frame e il codice c da compilare successivamente. function [salv]=mappaLorentz(numeroframe,colore,r,s,b,y0,t0,tfinal,path_desk,path_comp) %gestione delle variabili data=getappdata(gcbf,'metricdata'); data.edit5=b; data.edit6=s; data.edit7=r; setappdata(gcbf,'metricdata',data); %calcolo del sistema [t1,Y] = ode45(@lorenzequation,[t0 tfinal],y0); xlimits = [t0 tfinal]; ylimits = [ceil(min(min(Y(:,1))))-5 ceil(max(max(Y(:,1))))+5]; Yt = [Y(:,1)]; figure plot_view = [0,90]; xlimits = [ceil(min(min(Y(:,1))))-5 ceil(max(max(Y(:,1))))+5]; ylimits = [ceil(min(min(Y(:,2))))-5 ceil(max(max(Y(:,2))))+5]; zlimits = [ceil(min(min(Y(:,3))))-5 ceil(max(max(Y(:,3))))+5]; %creazione della directory contenete i file generati r1=num2str(r); s1=num2str(s); b1=num2str(b); nome=strcat('Lorentz_','r=',r1,'_s=',s1,'_b=',b1) salv=strcat(path_desk,nome); mkdir(salv); pathh=strcat(path_desk,nome,'\parametri.txt'); fid = fopen(pathh,'w'); fprintf(fid, 'y0=%d, \n', y0); fprintf(fid, 't0=%d, \n', t0); fprintf(fid, 'tfinal=%d, \n', tfinal); fprintf(fid, 'r=%d, \n', r); fprintf(fid, 's=%d, \n', s); fprintf(fid, 'b=%d, \n', b); fclose(fid);

62

%richiamo funzioni successive generaframe(numeroframe,Y); generamappa_comp(numeroframe,colore,path_comp); %funzione usata per generare le frame del sistema di Lorentz function []=generaframe(numero,vettore) dim=size(vettore) indice=dim(1)/numero; passo=40; fine=0; for i=1:numero fine=fine+passo; plot(vettore(1:fine,1),vettore(1:fine,2)); ch=num2str(i); salv=strcat('output',ch); saveas(gcf, salv, 'jpg'); end

per quanto riguarda le restanti funzioni, mappaRossler, mappaChua etc. il codice non ha subito sostanziali modifiche rispetto a quello giĂ visualizzato. FUNZIONE GENERAMAPPABZ

% Funzione che permette di creare il codice per rappresentare la % BZ-reaction function [salv]=generamappaBZ_mod(frame,colore,path_desk,path_comp) contatore=1; for i=1:3:frame %numero di frame da generare s1=num2str(contatore); %fase di image processing necessaria per binarizzare l'immagine ed estrarre % quindi le informazioni utili alla rapprensentazione val=strcat('output',s1,'.jpg'); A=imread(val); B=rgb2gray(A); bw=im2bw(B); se=strel('disk',3); C=imdilate(bw,se); D=imclose(C,se); figure I2=imcrop(D,[157 321 920 230]); Re=imresize(I2,[16,64]); imshow(Re); BW=zeros(16,64);

63

BW=~Re;

% fase di creazione e salvataggio nell'apposita cartella del codice c che % dovrĂ essere compilato dim=size(BW); endx=dim(1); endy=dim(2); % mkdir('C:\Documents and Settings\Administrator\Desktop\BZ'); % s2=strcat('C:\Documents and Settings\Administrator\Desktop\BZ\matrice',s1,'.c'); salv=strcat(path_desk,'BZ'); mkdir(salv); s2=strcat(path_comp,'\matrice',s1,'.c'); fid = fopen(s2,'w'); count=0; fprintf(fid,'#include <pic.h> \n'); fprintf(fid,'__CONFIG(WDTDIS & HS & UNPROTECT); \n'); fprintf(fid,'#define Line_SELA RC0 \n '); fprintf(fid,'#define Line_SELB RC1 \n '); fprintf(fid,'#define Line_SELC RC2 \n '); fprintf(fid,'#define Line_SELD RC3 \n '); fprintf(fid,'#define Line_EN RB1 \n '); fprintf(fid,'#define LAT RB2 \n '); fprintf(fid,'#define CLK RB3 \n '); fprintf(fid,'#define DAT_R1 RC4 \n '); fprintf(fid,'#define DAT_R2 RC5 \n '); fprintf(fid,'#define DAT_G1 RC6 \n '); fprintf(fid,'#define DAT_G2 RC7 \n'); fprintf(fid,'#define KEY RB0 \n'); fprintf(fid,'bank2 unsigned char keydata,key_last,key_now;\n'); fprintf(fid, 'const unsigned char presstest[128]={\n'); endy=endy; for i=1:endx for j=1:8:endy a=num2str(~BW(i,j)); b=num2str(~BW(i,j+1)); c=num2str(~BW(i,j+2)); d=num2str(~BW(i,j+3)); e=num2str(~BW(i,j+4)); f=num2str(~BW(i,j+5)); g=num2str(~BW(i,j+6)); h=num2str(~BW(i,j+7)); stringa=strcat(h,g,f,e,d,c,b,a); valore=bin2hex(stringa); count=count+1; if(count==8) count=0; fprintf(fid, '0x%s, \n', valore); else fprintf(fid, '0x%s,', valore); end end end fprintf(fid, '};'); fprintf(fid, 'void delay_sometime(unsigned char delaytime);\n'); fprintf(fid, 'void init(void){ \n');

64

fprintf(fid, 'TRISA=0b0000;\n '); fprintf(fid, 'TRISB=0b00001; \n '); ‌. ‌.. fprintf(fid, 'while(1){\n'); fprintf(fid, 'judgekey();\n'); fprintf(fid, 'rundisplay();}\n'); fprintf(fid, '}\n'); fclose(fid); contatore=contatore+1; end salvv=strcat('output_immagine'); saveas(gcf, salvv, 'jpg');

FUNZIONE SPIRAWAVES1 %funzione che implementa una spiralwave sfruttanto il modello di %FitzHugh-Nagumo function [conta]=SpiralWaves1(StimProtocol,iniziof,finefr,passoc) conta=1; k=iniziof; finef=finefr; ncols=64;%128; % Number of columns in domain nrows=16;%128; % Number of rows in domain dur=2500; % Number of time steps h=2.0; % Grid size h2=h^2; dt=0.15; % Time step Iex=30; % Amplitude of external current mu=1.0; % Anisotropy Gx=1; Gy=Gx/mu; % Conductances a=0.13; b=0.013; c1=0.26; c2=0.1; d=1.0; % FHN model parameters v=zeros(nrows,ncols); % Initialize voltage array r=v; % Initialize refractoriness array % Set initial stim current and pattern iex=zeros(nrows,ncols); if StimProtocol==1 %iex(15:20,15:20)=Iex; %iex(62:67,62:67)=Iex; iex(8:10,32:34)=Iex; else iex(:,1)=Iex; end figure % Setup image ih=imagesc(v); set(ih,'cdatamapping','direct') colormap(hot); axis image off; th=title(''); set(gcf,'position',[500 300 800 600],'color',[1 1 1],'menubar','none') % Create 'Quit' pushbutton in figure window uicontrol('units','normal','position',[.45 .02 .13 .07], ... 'callback','set(gcf,''userdata'',1)',...

65

'fontsize',10,'string','Quit'); n=0; k=0; done=0;

% Counter for time loop % Counter for movie frames % Flag for while loop

n1e=20; switch StimProtocol case 1 n2b=3800; n2e=3900; case 2 n2b=5400; n2e=5420; end

% Step at which to end 1st stimulus

while ~done

% % % % % %

Two-point stimulation Step at which to begin 2nd stimulus Step at which to end 2nd stimulus Cross-field stimulation Step at which to begin 2nd stimulus Step at which to end 2nd stimulus

% Time loop

if n == n1e % End 1st stimulus iex=zeros(nrows,ncols); end if n == n2b % Begin 2nd stimulus switch StimProtocol case 1 iex(62:67,49:54)=Iex; case 2 iex(end,:)=Iex; end end if n == n2e % End 2nd stimulus iex=zeros(nrows,ncols); end % Create padded v matrix to incorporate Newman boundary conditions vv=[[0 v(2,:) 0];[v(:,2) v v(:,end-1)];[0 v(end-1,:) 0]]; % Update v vxx=(vv(2:end-1,1:end-2) + vv(2:end-1,3:end) -2*v)/h2; vyy=(vv(1:end-2,2:end-1) + vv(3:end,2:end-1) -2*v)/h2; dvdt=c1*v.*(v-a).*(1-v)-c2*v.*r+iex+Gx*vxx+Gy*vyy; v_new=v + dvdt*dt; % Update r drdt=b*(v-d*r); r=r + drdt*dt; v=v_new; clear v_new % Map voltage to image grayscale value m=1+round(63*v); m=max(m,1); m=min(m,64); % Update image and text set(ih,'cdata',m); set(th,'string',sprintf('%d drawnow %if(n==2|| n==10||n==15)

%0.2f

%0.2f',n,v(1,1),r(1,1)))

66

if((n==k )& (n<finef)) ch=num2str(conta); salv=strcat('output',ch); saveas(gcf, salv, 'jpg') conta=conta+1; k=k+passoc;%Passo di campionamento della frame end n=n+1; done=(n > dur); if max(v(:)) < 1.0e-4, done=1; end % If activation extinguishes, quit early. if ~isempty(get(gcf,'userdata')), done=1; end % Quit if user clicks on 'Quit' button. end close(gcf)

FUNZIONE GENERAMAPPASW1

%funzione che si occupa di creare i file .c che saranno compilati function [salv]=generamappaSW1(frame,path_desk,path_comp) frame=frame-1; for i=1:frame %questa sezione si occupa,attraverso tecniche di image processing di %estrapolare dall'immagine le informazioni utili alla sua rappresentazione s1=num2str(i); val=strcat('output',s1,'.jpg'); A=imread(val); B=rgb2gray(A); bw=im2bw(B,0.2); Re = imcrop(bw,[320 322 600 200]); Re=imresize(Re,[16,64]); figure imshow(Re); salv=strcat('output_immagine',s1); saveas(gcf, salv, 'jpg'); BW=zeros(16,64); BW=~Re; dim=size(BW); endx=dim(1); endy=dim(2); dim=size(BW) endx=dim(1); endy=dim(2); %creazione della diretcory che conterrĂ i file salv=strcat(path_desk,'Spiral Wave 1'); mkdir(salv); s2=strcat(path_comp,'\matrice',s1,'.c');

67

%creazione del file .c fid = fopen(s2,'w'); count=0; fprintf(fid,'#include <pic.h> \n'); fprintf(fid,'__CONFIG(WDTDIS & HS & UNPROTECT); \n'); fprintf(fid,'#define Line_SELA RC0 \n '); fprintf(fid,'#define Line_SELB RC1 \n '); fprintf(fid,'#define Line_SELC RC2 \n '); …. …. …. fprintf(fid, 'rundisplay();}\n'); fprintf(fid, '}\n'); fclose(fid); end

FUNZIONE COMPILA %questa funzione di occupa di richiamare ed eseguire il compilatore dell’ %HI-TECH creando così i file .hex da passare al PIC function []=compila(numeroframe) %posizionamento nella directory di lavoro del compilatore working_path=what; cd(path_comp); if numeroframe==1 %esecuzione del compilatore !PICC.exe --CHIP=16F57 -C matrice1.c !PICC.exe --CHIP=16F57 matrice1.obj end if numeroframe ==2 !PICC.exe --CHIP=16F57 -C !PICC.exe --CHIP=16F57 !PICC.exe --CHIP=16F57 end if numeroframe ==3 !PICC.exe --CHIP=16F57 -C !PICC.exe --CHIP=16F57 !PICC.exe --CHIP=16F57 !PICC.exe --CHIP=16F57

matrice1.c matrice2.c matrice1.obj matrice2.obj

matrice1.c matrice2.c matrice3.c matrice1.obj matrice2.obj matrice3.obj

….. …. !PICC.exe !PICC.exe !PICC.exe !PICC.exe

--CHIP=16F57 --CHIP=16F57 --CHIP=16F57 --CHIP=16F57

matrice27.obj matrice28.obj matrice29.obj matrice30.obj

end %riposizionamento nella directory principale

68

cd(working_path.path);

FUNZIONE GENERAMAPPA_COMP

La funzione generamappa_comp si occupa di creare all’interno della cartella del compilatore il codice C in modo da renderne agevole la compilazione.

%funzione usata per generare il codice c relativo alle frame estratte dal %sistema di Lorentz function []=generamappa_comp(frame,colore,path_comp) for i=1:frame %numero di frame s1=num2str(i); val=strcat('output',s1,'.jpg'); %fase di image processing necessaria per binarizzare l'immagine ed estrarre % quindi le informazioni utili alla rapprensentazione A=imread(val); A=rgb2gray(A); A = imcrop(A,[170 84 900 700]); A = imresize(A,[16 64]); level = graythresh(A); BW = im2bw(A,level); imshow(BW) % fase di creazione e salvataggio nell'apposita cartella del codice c che % dovrĂ essere compilato matriceh=zeros(4,8); dim=size(BW); endx=dim(1); endy=dim(2); %s=strcat('C:\Program Files\HI-TECH Software\PICC\std\9.60\bin'); % s2=strcat(s,'\matrice',s1,'.c');

s2=strcat(path_comp,'\matrice',s1,'.c'); fid = fopen(s2,'w'); count=0; fprintf(fid,'#include <pic.h> \n'); fprintf(fid,'__CONFIG(WDTDIS & HS & UNPROTECT); \n'); fprintf(fid,'#define Line_SELA RC0 \n '); fprintf(fid,'#define Line_SELB RC1 \n '); fprintf(fid,'#define Line_SELC RC2 \n '); fprintf(fid,'#define Line_SELD RC3 \n '); fprintf(fid,'#define Line_EN RB1 \n '); fprintf(fid,'#define LAT RB2 \n '); fprintf(fid,'#define CLK RB3 \n '); fprintf(fid,'#define DAT_R1 RC4 \n '); fprintf(fid,'#define DAT_R2 RC5 \n '); fprintf(fid,'#define DAT_G1 RC6 \n ');

69

fprintf(fid,'#define DAT_G2 RC7 \n'); fprintf(fid,'#define KEY RB0 \n'); fprintf(fid,'bank2 unsigned char keydata,key_last,key_now;\n'); fprintf(fid, 'const unsigned char presstest[128]={\n'); for i=1:endx for j=1:8:endy a=num2str(~BW(i,j)); b=num2str(~BW(i,j+1)); c=num2str(~BW(i,j+2)); d=num2str(~BW(i,j+3)); e=num2str(~BW(i,j+4)); f=num2str(~BW(i,j+5)); g=num2str(~BW(i,j+6)); h=num2str(~BW(i,j+7)); stringa=strcat(h,g,f,e,d,c,b,a); valore=bin2hex(stringa) count=count+1; if(count==8) count=0; fprintf(fid, '0x%s, \n', valore); else fprintf(fid, '0x%s,', valore); end end end fprintf(fid, '};'); fprintf(fid, 'void delay_sometime(unsigned char delaytime);\n'); fprintf(fid, 'void init(void){ \n'); fprintf(fid, 'TRISA=0b0000;\n '); fprintf(fid, 'TRISB=0b00001; \n '); ….. …. …. fprintf(fid, 'judgekey();\n'); fprintf(fid, 'rundisplay();}\n'); fprintf(fid, '}\n'); fclose(fid); end

70

II SEZIONE FUNZIONE LAVAPOS_OPENINGFcn (MAIN) function lavapos_OpeningFcn(hObject, eventdata, handles, varargin) % This function has no output args, see OutputFcn. % hObject handle to figure % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % varargin command line arguments to lavapos (see VARARGIN) handles.output = hObject; %creazione del blocco di led matrix virtuale guidata(hObject, handles); q=[ handles.led11 handles.led12 handles.led13 handles.led14 handles.led15 handles.led16 handles.led17 handles.led18 ; handles.led21 handles.led22 handles.led23 handles.led24 handles.led25 handles.led26 handles.led27 handles.led28 ; handles.led31 handles.led32 handles.led33 handles.led34 handles.led35 handles.led36 handles.led37 handles.led38 ; handles.led41 handles.led42 handles.led43 handles.led44 handles.led45 handles.led46 handles.led47 handles.led48 ; handles.led51 handles.led52 handles.led53 handles.led54 handles.led55 handles.led56 handles.led57 handles.led58 ; handles.led61 handles.led62 handles.led63 handles.led64 handles.led65 handles.led66 handles.led67 handles.led68 ; handles.led71 handles.led72 handles.led73 handles.led74 handles.led75 handles.led76 handles.led77 handles.led78 ; handles.led81 handles.led82 handles.led83 handles.led84 handles.led85 handles.led86 handles.led87 handles.led88 ;]; l=[ handles.l11 handles.l12 handles.l13 handles.l14 handles.l15 handles.l17 handles.l18 ; handles.l21 handles.l22 handles.l23 handles.l24 handles.l25 handles.l27 handles.l28 ];

handles.l16 handles.l26

ml=[ handles.mled11 handles.mled12 handles.mled13 handles.mled14 handles.mled15 handles.mled16 handles.mled17 handles.mled18 ; handles.mled21 handles.mled22 handles.mled23 handles.mled24 handles.mled25 handles.mled26 handles.mled27 handles.mled28 ]; %procedura di inizializzazione dello stesso for i=1:2 for j=1:8 set(l(i,j),'Backgroundcolor',[0,0,0]) end end global A; A=zeros(16,64); for i=1:8 for j=1:8 set(q(i,j),'value',0) ; set(q(i,j),'BackgroundColor',[0,0,0]) ;

71

end end

if(get(q(i,j),'value')==1 ) set(q(i,j),'BackgroundColor',[1,0,0]) ; end set(handles.radiobutton17,'value',1); set(handles.radiobutton18,'value',0); for i=1 :2 for j= 1 : 8 set(ml(i,j),'value',0) end end

% Pulsante Elaborate (2) function pushbutton4_Callback(hObject, eventdata, handles) %settaggio path path_comp='C:\Program Files\HI-TECH Software\PICC\std\9.60\bin\'; path_desk='C:\Documents and Settings\Administrator\Desktop\'; %controllo dimensione frase colore=0; if(get(handles.radiobutton17,'value')==1) colore=1; else colore=0; end frase=(get(handles.edit1,'string')); dimfrase=size(frase) dimfrase(2); if(dimfrase(2)>15) errordlg('La parola deve essere di 15 lettere','error'); else %richiamo della funzione che si occupa della codifica della frase fraseCompletat(frase,colore,path_desk,path_comp); end

% pulsante Next frame function pushbutton5_Callback(hObject, eventdata, handles) global A; %gestione di frame multipli generati dal blocco di led matrix virtuale q=[ handles.led11 handles.led12 handles.led13 handles.led14 handles.led15 handles.led16 handles.led17 handles.led18 ;

72

handles.led21 handles.led22 handles.led23 handles.led26 handles.led27 handles.led28 ; handles.led31 handles.led32 handles.led33 handles.led36 handles.led37 handles.led38 ; handles.led41 handles.led42 handles.led43 handles.led46 handles.led47 handles.led48 ; handles.led51 handles.led52 handles.led53 handles.led56 handles.led57 handles.led58 ; handles.led61 handles.led62 handles.led63 handles.led66 handles.led67 handles.led68 ; handles.led71 handles.led72 handles.led73 handles.led76 handles.led77 handles.led78 ; handles.led81 handles.led82 handles.led83 handles.led86 handles.led87 handles.led88 ;];

handles.led24 handles.led25 handles.led34 handles.led35 handles.led44 handles.led45 handles.led54 handles.led55 handles.led64 handles.led65 handles.led74 handles.led75 handles.led84 handles.led85

ml=[ handles.mled11 handles.mled12 handles.mled13 handles.mled14 handles.mled15 handles.mled16 handles.mled17 handles.mled18 ; handles.mled21 handles.mled22 handles.mled23 handles.mled24 handles.mled25 handles.mled26 handles.mled27 handles.mled28 ]; l=[ handles.l11 handles.l12 handles.l13 handles.l14 handles.l15 handles.l17 handles.l18 ; handles.l21 handles.l22 handles.l23 handles.l24 handles.l25 handles.l27 handles.l28 ];

handles.l16 handles.l26

K=zeros(16,64); count=1; for t=1:2 for y=1:8 if(get(ml(t,y),'value')==1) riga=t; colonna=y; end end end if( get(handles.radiobutton17,'value')==1) set(l(riga,colonna),'Backgroundcolor',[0 ,1,0]) else set(l(riga,colonna),'Backgroundcolor',[1 ,0,0]) end a=zeros(8,8); for i=1:8 for j=1:8 if((get(q(i,j),'value')==1 )) if (get(handles.radiobutton17,'value')==1) set(q(i,j),'BackgroundColor',[0,1,0]) ; else set(q(i,j),'BackgroundColor',[1,0,0]) ; a(i,j)=1; end else a(i,j)=0; end

73

end end

for i=1 :8 for j=1:8 A((riga-1)*8+i,(colonna-1)*8+j)=a(i,j); end end riga; colonna; for i=1:2 for j=1:8 set(ml(t,y),'value',0); end end

% Elaborate (1) function pushbutton1_Callback(hObject, eventdata, handles) % esegue la funzione genera scritta2 che permette di creare il codice c % contenete l'immagine ,ottenuta attraverso l'uso del comando "Next frame" global A; %settaggio path path_comp='C:\Program Files\HI-TECH Software\PICC\std\9.60\bin\'; path_desk='C:\Documents and Settings\Administrator\Desktop\'; colore=0; if(get(handles.radiobutton17,'value')==1) colore=1; else colore=0; end salv=generascrittacomp(A,colore,path_desk,path_comp); compila(1,path_comp); move(path_comp,salv);

FUNZIONE FRASECOMPLETAT %funzione che si occupa della codifica della frase scritta all'interno %della text box function []=fraseCompletat(fras,colore,path_desk,path_comp) a=[0 1 1 1 1 1 1 0;0 1 0 0 0 0 1 0;0 1 0 0 0 0 1 0;0 1 0 0 0 0 1 0;0 1 1 1 1 1 1 0;0 1 0 0 0 0 1 0;0 1 0 0 0 0 1 0;0 1 0 0 0 0 1 0]; b=[0 1 1 1 1 0 0 0;0 1 0 0 0 1 0 0;0 1 1 1 1 0 0 0;0 1 0 0 0 1 0 0;0 1 0 0 0 0 1 0;0 1 0 0 0 0 1 0;0 1 0 0 0 0 1 0;0 1 1 1 1 1 0 0]; c=[0 1 1 1 1 1 1 0;0 1 0 0 0 0 0 0;0 1 0 0 0 0 0 0;0 1 0 0 0 0 0 0;0 1 0 0 0 0 0 0;0 1 0 0 0 0 0 0;0 1 0 0 0 0 0 0;0 1 1 1 1 1 1 0];

74

…… ……. ….. %controllo dimensioni frase A=fras; dime=size(A); dime=dime(2); ledm=zeros(16,64); dim=8; val=0; val1=0; if(dime>15) frase=('Frase troppo lunga!!') return; end for in=1:dime if(in>=8) val=8; val1=7; end if strcmp(A(in),'a') for jn=1:8 for kn=1:8 mn=jn+val; ln=((in-1-val1)*dim)+kn; ledm(mn,ln)=a(jn,kn); end end end

%procedura di codifica for in=1:dime if(in>=8) val=8; val1=7; end if strcmp(A(in),'a') for jn=1:8 for kn=1:8 mn=jn+val; ln=((in-1-val1)*dim)+kn; ledm(mn,ln)=a(jn,kn); end end end if strcmp(A(in),'b') for jn=1:8 for kn=1:8 ln=((in-1-val1)*dim)+kn; mn=jn+val; ledm(mn,ln)=b(jn,kn);

75

end end end

….. ….. ….. if strcmp(A(in),'9') for jn=1:8 for kn=1:8 ln=((in-1-val1)*dim)+kn; mn=jn+val; ledm(mn,ln)=n9(jn,kn); end end end end dim=size(ledm); endx=dim(1); endy=dim(2); %richiamo delle funzioni che permettono di creare il codice c % e compilarlo %richiamo delle funzioni che permettono di creare il codice c % e compilarlo salv=generascrittacomp(ledm,colore,path_desk,path_comp); compila(1,path_comp); move(path_comp,salv);

FUNZIONE GENERASCRITTA_COMP

% funzione che crea il codice c contenete il frame da rapprensentare che % verrà compilato in automatico function [salv]=generascrittacomp(BW,colore,path_desk,path_comp) dim=size(BW) endx=dim(1); endy=dim(2); BW=~BW;

% creazione e salvataggio, nella directory del compilatore, del file % rappresentante la frame da visualizzare salv=strcat(path_desk,'\Manual plot'); mkdir(salv); s2=strcat(path_comp,'\matrice1.c'); fid = fopen(s2,'w');

76

count=0; fprintf(fid,'#include <pic.h> \n'); fprintf(fid,'__CONFIG(WDTDIS & HS & UNPROTECT); \n'); fprintf(fid,'#define Line_SELA RC0 \n '); fprintf(fid,'#define Line_SELB RC1 \n '); fprintf(fid,'#define Line_SELC RC2 \n '); fprintf(fid,'#define Line_SELD RC3 \n ');

… … fprintf(fid, '}\n'); fclose(fid); end

APPENDICE B

Procedura di generazione di frame per la Led Matrix:

1) Selezionare dal tool il sistema di interesse. 2) Impostare i parametri(oltre ai parametri caratteristi dei sistemi è necessario impostare il numero di frame che si desidera visualizzare sulla Led Matrix) 3) Premere RunPlot->sulla figure viene rappresentata l’evoluzione del sistema selezionato. 4) L’evoluzione del sistema è trasformata in una sequenza di frame che sono poi elaborate e binarizzate con tecniche di image enhancement. Poiché è stata mantenuta una simmetria tra il dominio del sistema dinamico e quello della matrice. Ad ogni punto del dominio corrisponderà un led che a seconda del valore risulterà acceso o spento. 5) Dalla matrice ottenuta dalla binarizzazione si otterranno dei valori esadecimale che verranno trasformati nella frame per la led matrix. 6) Il codice generato è poi compilato mediante Hi tech compiler. Viene generato un file *.hex. 7) Il sorgente .hex viene spostato sul PIC16F57 della demoboard Sure mediante Pickit 2.0.

77

Issuu converts static files into: digital portfolios, online yearbooks, online catalogs, digital photo albums and more. Sign up and create your flipbook.