{"id":2192,"date":"2022-10-18T14:00:53","date_gmt":"2022-10-18T13:00:53","guid":{"rendered":"http:\/\/www.fabienm.eu\/flf\/?p=2192"},"modified":"2022-11-10T15:58:27","modified_gmt":"2022-11-10T14:58:27","slug":"simulons-la-fft-de-xilinx","status":"publish","type":"post","link":"http:\/\/www.fabienm.eu\/flf\/simulons-la-fft-de-xilinx\/","title":{"rendered":"Simulons la FFT de Xilinx"},"content":{"rendered":"\n

Apr\u00e8s avoir simul\u00e9 des FFT avec Python et pylab,<\/a> voyons comment les int\u00e9grer dans un FPGA r\u00e9el de Xilinx.<\/p>\n\n\n\n

Faire une FFT dans un FPGA est quelque chose qui n’est pas trivial. L’avantage, suivant la taille du FPGA, est de pouvoir en faire tourner plusieurs en parall\u00e8le pour acc\u00e9l\u00e9rer le traitement. L\u2019inconv\u00e9nient \u00e9tant le temps de d\u00e9veloppement qui est d\u00e9cupl\u00e9 par rapport \u00e0 une solution embarqu\u00e9e sur les habituels DSP ou microcontr\u00f4leurs.<\/p>\n\n\n\n

Pour acc\u00e9l\u00e9rer le d\u00e9veloppement, l’utilisation de modules fournis par les constructeurs est tr\u00e8s tentante. Bien s\u00fbr, si on utilise la FFT d’un constructeur X, elle ne sera pas utilisable sur le FPGA du constructeur Y… Mais c’est de bonne guerre.<\/p>\n\n\n\n

Plus g\u00eanant est la difficult\u00e9 de simuler le module sur son PC pour valider l’algorithme que l’on souhaite mettre en \u0153uvre.<\/p>\n\n\n\n

C’est pour cela que Xilinx fournit un mod\u00e8le C de sa FFT<\/a>. Mod\u00e8le que l’on peut utiliser gratuitement avec GCC.<\/p>\n\n\n\n

Voyons voir comment mettre tout \u00e7a en \u0153uvre.<\/p>\n\n\n\n

Installation du mod\u00e8le<\/h2>\n\n\n\n

Pour compiler le mod\u00e8le il faut d’abord le g\u00e9n\u00e9rer \u00e0 partir d’un projet Vivado. On cr\u00e9e donc un projet Vivado avec un FPGA cible et on instancie le bloc \u00abFast Fourrier Transform\u00bb dans l’\u00abIP designer\u00bb. Pour pouvoir g\u00e9n\u00e9rer le mod\u00e8le il faut que les entr\u00e9es\/sorties soient connect\u00e9es \u00e0 quelques chose, dans notre cas nous nous contenterons d’exporter les ports.<\/p>\n\n\n\n

\"\"<\/a>
Le bloc FFT de Vivado<\/figcaption><\/figure>\n\n\n\n

L’archive au format zip est g\u00e9n\u00e9r\u00e9e dans le r\u00e9pertoire suivant :<\/p>\n\n\n\n

test_fft\/test_fft.gen\/sources_1\/bd\/fft_test_design\/ip\/fft_test_design_xfft_0_0\/cmodel\/xfft_v9_1_bitacc_cmodel_lin64.zip<\/code><\/pre>\n\n\n\n
Archive que l’on d\u00e9zippera dans le r\u00e9pertoire de son choix :<\/p>\n\n\n\n
$ unzip xfft_v9_1_bitacc_cmodel_lin64.zip\n$ ls -l\ngmp.h\nlibgmp.so.11\nlibIp_xfft_v9_1_bitacc_cmodel.so\nmake_xfft_v9_1_mex.m\nrun_bitacc_cmodel.c\nrun_xfft_v9_1_mex.m\nxfft_v9_1_bitacc_cmodel.h\nxfft_v9_1_bitacc_mex.cpp<\/code><\/pre>\n\n\n\n
et \u00e0 laquelle nous ajouterons un fichier main() et un Makefile. Par contre ne r\u00eavez pas, il n’y a pas les sources du mod\u00e8le \ud83d\ude09 le mod\u00e8le se trouve dans le fichier binaire de librairie   libIp_xfft_v9_1_bitacc_cmodel.so<\/code><\/p>\n\n\n\n
L’explication pour la compilation est donn\u00e9e sur le site officiel<\/a>. Avec g++<\/code> \u00e7a donne :<\/p>\n\n\n\n
$ g++ -std=c++11 -I. -L. -lgmp -Wl,-rpath,. run_bitacc_cmodel.c -o run_fft -lIp_xfft_v9_1_bitacc_cmodel<\/code><\/pre>\n\n\n\n
La compilation g\u00e9n\u00e8re un binaire nomm\u00e9 run_fft qu’il faut lancer en int\u00e9grant les librairies du r\u00e9pertoire courant pour le lien dynamique :<\/p>\n\n\n\n
$  LD_LIBRARY_PATH=$$LD_LIBRARY_PATH:. .\/run_fft\nRunning the C model...\nSimulation completed successfully\nOutputs from simulation are correct\n$ <\/code><\/pre>\n\n\n\n
Le r\u00e9sultat est relativement frustrant: certes il n’y a pas d’erreur, mais enfin bon … on n’est pas super avanc\u00e9. On aimerait bien avoir de belles courbes et pouvoir admirer le r\u00e9sultat spectral de cette FFT !<\/p>\n\n\n\n
Pour cela il va falloir se plonger dans le code \u00abmain()\u00bb et injecter son propre signal.<\/p>\n\n\n\n
Plong\u00e9e dans le code<\/h2>\n\n\n\n
Pour avoir la documentation du mod\u00e8le on pourra bien s\u00fbr se r\u00e9f\u00e9rer \u00e0 la documentation officiel<\/a>, mais on peut \u00e9galement se plonger dans le header xfft_v9_1_bitacc_cmodel.h<\/code>  qui est bien comment\u00e9.<\/p>\n\n\n\n
Le calcul est lanc\u00e9 avec la fonction xilinx_ip_xfft_v9_1_bitacc_simulate d\u00e9clar\u00e9e ainsi :<\/p>\n\n\n\n
\n\/**\n * Simulate this bit-accurate C-Model.\n *\n * @param     state      Internal state of this C-Model. State\n *                       may span multiple simulations.\n * @param     inputs     Inputs to this C-Model.\n * @param     outputs    Outputs from this C-Model.\n *\n * @returns   Exit code   Zero for SUCCESS, Non-zero otherwise.\n *\/\nIp_xilinx_ip_xfft_v9_1_DLL\nint xilinx_ip_xfft_v9_1_bitacc_simulate\n(\n struct xilinx_ip_xfft_v9_1_state*   state,\n struct xilinx_ip_xfft_v9_1_inputs   inputs,\n struct xilinx_ip_xfft_v9_1_outputs* outputs\n );<\/code><\/pre>\n\n\n\n
L’\u00e9tat est cr\u00e9\u00e9 avec la fonction xilinx_ip_xfft_v9_1_create_state()<\/code> et la structure d’entr\u00e9e (inputs) poss\u00e8de un tableau de double pour la partie imaginaire et un tableau de double pour la partie r\u00e9elle. La taille de la FFT \u00e9tant donn\u00e9e en 2^n par l’attribut nfft<\/code>.<\/p>\n\n\n\n
struct xilinx_ip_xfft_v9_1_inputs\n{\n  int      nfft;              \/\/@- log2(point size)\n\n  double*  xn_re;             \/\/@- Input data (real)\n  int      xn_re_size;\n\n  double*  xn_im;             \/\/@- Input data (imaginary)\n  int      xn_im_size;\n\n  int*     scaling_sch;       \/\/@- Scaling schedule\n  int      scaling_sch_size;\n\n  int      direction;         \/\/@- Transform direction\n}; \/\/ end xilinx_ip_xfft_v9_1_inputs<\/code><\/pre>\n\n\n\n
La structure de sortie est encore plus simple :<\/p>\n\n\n\n
struct xilinx_ip_xfft_v9_1_outputs\n{\n  double*  xk_re;          \/\/@- Output data (real)\n  int      xk_re_size;\n\n  double*  xk_im;          \/\/@- Output data (imaginary)\n  int      xk_im_size;\n\n  int      blk_exp;        \/\/@- Block exponent\n\n  int      overflow;       \/\/@- Overflow occurred\n}; \/\/ xilinx_ip_xfft_v9_1_outputs<\/code><\/pre>\n\n\n\n
Dans l’exemple donn\u00e9e, la partie imaginaire est fix\u00e9e \u00e0 0 sur les 1024 \u00e9chantillons et la partie r\u00e9el \u00e0 0.5.<\/p>\n\n\n\n
    \/\/ Create input data frame: constant data\n    double constant_input = 0.5;\n    int i;\n    for (i=0; i<samples; i++) {\n      xn_re[i] = constant_input;\n      xn_im[i] = 0.0;\n    }<\/code><\/pre>\n\n\n\n
Si le signal est constant, en toute logique seule la fr\u00e9quence continue (0Hz) doit \u00eatre diff\u00e9rente de 0. C’est ce qui est v\u00e9rifi\u00e9 apr\u00e8s avoir effectu\u00e9 le calcul :<\/p>\n\n\n\n
    \/\/ Check xk_re data: only xk_re[0] should be non-zero\n    double expected_xk_re_0;\n    if (C_HAS_SCALING == 0) {\n      expected_xk_re_0 = constant_input * (1 << C_NFFT_MAX);\n    } else {\n      expected_xk_re_0 = constant_input;\n    }\n    if (xk_re[0] != expected_xk_re_0) {\n      cerr << \"ERROR:\" << channel_text << \" xk_re[0] is incorrect: expected \" << expected_xk_re_0 << \", actual \" << xk_re[0] << endl;\n      ok = false;\n    }\n    for (i=1; i<samples; i++) {\n      if (xk_re[i] != 0.0) {\n        cerr << \"ERROR:\" << channel_text << \" xk_re[\" << i << \"] is incorrect: expected \" << 0.0 << \", actual \" << xk_re[i] << endl;\n        ok = false;\n      }\n    }\n\n    \/\/ Check xk_im data: all values should be zero\n    for (i=1; i<samples; i++) {\n      if (xk_im[i] != 0.0) {\n        cerr << \"ERROR:\" << channel_text << \" xk_im[\" << i << \"] is incorrect: expected \" << 0.0 << \", actual \" << xk_im[i] << endl;\n        ok = false;\n      }\n    }<\/code><\/pre>\n\n\n\n
Transform\u00e9e de wavelet<\/h2>\n\n\n\n
Tout ceci n’est pas tr\u00e8s parlant pour le moment, testons maintenant le mod\u00e8le sur la \u00abwavelet\u00bb g\u00e9n\u00e9r\u00e9e \u00e0 partir d’un script python. Le script permettant de g\u00e9n\u00e9rer le signal <\/a>et de l’\u00e9crire dans un fichier *.txt se trouve dans le r\u00e9pertoire cmodel<\/a> du d\u00e9pot github.<\/p>\n\n\n\n
\"\"<\/a>
Le signal que l’on va injecter dans le mod\u00e8le FFT de xilinx<\/figcaption><\/figure>\n\n\n\n
Le script g\u00e9n\u00e8re un fichier ysig.txt avec toutes les valeurs flottantes \u00e9crites en ASCII. On va ensuite relire le fichier avec le programme C++<\/a> :<\/p>\n\n\n\n
    \/\/ Read input data from file ysig.txt\n    std::ifstream yfile; yfile.open(\"ysig.txt\");\n    if(!yfile.is_open()){\n        perror(\"Open error\");\n        exit(EXIT_FAILURE);\n    }\n    string line;\n    int i=0; \n    while(getline(yfile, line)){\n        xn_re[i] = stof(line);\n        cout << stof(line) << endl;\n        xn_im[i] = 0.0;\n        i++; \n    }<\/code><\/pre>\n\n\n\n
Le programme \u00e9crira le r\u00e9sultat sous dans le fichier xfft_out.txt une fois le r\u00e9sultat calcul\u00e9:<\/p>\n\n\n\n
\n    \/\/ save outputs in xfft_out.txt\n    std::ofstream outfile; outfile.open(\"xfft_out.txt\");\n    if(outputs.xk_re_size != outputs.xk_im_size){\n        printf(\"Error imaginary part size is not equal to real part\");\n    }\n    for(int i=0; i < outputs.xk_re_size; i++){\n        outfile << outputs.xk_re[i] << \", \" << outputs.xk_im[i] << endl;\n    }\n    <\/code><\/pre>\n\n\n\n
Fichier que l’on relira pour l’afficher au moyen du script python plot_fft.py<\/a><\/p>\n\n\n\n
\"\"<\/a>
R\u00e9sultat plut\u00f4t concluant puisque identique au calcul de la fonction magnitude_spectrum de pylab.<\/figcaption><\/figure>\n\n\n\n
Et nous avons la bonne surprise d’obtenir le m\u00eame spectre du module qu’avec la fonction de pylab.<\/p>\n\n\n\n
On peut maintenant jouer avec les param\u00e8tres du module Xilinx et affiner notre mod\u00e8le de simulation avant de le synth\u00e9tiser dans un FPGA (de chez Xilinx \u00e9videment \ud83d\ude09<\/p>\n","protected":false},"excerpt":{"rendered":"
Apr\u00e8s avoir simul\u00e9 des FFT avec Python et pylab, voyons comment les int\u00e9grer dans un FPGA r\u00e9el de Xilinx. Faire une FFT dans un FPGA est quelque chose qui n’est pas trivial. L’avantage, suivant la taille du FPGA, est de pouvoir en faire tourner plusieurs en parall\u00e8le pour acc\u00e9l\u00e9rer le traitement. L\u2019inconv\u00e9nient \u00e9tant le temps de … Continuer la lecture de Simulons la FFT de Xilinx<\/span> →<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_uag_custom_page_level_css":"","footnotes":""},"categories":[1],"tags":[228,13,225,226,56,227,17],"class_list":["post-2192","post","type-post","status-publish","format-standard","hentry","category-non-classe","tag-c","tag-compilation","tag-dsp","tag-fft","tag-python","tag-signal","tag-xilinx"],"uagb_featured_image_src":{"full":false,"thumbnail":false,"medium":false,"medium_large":false,"large":false,"1536x1536":false,"2048x2048":false,"post-thumbnail":false},"uagb_author_info":{"display_name":"Fabien Marteau","author_link":"http:\/\/www.fabienm.eu\/flf\/author\/admin\/"},"uagb_comment_info":0,"uagb_excerpt":"Apr\u00e8s avoir simul\u00e9 des FFT avec Python et pylab, voyons comment les int\u00e9grer dans un FPGA r\u00e9el de Xilinx. Faire une FFT dans un FPGA est quelque chose qui n’est pas trivial. L’avantage, suivant la taille du FPGA, est de pouvoir en faire tourner plusieurs en parall\u00e8le pour acc\u00e9l\u00e9rer le traitement. L\u2019inconv\u00e9nient \u00e9tant le temps de\u2026","_links":{"self":[{"href":"http:\/\/www.fabienm.eu\/flf\/wp-json\/wp\/v2\/posts\/2192","targetHints":{"allow":["GET"]}}],"collection":[{"href":"http:\/\/www.fabienm.eu\/flf\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"http:\/\/www.fabienm.eu\/flf\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"http:\/\/www.fabienm.eu\/flf\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"http:\/\/www.fabienm.eu\/flf\/wp-json\/wp\/v2\/comments?post=2192"}],"version-history":[{"count":23,"href":"http:\/\/www.fabienm.eu\/flf\/wp-json\/wp\/v2\/posts\/2192\/revisions"}],"predecessor-version":[{"id":2248,"href":"http:\/\/www.fabienm.eu\/flf\/wp-json\/wp\/v2\/posts\/2192\/revisions\/2248"}],"wp:attachment":[{"href":"http:\/\/www.fabienm.eu\/flf\/wp-json\/wp\/v2\/media?parent=2192"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"http:\/\/www.fabienm.eu\/flf\/wp-json\/wp\/v2\/categories?post=2192"},{"taxonomy":"post_tag","embeddable":true,"href":"http:\/\/www.fabienm.eu\/flf\/wp-json\/wp\/v2\/tags?post=2192"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}