Discussion :

[thejavator]

Bonjour,

Est-il possible d'implememter des equations differentielles sur un FPGA ? Mom tuteur de stage m'a demamde si je savais faire ca mais je doute que ca soit possible.
Desole pour les accents je suis sur un qwerty.

[titiri]

Bonjour,

Si la question est "en VHDL", je dirais non. Jamais entendu parlé de cela et mes souvenirs (rafraichis par wikipedia) de la résolution de ces équations (ne serait-ce que d'ordre 1) requiert du calcul formel. Hors de question en VHDL.
Par contre, si la question est bien "sur un FPGA", alors là la réponse est clairement oui :

• Sur Altera, utilisez Qsys pour implémenter un Nios (µP softcore et compatible avec toutes les familles Altera, sauf les "trop vieilles"). Après, vous pouvez le programmer en C. Il y a fort à parier que des bibliothèques open-source existent déjà.
• Sur Xilinx, utilisez MicroBlase (grosso-modo philosophie/concept que le Nios, mais beaucoup plus "compliqué" à utiliser )

En conclusion, si le FPGA n'est pas encore choisi, je vous conseille plutôt Altera avec le Nios. Je le répète, le Nios est un vrai µP mais implémenté dans les ressources "classiques" du FPGA (LUT, registres, RAM). Il est même envisageable de n'utiliser que les blocs RAM internes du FPGA pour y stocker le code --> donc aucun composant externe

Cdlt

[thejavator]

merci beaucoup pour votre réponse.
Je pensais que le VHDL était le langage pour le FPGA, faut que je relise mes cours...
J'ai eja utilisé xilinx mais je sais plus si c'était pour du FPGA

[sgievounet]

Salut,

Il faut se rappeler et bien garder à l'esprit que le VHDL est un langage de description. Description de quoi? Description en fait qui te permet de modeliser ce que tu veux ou calcul que tu veux avec de la logique combinatoire, et pouvoir s'aider à mémoriser/temporiser avec RAM (cache). Sur un FPGA il y a même des multiplieurs pour avoir plus de force de calcul de disponible. Après, tout ça est une histoire de compromis entre: vitesse, ressource, latence et précision...

Une equation différentielle, biensur que tu peux l'implémenter. Une boucle d'asservissement implémenté dans un FPGA, du genre une PLL, c'est l'utilisation d'une equation différentielle pour atteindre la stabilité.

En tout cas, si tu as la solution de ton equation, tu peux tenter. Mais, clairement, les formules mathématiques non linéaires (du type racine, exposant, exponentielle ou arctangeante), ça coute très chère niveau occupation de ressources FPGA ou niveau vitesse...

Si je peux me permettre un avis, utiliser un softcore du type (NIOS ou Microblaze) c'est franchement pas l'objectif du FPGA, vaut mieux passer sur un DSP, ou sinon, se pencher à decrire l'equation à implémenter l'equation en VHDL pour monter en débit de calcul. Le softcore c'est plutot de l'appoint...

Tu peux décrire une peu plus le contexte de ce que tu souhaites réaliser, plus en détail?

[thejavator]

je dois realiser un oscillateur chaotique: l'oscillateur de Lorenz. C'est explique dans ce documemt mais je suis completement perdu
http://www.sciencedirect.com/science...07570412005734

[thejavator]

en fait il n y a pas d equations differentielles a implementer, il fallait discretiser les equation par une methodes.
je dois juste implementer 3 equations qui dependent de l'etat precedent, je l ai fait sur matlab voici le code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
function [Vx, Vy, Vz] = lorenz()
Xn = 0;
Yn = 5;
Zn = 25;
a = 10;
b = 8/3;
c = 28;
h = 0.01;
k1x = h*a*(Yn-Xn);
k2x = k1x;
k1y = h*(-Xn*Zn+b*Xn-Yn);
k2y = h*(-Xn*Zn-Xn*h-Zn*h-h*h+b*Xn+b*h-Yn-h);
k1z = h*(Xn*Yn - c*Zn);
k2z = h*(Xn*Yn+Xn*h+Yn*h+h*h-c*Zn-c*h);
X = Xn +0.5*(k1x+k2x);
Y = Yn +0.5*(k1y+k2y);
Z = Zn +0.5*(k1z+k2z);
i = 10000;
Vx=(1:i); 
Vy=(1:i);
Vz=(1:i);
for k=1:1:i 
k1x = h*a*(Y-X);
k2x = k1x;
k1y = h*(-X*Z+b*X-Y);
k2y = h*(-X*Z-X*h-Z*h-h*h+b*X+b*h-Y-h);
k1z = h*(X*Y - c*Z);
k2z = h*(X*Y+X*h+Y*h+h*h-c*Z-c*h);
X = X +0.5*(k1x+k2x);
Y = Y +0.5*(k1y+k2y);
Z = Z +0.5*(k1z+k2z);
Vx(k)= X;
Vy(k)= Y;
Vz(k)= Z;
end
% subplot(3,1,1);
% plot (Vx);
% title('X');
% subplot(3,1,2);
% plot (Vy);
% title('Y');
% subplot(3,1,3);
% plot (Vz);
% title('Z');
end

je n'obtiens pas ce que je veux avec les courbes mais deja faire ca en vhdl serait pas mal, j'ai essayer aussi une application sur matlab qui convertit le langage matlab vers HDL mais je n'y arrive pas.

j'ai tente sur modelsim mais j'ai plein d'erreur...
je vous met le code ci-dessous:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
 
entity lorenz is
    Port ( X : out  real;
           Y : out  real;
           Z : out  real);
end lorenz;
 
architecture Behavioral of lorenz is
 
constant Xn: real := 0.00;
constant Yn: real := 5.00;
constant Zn: real := 25.00;
constant a: real := 10.00;
constant b: real := 2.6666;
constant c: real := 28.00;
constant h: real := 0.01;
 
begin
  process
 
variable k1x: real;
variable k2x: real;
variable k1y: real;
variable k2y: real;
variable k1z: real;
variable k2z: real;
    begin
k1x := h * a * (Yn-Xn);
k2x := k1x;
k1y := h*(-Xn*Zn+b*Xn-Yn);
k2y := h*(-Xn*Zn-Xn*h-Zn*h-h*h+b*Xn+b*h-Yn-h);
k1z := h*(Xn*Yn - c*Zn);
k2z := h*(Xn*Yn+Xn*h+Yn*h+h*h-c*Zn-c*h); 
X <= Xn +0.5*(k1x+k2x);
Y <= Yn +0.5*(k1y+k2y);
Z <= Zn +0.5*(k1z+k2z);
loop1: FOR I IN 1 TO 100 LOOP 
k1x := h* a * (Y-X);
k2x := k1x;
k1y := h*(-X*Z+b*X-Y);
k2y := h*(-X*Z-X*h-Z*h-h*h+b*X+b*h-Y-h);
k1z := h*(X*Y - c*Z);
k2z := h*(X*Y+X*h+Y*h+h*h-c*Z-c*h);
X <= X +0.5*(k1x+k2x);
Y <= Y +0.5*(k1y+k2y);
Z <= Z +0.5*(k1z+k2z);
END LOOP loop1;
end process;
end Behavioral;

voila les erreurs qu'il m'affiche:

** Error: \\pstudfsnb\home8\w13046248\My Documents\Work\lorenz.vhd(42): Cannot read output "y".
** Error: \\pstudfsnb\home8\w13046248\My Documents\Work\lorenz.vhd(42): Cannot read output "x".
** Error: \\pstudfsnb\home8\w13046248\My Documents\Work\lorenz.vhd(42): Cannot read output "x".
** Error: \\pstudfsnb\home8\w13046248\My Documents\Work\lorenz.vhd(42): Cannot read output "z".
** Error: \\pstudfsnb\home8\w13046248\My Documents\Work\lorenz.vhd(43): Cannot read output "x".

J'ai plein d'erreurs comme quoi il n'arrive pas a lire les variables de sorties X,Y et Z.
J'ai declare les variables de sorties en "real" je sais pas si c'est vraiment normal de pouvoir faire ca...

[sgievounet]

N'utilise pas de variable type real, le FPGA ne saura faire.

Etape 1: Modifie ton Matlab pour que tout se fasse sans nombre à virgule... Tu multiplies tes entrées par 2^valeur, valeur etant ce qui te suffira pour pas perdre en precision, idem pour tes constante. Le FPGA, les nombres à virgule, il ne connait pas...

Etape 2:
Ensuite ecris ton code avec plein de variables intermediaires. En gros, par affectation ou par ligne, tu as le droit de faire une operation ( * ou + ou -)
Tu vois ce que je veux dire?

Etape 3: Va falloir casser la boucle FOR

[thejavator]

pourquoi il faut faire qu'une seule opération par affectation ? casser la boucle for c'est à dire ? normalement c'est une boucle infinie que je dois faire mais la c'est un test.

[sgievounet]

Dans le premier lien tu trouveras un bout de code qui implémente un correlateur (je ne l'ai pas testé mais j'imagine qu'il tourne, c'est souvent le cas sur ce blog)

http://vhdlguru.blogspot.fr/2011/06/...ir-filter.html

Globalement ça se compose de deux fichiers:
Le FIR (correlateur) <-> qui pourrait être ta fonction de traitement de Lorentz
Le Testbench, c'est ce qui permet de ecrire et relire depuis le FIR ( ou ce qu'on appelle plus communément Unit Under Test)
Le DFF n'a pas vraaiment lieu d'avoir son entité ou fichier, il aurait pu être mis directement dans le FIR.

Ta boucle FOR, ça pourrait être des données que tu relis depuis un fichier et stimule dans le UUT en VHDL. Je te conseille donc de la sortir de ta fonction matlab et à la limite utiliser du permanent pour les variables globales.

Concernant, les opérations à mettre sur plusieurs affectations, ça vise à éviter l'engorgement en implémentation une fois sur cible, et donc diminution de la fréquence de traitement atteignable. http://zone.ni.com/reference/en-XX/h...pts/registers/

Vaut mieux se focaliser sur les deux fichiers du premier lien, comprendre s'en inspirer.

Fait gaff, le VHDL en autodidact, ca peut très vite devenir prise de tête