Controllore Fuzzy in VHDL

[cavetto]

Scusate,
dovrei realizzare un controllore fuzzy in vhdl.
Si tratterebbe di tenere sotto controllo la velocità di un motore attraverso regolazione PWM.
Il modulo PWM funziona, vedi post :http://www.delucagiovanni.com/public/phpbb3/viewtopic.php?f=10&t=244

In ingresso ho un segnale del tipo encoder relativo collegato all'asse del motore.

Il discorso è che è dovrei realizzare il controllo non con un PID ma con un controllore Fuzzy
implementato su FPGA.

C'è qualcuno che ha esperienza e che mi può aiutare?

Vi ringrazio a priori.

[Micos]

cavetto,
ho letto il tuo topic, ma non saprei come aiutarti.

Ho sentito parlare di logica-fuzzy per realizzare controlli al posto del classico PID.

Ma tu hai esperienza con il fuzzy, parlo di fuzzificazione, defuzzificazione ecc. ?
Io ho visto qualcosa ma ci ho capito pochissimo, penso siamo argomenti puramente teorici.
Piacerebbe anche a me capirci qualcosa, soprattutto realizzare qualcosa con le fpga.

ciao

[deluca]

Se volete, tenterò di aiutarvi in questo percorso abbastanza complesso specie se partite da zero.

Il controllo della velocità di rotazione dei motori è abbastanza complicato quando viene realizzato utilizzando le tradizionali
tecniche di controllo (PID), poiché esso richiede un modello matematico abbastanza complesso.
L'uso della logica Fuzzy elimina la necessità di modellazione matematica e consente una facile realizzazione di una soluzione.

La logica fuzzy definisce le regole che determinano il comportamento del sistema usando le descrizioni tramite linguaggio naturale invece di
equazioni matematiche.

L'algoritmo Fuzzy si compone di tre fasi:
1. Fuzzificazione
2. Inferenza Fuzzy
3. Defuzzificazione

Non so se avete mai sentito parlare di queste definizioni....
Sarebbe cosa buona, prima di parlare di vhdl e fpga, prendere dimestichezza con questi termini e magari tentare di chiarirli
implementando l'algoritmo Fuzzy attraverso uno pseudo-firmware che potrebbe girare su di un micro-controllore risc classico.

La fuzzificazione è il processo che determina il grado di appartenenza dei valori di input per definire i fuzzy-sets (variabili linguistiche).
Nel caso della rotazione di un motore i valori di input sono:

1. Errore assoluto nella velocità di rotazione dato da:
Error = SetSpeed - CurrentSpeed
2. Errore Differenziale che è ottenuto sottraendo l'errore precedente (l'ultimo) al valore corrente:
dError = Error - LastError

Per stabilizzare e controllare la velocità di un motore possiamo definire 5 fuzzy-sets per i valori di input Error e dError:

1. NM. negative medium
2. NS. negative small
3. ZE. zero
4. PS. positive small
5. PM. positive medium

Ammettiamo di voler realizzare un controllo per la stabilizzazione della velocità di un motore in CC provvisto di un encoder relativo che genera una ventina di impulsi per giro del motore....

A presto

[virtus]

Un saluto a tutti gli iscritti al forum.

Ho sniffato un pò tra i topics, non male, un pò pochini gli iscritti, ma devo dire non male.
Complimenti all'amministratore , credo di aver capito sia deluca.

Io sono un appassionato di electronic-topics (si fa per dire) e realizzo qualche progettino con i micro atmel (tipo arduino) ma
vorrei tanto imparare ad usare anche le logiche programmabili.

Il discorso sul controllore fuzzy (anche non VHDL) mi interessa tantissimo (ne ho tanto sentito parlare ma mai implementato praticamente).
Spero che deluca o un vice-deluca abbia tempo per chiarirmi un pò le idee.

Ancora saluti a tutti

[deluca]

Dalla rete è possibile scaricare centinaia di PDF, trattati, pubblicazioni e libri di testo che parlano di logica Fuzzy ma purtroppo molta di questa documentazione è puramente teorica. DOCs su vere e proprie applicazioni pratiche in giro ce nè veramente poco. Per questo motivo ho deciso di trattare l'argomento attraverso la presentazione di documentazione semplice ma soprattutto cercando di dare la possibilità a tutti di scrivere del firmware pronto da essere implemento su microcontrollori generici e FPGA.

Visto che reputo questo topic abbastanza interessante ho voluto scrivere un piccolo PDF con il quale cercherò di spiegare in modo semplicistico come utilizzare l'algoritmo Fuzzy per controllare la velocità di rotazione di un motore alimentato in CC su cui è attaccato fisicamente un encoder rotativo relativo (Parte prima).
Si tratta di una descrizione elementare ma che dà l'idea su come usare ed implementare praticamente il Fuzzy-Logic su di un microcontrollore generico.

http://www.delucagiovanni.com/Fuzzy%20Logic%20-%20Speed%20Motor%20Control.pdf

Ciao e a presto

[virtus]

Grazie deluca per aver preso in considerazione la mia richiesta.

Devo dire che il tuo pdf, appena scaricato e visionato, nella sua semplicità mi ha chiarito delle lacune che mi portavo dietro
da un bel po di tempo. Spero che potrai trovare il tempo per continuare il lavoro che hai iniziato.

Grazie ancora e lieto di aver fatto tua conoscenza anche se in modo virtuale.

[flz47655]

Volevo solamente segnalare che ho trovato un'introduzione alla logica fuzzy (6 pagine) sul n.140 di Fare Elettronica, articolo facente parte di una serie dedicata all'intelligenza artificiale

Ciao
EDIT: ho sbagliato a scrivere, il numero è il 240

[virtus]

deluca, o chi mi può aiutare,
ho letto il tuo tutorial preliminare ma mi sono nati moltissimi dubbi e ho allegato porzione della pagina che me li ha fatti venire.
Non riesco a capire come viene generato il vettore di uscita Y a partire dalla tavola delle inferenze e avendo vettori errori:

X1[]=[0h, 0h, 3D0h, 30h, 0h]
X2[]=[0h, 0h, 3F0h, 10h, 0h]

come da tuo esempio.

Code: Select all

2. Inferenza Fuzzy
Per generare le Fuzzy-Inference abbiamo necessità di elaborare le relazioni min-max di Zadeh perché l’esperienza e la letteratura ci dicono che esse danno buoni risultati.
Il processo consiste nel:

1-   Pulire il vettore d’uscita Y[]
2-   Prendere il primo membro del vettore X1[]
3-   Comparare esso con ogni membro del vettore X2[]. Il valore più piccolo viene memorizzato ad ogni comparazione.
4-   Il valore massimo è trovato tra i membri ottenuti nello step 3
5-   Questo valore viene sommato al membro del vettore d’uscita il quale è definito dalle regole d’inferenza.
6-   Il prossimo membro del vettore X1[] è preso, processato e ripetuto dal passo 3 al passo 6.

Il vettore di uscita che otteniamo applicando  le inferenze fuzzy è : Y[]=[0h, 30h, 3D0h, 0h, 0h]


cioè questi valori come li ottengo ? come si calcolano ? mi sembrava molto più semplice !!!
qualcuno mi può dare una mano?

[deluca]

Prima di spiegarti l'algoritmo per applicare le regole di inferenza fuzzy vorrei sapere una cosa:
hai già risolto il problema della fuzzificazione ?
da quello che mi dici la risposta sembrerebbe SI o ho capito male.

Cioè hai già assegnato le funzioni di appartenenza, dati gli errori d'ingresso, alla funzione e calcolato i
vettori X1[] e X2[] ?

per andare avanti devo essere certo che questo step lo hai superato, se nò è inutile procedere con altre info

[virtus]

Volevo solamente segnalare che ho trovato un'introduzione alla logica fuzzy (6 pagine) sul n.140 di Fare Elettronica, articolo facente parte di una serie dedicata all'intelligenza artificiale

Ciao

flz, ma sull'indice della rivista che menzioni non si vede traccia di logica fuzzy.

Code: Select all

Numero: 140
Mese: Febbraio
Anno: 1997
Numero doppio: NO
Pagine: 116

10   Centralina d'allarme            
8   Pulce telefonica in FM         
9   Xr2206 sinus generator         
9   Superfiltro RCL         
18   Semplice tester per riflessi         
22   Love test         
26   Controllo automatico per caricabatterie         
29   Dottor square         
36   Termometro digitale con 68HC11         
42   Solar system 1' Parte         
52   Filtro di banda sui 144 MHz         
53   Stadio audio a transistor per rx         
54   Ricevitore AM FM sui 10 metri         
58   Sonda amplificata         
59   Mixer a doppio bilanciamento         
61   Filtro audio         
63   Media frequenza a banda stretta         
65   Compressore per trasmettitori         
72   Ground plane VHF         
79   Soundplayer         
86   Timer ritardatore 1-130 secondi         
90   Adc low cost         
95   Preampli phono dinamico         
102   I filtri passa alto         
108   Pulsantiera a quattro tasti         


[flz47655]

Scusatemi il numero è il 240, l'articolo è intitolato "Introduzione alla logica Fuzzy" di Antonio Di Stefano

Ciao

[virtus]

aaaaaaaaaaaah, adesso provo a cercarlo.

ma è su cartaceo o tiene un pdf-link ?

grazie

[flz47655]

Non lo so ma hai provato a cercare con google "fare elettronica n. 240"?

[virtus]

Ok trovata e comprata

ma sul n 240 alla pag.34 siamo alla parte quarta..

devo comprare gli altri numeri.

[flz47655]

Gli altri numeri parlano di altri argomenti relativi alla IA, reti neurali, etc.. non parlano di logica fuzzy purtroppo

Ciao

PS: l'autore dell'articolo tra l'altro ha scritto il paper "An FPGA-Based Adaptive Fuzzy Coprocessor" http://www.springerlink.com/content/gapbw48jekclk9ye/

[virtus]

allora, l'articolo della rivista l'ho letto, ma scusate la mia deficienza , non so voi, a parte i colori blu, verde e rosso dei triangoli "dell'universo del discorso", non riesco a trovare sulla rete globale googleana una sorta di codice, un listato, qualcosa di pratico da testare realmente su di un microC.

mi sa che la strada è lunga e tortuosa !!!

[flz47655]

Sul n.243 trovi l'implementazione di un controllo di guida fuzzy...
Ad ogni modo una volta capita la teoria dietro non mi sembra così impossibile realizzarlo.. più che altro c'è da scegliere con cognizione le regole con delle soglie sensate se si vuole qualcosa di efficace..

[deluca]

Allora ragazzi ... ci siamo bloccati ?

Prendendo come riferimento il documento che avevo precedentemente allegato,
Vi dò allora qualche dritta su come realizzare questo benedetto controllore fuzzy che potremo utilizzare per controllare la velocità di un motore in cc con accoppiato un encoder relativo. L'interrupt di un timer e una funzione di lettura passi encoder ci restituirà due informazioni : Errore assoluto ed Errore differenziale.

L'algoritmo Fuzzy si compone di tre fasi:
1. Fuzzificazione
2. Inferenza Fuzzy
3. Defuzzificazione

1. Fuzzificazione
La fuzzificazione è il processo che determina il grado di appartenenza dei valori di input per definire i fuzzy-sets (variabili linguistiche). Nel caso della rotazione di un motore i valori di input sono due:
1) Errore assoluto nella velocità di rotazione dato da: Error = SetSpeed - CurrentSpeed
2) Errore Differenziale è ottenuto sottraendo l'errore precedente (l'ultimo) al valore corrente:
dError = Error - LastError

Per controllare la velocità di un motore definiamo 5 fuzzy-sets per i valori di input Error e dError:

NM. 1 negative medium
NS. 2 negative small
ZE. 3 zero
PS. 4 positive small
PM. 5 positive medium

Ammettiamo di voler realizzare un controllo di velocità di un motore in CC a cui è accoppiato un encoder relativo che genera una ventina di impulsi per ogni giro del motore.
Le funzioni di appartenenza ( Figura 1) sono di forma triangolare e il massimo valore scalato è 400h invece di uno che di norma si trova in altri documenti che descrivono la teoria fuzzy.
Questa via riduce di molto la complessità del calcolo matematico perché le operazioni di moltiplicazione vengono effettuate usando soltanto addizioni e sottrazioni.


Il risultato della fuzzificazione dei valori di ingresso è un vettore con cinque elementi detti fuzzy-set
e il valore di ogni elemento definisce il grado di appartenenza dei valori di input ad un particolare fuzzy-set (y-value). I vettori per gli errori assoluti e differenziali, che sono il risultato della fuzzificazione, sono elencati in X1[] e X2[].

Esempio: Error = 30h, dError=10h
In questo caso in accordo alle figure 2 e 3 i risultati della fuzzificazione saranno:

X1[]=[0h, 0h, 3D0h, 30h, 0h]
X2[]=[0h, 0h, 3F0h, 10h, 0h]

Vediamo adesso come si ottengono questi due vettori attraverso uno pseudo codice C.
Alla procedura Fuzzification viene passato attraverso l’integer Value il valore Errore=30h e sequenzialmente il valore dError=10h che abbiamo precedentemente estrapolato dalla lettura di un encoder ad intervalli regolari determinati dall’interrupt del Timer del uControllore.

Per le figure e tabelle attenersi al documento allegato

Code: Select all

//-----------------------------------------------------------------------------------
// La funzione converte i valori discreti in un vettore a 5 elementi Fuzzy Vector Data[]
//-----------------------------------------------------------------------------------
void Fuzzification(int Value, int *Data)
{
  int i;

  for (i = 0; i < 5; i++)
    Data[i] = 0;

 if (Value < -0x800)
    Data[NM] = 0x400;
  else if (Value < -0x400)
  {
    Data[NM] = 0x400 - (Value + 0x800);
    Data[NS] = Value + 0x800;
  }
  else if (Value < 0)
  {
    Data[NS] = 0x400 - (Value + 0x400);
    Data[ZE] = Value + 0x400;
  }
  else if (Value < 0x400)
  {
    Data[ZE] = 0x400 - Value;
    Data[PS] = Value;
  }
  else if (Value < 0x800)
  {
    Data[PS] = 0x400 - (Value - 0x400);
    Data[PM] = Value - 0x400;
  }
  else
    Data[PM] = 0x400;
}


Alla fine di questo processo, che verrà eseguito per ognuno dei due errori, otterremo un vettore Data[i] che riassegneremo ai vettori X1[i] e X2[i] composti rispettivamente da 5 elementi:
X1[]=[0h, 0h, 3D0h, 30h, 0h]
X2[]=[0h, 0h, 3F0h, 10h, 0h]

Ci siamo fin qui ?

[cavetto]

saluti a tutti.
sto per riprendere il progetto del controllore fuzzy, che per problemi vari avevo dovuto accantonare.
devo partire con la realizzazione del decodificatore e contatore impulsi provenienti dall'encoder collegato all'asse del motore.
CHA e CHB sono i miei segnali di ingresso e sono sfasati di 90°. Dovrei per prima cosa pulirli e poi conteggiare gli impulsi in x4.
Poi cercherò di passare al resto: cioè fuzzy controller e controllore pwm + tutto il necessario.

C'è qualcuno disposto a darmi una mano?
magari una manina iniziale visto che ho poca esperienza con il vhdl.
un grazie a tutti e saluti ancora.

[deluca]

cavetto,
per prima cosa, prima di procedere con la descrizione del decodificatore, ti consiglio di progettare il filtro digitale (digital filter) a due canali da inserire subito dopo i segnali provenienti dall' encoder. Con esso è possibile rimuovere il rumore generato dalle vibrazioni meccaniche e non solo.

Di norma un modulo in grado di contare gli impulsi generati da un encoder deve essere realizzato con questi oggetti:

-digital filter (filtro per eliminare il rumore)
-decoder logic (quadrature x4)
-position counter (contatore degli impulsi)
-position data-latch (registro memorizzazione conteggio)
-bus logic (interfaccia I/O)

un cenno su "FPGA quadrature encoder" lo puoi trovare qui
http://www.delucagiovanni.com/files/FPG ... /frame.htm

quali sono i tuoi dubbi? hai già descritto in vhdl qualcosa?
ciao