Embed Size (px)
DESCRIPTION
tesina sistemi complessi
Citation preview
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
Ing. M.Frasca Ing. A.Buscarino
Ing. C. Camerano
Di Mauro Gianluca Patti Giuseppe
2
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
3
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
4
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.
5
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
𝑑𝑑𝑑𝑑 (𝑡𝑡)𝑑𝑑𝑡𝑡
=F(x(t)) (2.1)
nel caso continuo,
𝑋𝑋(𝑡𝑡 + 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
6
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∞ .
7
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|∗ … . .∗ |𝐸𝐸1|
|𝐸𝐸0| (2.3)
Da cui usando una rappresentazione logaritmica
1𝑛𝑛 ln𝐸𝐸𝑛𝑛
𝐸𝐸0=∑ 𝑙𝑙𝑛𝑛 𝐸𝐸𝑘𝑘
𝐸𝐸𝑘𝑘−1
𝑛𝑛𝑘𝑘 (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
𝜆𝜆(𝑑𝑑0)=lim𝑛𝑛→∞ lim𝐸𝐸0→01𝑛𝑛∑ 𝐸𝐸𝑘𝑘
𝐸𝐸𝑘𝑘−1
𝑛𝑛𝑘𝑘 =lim𝑛𝑛→∞
1𝑛𝑛∑ |𝑓𝑓′(𝑑𝑑𝑘𝑘−1)|𝑛𝑛𝑘𝑘 (2.5)
8
(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) ̇ =𝜆𝜆 δ(t)+kδ(t) 2 (2.6)
9
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 (δ(t) ̇ =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.
10
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:
⎩⎪⎨
⎪⎧
𝑑𝑑𝑑𝑑𝑑𝑑𝑡𝑡
= 𝜎𝜎(𝑦𝑦 − 𝑑𝑑)
𝑑𝑑𝑦𝑦𝑑𝑑𝑡𝑡
= −𝑑𝑑𝑥𝑥 + 𝑟𝑟𝑑𝑑 − 𝑦𝑦𝑑𝑑𝑥𝑥𝑑𝑑𝑡𝑡
= 𝑑𝑑𝑦𝑦 − 𝑏𝑏𝑥𝑥
� (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.
11
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.
12
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
13
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.
14
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.
15
• 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.
16
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
17
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.
18
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
19
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+.
20
⎩⎪⎨
⎪⎧𝜕𝜕𝑑𝑑𝜕𝜕𝑡𝑡
= 𝑑𝑑 + 𝑦𝑦 − 𝛼𝛼𝑑𝑑2 − 𝑑𝑑𝑦𝑦 + 𝐷𝐷1∇2𝑑𝑑𝜕𝜕𝑦𝑦𝜕𝜕𝑡𝑡
= −𝑦𝑦 + 𝐵𝐵𝑥𝑥 − 𝑑𝑑𝑦𝑦 + 𝐷𝐷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.
21
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;
22
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.
23
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.
24
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.
25
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.
26
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.
27
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 :
28
• 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.
29
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.
30
• 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.
31
• 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.
32
• 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.
33
• 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.
34
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
35
• 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.
36
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.
37
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.
38
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
39
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.
40
Fig.4.7 Piedinature del PIC16F57.
Schema delle porte del Pic 16F57:
Fig.4.8 definizione porte del PIC16F57.
41
Fig.4.9 Legenda delle porte del PIC16F57.
Definizione Porte
Fig.4.10 Corrispondenza delle porte del PIC16F57.
42
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
43
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.
44
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.
45
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.
46
Fig.5.1.1 Attrattore di Lorenz B= 8/3 σ=10 r=28.
47
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.
48
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.
49
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.
50
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.
51
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
52
5.4 La BZ-reaction
Le figure 5.4.1 rappresentano i risultati ottenuti simulando l’evoluzione di una BZ reaction.
53
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.
54
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.
55
Fig.5.5.2 Autowaves a=20; b=0.91; c1=0.70; c2=0.7; d=5.
56
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;
57
%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)];
58
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); ….. …..
59
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
60
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 25]; ylimit = [-30 30]; n=16; m=64; 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(x-1,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);
61
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)
62
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);
63
%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);
64
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');
65
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)',...
66
'fontsize',10,'string','Quit'); n=0; % Counter for time loop k=0; % Counter for movie frames done=0; % Flag for while loop n1e=20; % Step at which to end 1st stimulus switch StimProtocol case 1 % Two-point stimulation n2b=3800; % Step at which to begin 2nd stimulus n2e=3900; % Step at which to end 2nd stimulus case 2 % Cross-field stimulation n2b=5400; % Step at which to begin 2nd stimulus n2e=5420; % Step at which to end 2nd stimulus end while ~done % 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 %0.2f %0.2f',n,v(1,1),r(1,1))) drawnow %if(n==2|| n==10||n==15)
67
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');
68
%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 matrice1.c matrice2.c !PICC.exe --CHIP=16F57 matrice1.obj !PICC.exe --CHIP=16F57 matrice2.obj end if numeroframe ==3 !PICC.exe --CHIP=16F57 -C matrice1.c matrice2.c matrice3.c !PICC.exe --CHIP=16F57 matrice1.obj !PICC.exe --CHIP=16F57 matrice2.obj !PICC.exe --CHIP=16F57 matrice3.obj ….. …. !PICC.exe --CHIP=16F57 matrice27.obj !PICC.exe --CHIP=16F57 matrice28.obj !PICC.exe --CHIP=16F57 matrice29.obj !PICC.exe --CHIP=16F57 matrice30.obj end %riposizionamento nella directory principale
69
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 ');
70
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
71
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.l16 handles.l17 handles.l18 ; handles.l21 handles.l22 handles.l23 handles.l24 handles.l25 handles.l26 handles.l27 handles.l28 ]; 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]) ;
72
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 ;
73
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 ;]; 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.l16 handles.l17 handles.l18 ; handles.l21 handles.l22 handles.l23 handles.l24 handles.l25 handles.l26 handles.l27 handles.l28 ]; 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
74
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];
75
……
…….
…..
%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);
76
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');
77
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.
