Controllore Fuzzy in VHDL

[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

[legacy]

Questo argomento si e' arenato ?

[deluca]

Si è arenato perchè non ci sono stati + replay.

Noi, invece, siamo andati avanti e finalizzato il progetto con risultati + che soddisfacenti.

[legacy]

Mi sarebbe piaciuto leggere la parte delle rules e poi la strategia del defuzzy.

[legacy]

Spegniamo le luci, ci accomodiamo in poltrona, e ci gustiamo La seconda parte ? Giovanni, che ne dici ? Io, se possibile, accenderei richiesta per la parte II di questo interessantissimo argomento con esempio pratico inside!

[deluca]

Mettendo in evidenza quanto già detto qui:
http://www.delucagiovanni.com/Fuzzy%20L ... ontrol.pdf

Il risultato della defuzzificazione è un valore numerico il quale determina il fattore di duty-cycle del segnale PWM usato per pilotare il motore. Esso è ottenuto trovando il punto centroide della funzione che è il risultato della moltiplicazione tra la funzione (membership) di uscita e il vettore d’uscita Y[]. Se vai alla pag.3 di questa presentazione parte I noterai che il valore Defuz ottenuto è -0.375.
Quello sarà il valore che opportunamente moltiplicato per una costante di amplificazione potrà essere usato per variare il duty-cycle
del pwm in uscita dal microcontrollore.
Non possiamo comunque sottovalutare i tempi di esecuzione per la defuzzificazione, per applicare le inferenze e defuzzificare, che se calcolati male, possono provocare oscillazioni inderiderate.
Un aspetto da valutare con attenzione sarà il tempo di campionamento con cui saranno prelevati i valori in ingresso che arrivano dall'encoder.

Ovviamente questo è un semplicissimo esempio a due variabili d'ingresso, ma può essere un buon inizio per realizzare un controllore fuzzy molto + performante.

[legacy]

Ok, chiaro, mi sfugge pero' come siete arrivati alle regole di inferenza per 5 fuzzy sets.
Retaggio d'esperienza ?

[deluca]

L'esperienza è importante, aver valutato a fondo il comportamento dei controlli anche se di natura diversa giova sicuramente quando si ha a che fare con controlli fuzzy.
In questo caso hai necessità di testare e simulare interattivamente le varie configurazioni con un numero di fuzzy-sets sempre crescente a partire da 3.
Una volta fissate le regole di inferenza devi trovare un compromesso tra la configurazione studiata via software sul tuo PC e quella che dovrai andare a implementare via firmware su un microcontrollore tipo 8051/avr/arm o su FPGA.