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
This document is posted to help you gain knowledge. Please leave a comment to let me know what you think about it! Share it to your friends and learn new things together.
Transcript
1
UNIVERSITA’ DEGLI STUDI DI CATANIA
Corso di Laurea in Ingegneria dell’ Automazione e Controllo dei sistemi complessi
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
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
% 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
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)
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);
%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');
%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 ');
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 ;
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);
%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');
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.