{"id":2060,"date":"2022-08-23T21:00:22","date_gmt":"2022-08-23T20:00:22","guid":{"rendered":"http:\/\/www.fabienm.eu\/flf\/?p=2060"},"modified":"2023-02-02T14:38:38","modified_gmt":"2023-02-02T13:38:38","slug":"traitement-numerique-du-signal-prise-de-notes","status":"publish","type":"post","link":"http:\/\/www.fabienm.eu\/flf\/traitement-numerique-du-signal-prise-de-notes\/","title":{"rendered":"Traitement num\u00e9rique du signal, prise de notes"},"content":{"rendered":"\n

On dit souvent que pour bien apprendre un sujet en informatique il faut \u00e9crire une doc. Pour des besoins pro j’ai du me re-mettre au traitement num\u00e9rique du signal. Je commence en g\u00e9n\u00e9ral par un bouquin et un projet. Pour le projet comme c’est du pro je c’est \u00e0 ma discr\u00e9tion, par contre pour le bouquin je me suis plong\u00e9 dans le livre de Richard G.Lyons <\/strong>\u00abUnderstanding digital signal processing<\/a><\/em>\u00bb qui a le m\u00e9rite d’\u00eatre richement illustr\u00e9 de graphes et d’\u00e9quations avec beaucoup d’explications visuelles et \u00abavec les mains\u00bb.<\/p>\n\n\n\n

\"\"<\/a>
Du bon soleil pour apprendre<\/figcaption><\/figure>\n\n\n\n

L’id\u00e9e de cette note est donc de faire des exercices en rapport avec ce qui est dans ce livre mais pas que, le tout de mani\u00e8re pratique en python et de voir les implications que \u00e7a peut avoir avec les FPGA.<\/p>\n\n\n\n

Un signal discret<\/h2>\n\n\n\n

Dans un premier temps nous aurons besoin de numpy<\/strong> et pylab<\/strong> en python3 <\/p>\n\n\n\n

import numpy as np\nimport pylab as plt<\/code><\/pre>\n\n\n\n
Le signal de base est une sinuso\u00efde. Pour repr\u00e9senter un signal de 1 Hertz en python on va d’abord cr\u00e9er un tableau d’un certain nombre de valeur de 0 \u00e0 1 secondes :<\/p>\n\n\n\n
# Freq\nf0 = 1\n# 40 points de 0 \u00e0 39\nt = np.linspace(0, 1, 40)<\/code><\/pre>\n\n\n\n
Puis calculer le sinus <\/p>\n\n\n\n
y = np.sin(2*math.pi*f0*t)<\/code><\/pre>\n\n\n\n
Signal qu’il est facile de \u00abplotter\u00bb ensuite :<\/p>\n\n\n\n
plt.plot(t, y)\nplt.show()<\/code><\/pre>\n\n\n\n
Ce qui nous donne cette belle courbe de sinus :<\/p>\n\n\n\n
\"\"<\/a>
D’apr\u00e8s Richard il ne faut pas relier les points<\/figcaption><\/figure>\n\n\n\n
Mais pour bien se repr\u00e9senter un signal num\u00e9rique<\/strong> il ne faut pas relier les points. Il vaut mieux mettre des points avec des lignes verticales comme ceci :<\/p>\n\n\n\n
fix, ax = plt.subplots()\nax.stem(t, y, 'b', markerfmt=\"b.\")\nplt.show()<\/code><\/pre>\n\n\n\n
Ce qui nous donne la figure suivante :<\/p>\n\n\n\n
\"\"<\/a>
Les points non reli\u00e9s entre eux donnent une meilleur vision d’un signal num\u00e9rique (discret)<\/figcaption><\/figure>\n\n\n\n
Cette derni\u00e8re figure illustre bien la notion d’\u00e9chantillonnage avec une fr\u00e9quence d\u2019\u00e9chantillonnage fs de 40Hertz (temps en secondes et 40 points) soit :<\/p>\n\n\n\n
# Freq\nf0 = 1\n# Temps total\nT = 1\n# Nombre de points:\nN = 40\n# Fr\u00e9quence d\u2019\u00e9chantillonnage :\nprint(f\"fs = {N\/T} Hertz\")\n# fs = 40.0 Hertz<\/code><\/pre>\n\n\n\n
Ici, la fr\u00e9quence d’\u00e9chantillonnage (40Hertz) est largement sup\u00e9rieur \u00e0 la fr\u00e9quence du signal enregistr\u00e9 (1 Hertz). On peut s’amuser maintenant \u00e0 monter la fr\u00e9quence du signal \u00e0 la fr\u00e9quence de Nyquist :<\/p>\n\n\n\n
\"\"<\/a>
f0 = 5<\/figcaption><\/figure>\n\n\n\n
\"\"<\/a>
f0 = 10<\/figcaption><\/figure>\n\n\n\n
\"\"<\/a>
f0 = 20<\/figcaption><\/figure>\n\n\n\n
Ce que nous dit Nyquist, c’est qu’avec tous les signaux ci-dessus, il est possible de retrouver la sinuso\u00efde du d\u00e9but. Mais si on augmente encore la fr\u00e9quence on obtient un repliement<\/strong> du spectre.<\/p>\n\n\n\n
\"\"<\/a>
f0  = 30<\/figcaption><\/figure>\n\n\n\n
\"\"<\/a>
f0 = 40<\/figcaption><\/figure>\n\n\n\n
On peut ajouter le l’analyse de spectre en augmentant \u00e9galement le nombre de points mesur\u00e9 :<\/p>\n\n\n\n
# Freq\nf0 = 1\n# Temps total\nT = 1\n# Nombre de points:\nN = 100\n# 100 points de 0 \u00e0 99\nt = np.linspace(0, T, N)\ny = np.sin(2*np.pi*f0*t)\nfix, ax = plt.subplots(1,2)\nax[0].stem(t, y, 'b', markerfmt=\"b.\")\nax[1].magnitude_spectrum(y, Fs=N\/T, ds=\"steps-mid\")\nplt.show()<\/code><\/pre>\n\n\n\n
\"\"<\/a>
(f0=1) \u00c0 gauche le signal sur 100 points, \u00e0 droite l’analyse des fr\u00e9quences <\/figcaption><\/figure>\n\n\n\n
Ondelettes<\/h2>\n\n\n\n
Pour faire une ondelette (wavelet) on multiplie un cosinus (p\u00e9riodique) avec une gaussienne (exp(-t\u00b2\/2)) :<\/p>\n\n\n\n
# D\u00e9calage en seconde:\nretard = 5\ny = np.cos(2*np.pi*f0*t)*np.exp(-np.power(t-retard,2)\/2)<\/code><\/pre>\n\n\n\n
\"\"<\/a>
La fr\u00e9quence du signal est toujours de 1Hz mais le signal n’est plus p\u00e9riodique \u00e0 l’infini<\/figcaption><\/figure>\n\n\n\n
La vid\u00e9o suivante<\/a> explique tout ce que vous avez toujours voulu savoir sur les ondelettes.<\/p>\n\n\n\n
Si on change la fr\u00e9quence du signal, en passant \u00e0 2Hz par exemple. On se rend compte que l’\u00e9chantillonnage tronque les maximum locaux :<\/p>\n\n\n\n
\"\"<\/a>
La courbe n’est plus sym\u00e9trique<\/figcaption><\/figure>\n\n\n\n
Ce qui casse la sym\u00e9trie de la courbe.<\/p>\n\n\n\n
Hilbert avec scipy<\/h2>\n\n\n\n
La transform\u00e9e de hilbert <\/a>permet de calculer la partie imaginaire du signal r\u00e9el. Le package python nomm\u00e9 scipy<\/a> inclue la fonction qui la calcule.<\/p>\n\n\n\n
[...]\nfrom scipy import signal\n[...]\n# morlet wavelet\ny = np.cos(2*np.pi*f0*t)*np.exp(-np.power(t-retard,2)\/2)\n\nhimg = signal.hilbert(y).imag\nhreal = signal.hilbert(y).real\n[...]<\/code><\/pre>\n\n\n\n
\"\"<\/a>
On distingue bien la partie r\u00e9el (le signal d’origine) et la partie imaginaire en orange<\/figcaption><\/figure>\n\n\n\n
Comme nous avons la partie r\u00e9elle et la partie imaginaire de notre signal, il est possible d\u00e9sormais de calculer son module pour en tirer l’enveloppe:<\/p>\n\n\n\n
# morlet wavelet\ny = np.cos(2*np.pi*f0*t)*np.exp(-np.power(t-retard,2)\/2)\n\nhimg = signal.hilbert(y).imag\nhreal = signal.hilbert(y).real\n\nhabs = np.sqrt(np.power(himg, 2) + np.power(hreal, 2))<\/code><\/pre>\n\n\n\n
\"\"<\/a>
L’enveloppe du signal en vert (habs)<\/figcaption><\/figure>\n\n\n\n
Si l’on diminue la fr\u00e9quence d\u2019\u00e9chantillonnage (division par 10) on remarque que l’enveloppe ne passe plus par les maximums. La transform\u00e9e de Hilbert semble les avoirs tout de m\u00eame d\u00e9duit :<\/p>\n\n\n\n
\"\"<\/a>
Avec une fr\u00e9quence de pulsation de 2 Hertz et une division de la fr\u00e9quence \u00e9chantillonnage par 10 on constate que l’enveloppe demeure alors que les maximums r\u00e9el et imaginaire sont tronqu\u00e9s. <\/figcaption><\/figure>\n\n\n\n
Peut-on calculer l’enveloppe sans racine carr\u00e9 et carr\u00e9 ?<\/p>\n\n\n\n
habs = np.abs(himg) + np.abs(hreal)<\/code><\/pre>\n\n\n\n
\"\"<\/a>
Hmmm \u00e7a marche moins bien sans carr\u00e9 (courbe rouge)<\/figcaption><\/figure>\n\n\n\n
Et juste avec des carr\u00e9s ?<\/p>\n\n\n\n
hsquare= np.power(himg, 2) + np.power(hreal, 2)<\/code><\/pre>\n\n\n\n
\"\"<\/a>
Hmm c’est pas magique non plus<\/figcaption><\/figure>\n\n\n\n
Transform\u00e9e de Fourrier<\/h2>\n\n\n\n
Mais que faites vous encore sur ce blog ! Vite allez visionner l’excellente vid\u00e9o<\/a> de 3Blue1Brown<\/a> qui parle de la transform\u00e9e de Fourrier avec force de graphes et de dessins. Vous ne verrez plus la transform\u00e9e de fourrier comme avant \ud83d\ude09<\/p>\n\n\n\n
Sinon y a aussi cette formule trouv\u00e9e sur twitter<\/a> qui est vraiment tr\u00e8s parlante :<\/p>\n\n\n\n
\"\"<\/a>
Trouv\u00e9e sur twitter<\/a><\/figcaption><\/figure>\n\n\n\n
Jusqu’\u00e0 pr\u00e9sent, pour calculer et afficher la transform\u00e9e de fourrier de notre signal, nous nous sommes servi exclusivement de la fonction magnitude_spectrum()<\/code> inclue dans pylab<\/code>. C’est int\u00e9ressant pour avoir un aper\u00e7u du spectre, mais \u00e7a ne permet pas de dire que l’on ma\u00eetrise \u00e7a.<\/p>\n\n\n\n
\n
Nombre complexes en python<\/h3>\n\n\n\n
Python permet visiblement d’utiliser nativement des nombres complexes avec ‘j’ \u00e0 condition d’y mettre un nombre devant :<\/p>\n\n\n\n
In [2]: j                                                                                                                                                                                                          \n---------------------------------------------------------------------------\nNameError                                 Traceback (most recent call last)\n<ipython-input-2-3eedd8854d1e> in <module>\n----> 1 j\n\nNameError: name 'j' is not defined\n\nIn [3]: 1j                                                                                                                                                                                                         \nOut[3]: 1j\n\nIn [4]: 0.02j                                                                                                                                                                                                      \nOut[4]: 0.02j\n\nIn [5]: -3j                                                                                                                                                                                                        \nOut[5]: (-0-3j)\n\nIn [7]: np.exp(1j)                                                                                                                                                                                                 \nOut[7]: (0.5403023058681398+0.8414709848078965j)\n<\/code><\/pre>\n<\/div><\/div>\n\n\n\n
Tentons donc de calculer la transform\u00e9e de fourrier en mode \u00abbrute de force\u00bb pour voir:<\/p>\n\n\n\n
\n#temps: 0 points de 0 \u00e0 N-1\nt = np.linspace(0, T, N)\n# morlet wavelet\ny = np.cos(2*np.pi*f0*t)*np.exp(-np.power(t-retard,2)\/2)\n\n# transform\u00e9e de fourrier\nfreqs = np.array([])\nfor k in range(N):\n    listexp = [y[n]*np.exp(1j*2*np.pi*k*n\/N) for n in range(N)]\n    xk = (1\/N)*np.array(listexp).sum()\n    freqs = np.append(freqs, xk)\n\n#fr\u00e9quence: 0 points de 0 \u00e0 N-1\nk = np.linspace(0, T, N)<\/code><\/pre>\n\n\n\n
\"\"<\/a>
Visiblement nous avons un probl\u00e8me \u00abcomplexe\u00bb<\/figcaption><\/figure>\n\n\n\n
L\u00e0 ce que nous venons de calculer est la version complexe de la transform\u00e9e de fourrier dont pylab nous \u00abplot\u00bb la partie r\u00e9elle. Voyons voir le module :<\/p>\n\n\n\n
fourrier_module = np.sqrt(np.power(freqs.imag, 2) + np.power(freqs.real, 2))<\/code><\/pre>\n\n\n\n
\"\"<\/a>
Mais pourquoi ce deuxi\u00e8me pic ?<\/figcaption><\/figure>\n\n\n\n
Nous avons donc toujours deux pics, sachant que le second pic est au del\u00e0 de la fr\u00e9quence de Nyquist (Fs=10Hz) et semble \u00abnormal\u00bb. <\/p>\n\n\n\n
Par contre nous avons un facteur 2 entre le calcul de magnitude de python et celui que l’on vient de calculer.<\/p>\n\n\n\n
Peut-\u00eatre parce que la formule de l’image est celle de la transform\u00e9e inverse ? La transform\u00e9e discr\u00e8te donn\u00e9e dans le livre est plut\u00f4t celle l\u00e0 :<\/p>\n\n\n\n
\"\"<\/a>
Page 60: On retrouve encore moins le facteur 2 sur cette formule.<\/figcaption><\/figure>\n\n\n\n
Voyons voir avec cette nouvelle formule :<\/p>\n\n\n\n
# transform\u00e9e de fourrier\nfreqs = np.array([])\nfor k in range(N):\n    listexp = [y[n]*np.exp(-1j*2*np.pi*k*n\/N) for n in range(N)]\n    xk = np.array(listexp).sum()\n    freqs = np.append(freqs, xk)\n\nfourrier_module = np.sqrt(np.power(freqs.imag, 2) + np.power(freqs.real, 2))<\/code><\/pre>\n\n\n\n
\"\"<\/a>
Bon c’est pas un facteur 2 cette fois!<\/figcaption><\/figure>\n\n\n\n
Si on veut \u00abmatcher\u00bb la courbe de magnitude il faut ajouter un facteur 2\/N au calcul du module :<\/p>\n\n\n\n
fourrier_module = (2\/N)*np.sqrt(np.power(freqs.imag, 2) + np.power(freqs.real, 2))<\/code><\/pre>\n\n\n\n
\"\"<\/a>
Avec le facteur (2\/N) on obtient une superposition des courbes.<\/figcaption><\/figure>\n\n\n\n
cos – sin<\/h2>\n\n\n\n
Pour faire entrer le calcul de la transform\u00e9e dans un FPGA, l’exponentielle d’un complexe n’est pas super pratique. D\u00e9composons donc en diff\u00e9rence cos-sin avec la formule d’Euler<\/a>, on devrait obtenir le m\u00eame r\u00e9sultat:<\/p>\n\n\n\n
# transform\u00e9e de fourrier\nfreqs = np.array([])\nfor k in range(N):\n    listexp = []\n    for n in range(N):\n        angle = 2*np.pi*k*n\/N\n        listexp.append(y[n]*(np.cos(angle) - 1j*np.sin(angle)))\n    xk = np.array(listexp).sum()\n    freqs = np.append(freqs, xk)<\/code><\/pre>\n\n\n\n
Et nous obtenons exactement le m\u00eame graphe qu’avant.<\/p>\n\n\n\n
C’est sans surprise qu’on obtient  la m\u00eame chose en sommant ind\u00e9pendamment partie r\u00e9elle et partie imaginaire :<\/p>\n\n\n\n
# transform\u00e9e de fourrier\nfreqs_real = np.array([])\nfreqs_img = np.array([])\nfor k in range(N):\n    listreal = []\n    listimg = []\n    for n in range(N):\n        angle = 2*np.pi*k*n\/N\n        listreal.append(y[n]*(np.cos(angle)))\n        listimg.append(y[n]*(-np.sin(angle)))\n    xkreal = np.array(listreal).sum()\n    xkimg = np.array(listimg).sum()\n    freqs_real = np.append(freqs_real, xkreal)\n    freqs_img = np.append(freqs_img, xkimg)\n\nfourrier_module = (2\/N)*np.sqrt(np.power(freqs_img, 2) + np.power(freqs_real, 2))<\/code><\/pre>\n\n\n\n
Nous permettant au passage de d\u00e9gager le ‘j’ des nombres complexes qui ne passe pas tr\u00e8s bien dans un FPGA.<\/p>\n\n\n\n
Des entiers ou des virgules fixes<\/h2>\n\n\n\n
Pour le moment c’\u00e9tait facile: on avait les flottant de python. Seulement voil\u00e0, dans un FPGA, les flottants ne sont pas simple.  Nous avons besoin de fixer la taille (en bits) des variables\/registres utilis\u00e9s. Il faut \u00e9galement fixer la position de la virgule si l’on souhaite simplifier le calcul.<\/p>\n\n\n\n
Le second probl\u00e8me nous vient des fonctions sin() et cos() qui ne sont pas calculables simplement. L’astuce consiste \u00e0 pr\u00e9-calculer les valeurs et les stocker dans une table qui ira remplir une ROM du FPGA. <\/p>\n\n\n\n
Pour g\u00e9rer des entiers en virgule fixe et de taille h\u00e9t\u00e9rog\u00e8ne on installera le module fxpmath<\/a> :<\/p>\n\n\n\n
$ git clone https:\/\/github.com\/francof2a\/fxpmath.git\n$ cd fxpmath\/\n$ python -m pip install -e .<\/code><\/pre>\n\n\n\n
Pour commencer on va passer le signal ‘y’ en entier sign\u00e9 sur 16bits avec <\/p>\n\n\n\n
# morlet wavelet\ny = np.cos(2*np.pi*f0*t)*np.exp(-np.power(t-retard,2)\/2)\n\nYTYPE=\"S1.15\"\nysint = Fxp(y, dtype=YTYPE)<\/code><\/pre>\n\n\n\n
Le signal se trouvant entre -1 et 1 nous choisirons un format sign\u00e9 sur 16 bits avec tous les chiffres derri\u00e8re la virgule ‘S1.15’.<\/p>\n\n\n\n
Pour les calculs interm\u00e9diaires on va rester sur du sign\u00e9 16 bits mais avec la virgule au milieu cette fois, soit ‘S8.8’:<\/p>\n\n\n\n
# transform\u00e9e de fourrier\nfreqs_real = np.array([])\nfreqs_img = np.array([])\nfor k in range(N):\n    listreal = []\n    listimg = []\n    for n in range(N):\n        angle = Fxp(2*fixpi*Fxp(k, dtype=DTYPE)*Fxp(n, dtype=DTYPE)\/N,\n                dtype=DTYPE)\n        listreal.append(Fxp(y[n]*( np.cos(angle)), dtype=DTYPE))\n        listimg.append (Fxp(y[n]*(-np.sin(angle)), dtype=DTYPE))\n    xkreal = Fxp(np.array(listreal).sum(), dtype=DTYPE)\n    xkimg  = Fxp(np.array(listimg ).sum(), dtype=DTYPE)\n    print(f\"Freq {k} -> {xkreal}({xkreal.dtype}) + {xkimg}j ({xkimg.dtype})\")\n    freqs_real = np.append(freqs_real, xkreal)\n    freqs_img = np.append(freqs_img, xkimg)\n\n#fourrier_module = (2\/N)*np.sqrt(np.power(freqs_img, 2) + np.power(freqs_real, 2))\nfourrier_power = Fxp(Fxp(freqs_img*freqs_img, dtype=DTYPE) + Fxp(freqs_real*freqs_real, dtype=DTYPE), dtype=DTYPE)\nfourrier_module = Fxp((2\/N)*Fxp(np.sqrt(fourrier_power), dtype=DTYPE), dtype=DTYPE)<\/code><\/pre>\n\n\n\n
La premi\u00e8re surprise de cette m\u00e9thode est le temps de calcul: on passe d’un calcul de la transform\u00e9e quasi instantan\u00e9e \u00e0 un calcul qui prend presque une minute.<\/p>\n\n\n\n
La seconde surprise vient avec le \u00abbruit haute fr\u00e9quence\u00bb qui appara\u00eet dans le r\u00e9sultat et le second pic qui dispara\u00eet.<\/p>\n\n\n\n
\"\"<\/a>
Avec les calculs interm\u00e9diaire en S8.8 on parvient \u00e0 la m\u00eame courbe, modulo le bruit en haute fr\u00e9quences.<\/figcaption><\/figure>\n\n\n\n
Le probl\u00e8me de ce bruit vient de l’arrondi calcul\u00e9 sur Pi, si on ajuste la virgule de Pi comme ceci :<\/p>\n\n\n\n
# Frequence du signal\nSf0 = 2\n\nf0 = (Sf0 * Fs)\/T\n\n# D\u00e9calage en seconde:\nretard = 5\n\n#temps: 0 points de 0 \u00e0 N-1\nt = np.linspace(0, T, N)\n# morlet wavelet\ny = np.cos(2*np.pi*f0*t)*np.exp(-np.power(t-retard,2)\/2)\n\nYTYPE=\"S1.15\"\nysint = Fxp(y, dtype=YTYPE)\n\nDTYPE=\"S8.8\"\nD2TYPE=\"S16.16\"\n\nfixpi = Fxp(np.pi, dtype=\"U3.13\")\n\n# transform\u00e9e de fourrier\nfreqs_real = np.array([])\nfreqs_img = np.array([])\nfor k in range(N):\n    listreal = []\n    listimg = []\n    for n in range(N):\n        angle = Fxp(2*fixpi*Fxp(k*n, dtype=\"U16.0\")\/N, dtype=D2TYPE)\n        listreal.append(Fxp(y[n], dtype=YTYPE)*Fxp( np.cos(angle), dtype=YTYPE))\n        listimg.append (Fxp(y[n], dtype=YTYPE)*Fxp(-np.sin(angle), dtype=YTYPE))\n    xkreal = Fxp(np.array(listreal).sum(), dtype=DTYPE)\n    xkimg  = Fxp(np.array(listimg ).sum(), dtype=DTYPE)\n    print(f\"Freq {k}\/{Fs} ({k*T\/N}) -> {np.sqrt(xkreal*xkreal + xkimg*xkimg)})\")\n    freqs_real = np.append(freqs_real, xkreal)\n    freqs_img = np.append(freqs_img, xkimg)\n\nfourrier_power = Fxp(Fxp(freqs_img*freqs_img, dtype=DTYPE) + Fxp(freqs_real*freqs_real, dtype=DTYPE), dtype=DTYPE)\nfourrier_module = Fxp((2\/N)*Fxp(np.sqrt(fourrier_power), dtype=DTYPE), dtype=DTYPE)\n\n<\/code><\/pre>\n\n\n\n
\"\"<\/a>
Avec 128 \u00e9chantillons (2^7)<\/figcaption><\/figure>\n\n\n\n
Par contre on a un d\u00e9calage de fr\u00e9quence avec la fonction magnitude_spectrum() de pylab :<\/p>\n\n\n\n
\"\"<\/a>
Mais d’o\u00f9 vient ce d\u00e9calage ?<\/figcaption><\/figure>\n\n\n\n
Ce d\u00e9calage provient de l’axe des x qui n’est pas le m\u00eame pour le calcul de python et le calcul maison. En effet, notre calcul \u00ab\u00e0 la main\u00bb s’\u00e9tend sur tout l’espace \u00abde nyquist\u00bb (0 \u00e0 N-1) alors que la fonction magnitude_spectrum() n’affiche le spectre que sur la moit\u00e9e.<\/p>\n\n\n\n
Pour recentrer tout \u00e7a on peut simplement r\u00e9cup\u00e9rer la table des fr\u00e9quences fournie par magnitude_spectrum() et l’utiliser comme axe des x dans l’affichage de notre spectre :<\/p>\n\n\n\n
#...\nmagnitude, freqs, _ = ax[1].magnitude_spectrum(y, Fs=N\/T, ds=\"steps-mid\", label=f\"fft (Fs={Fs} Hz)\")\n#...\nax[1].plot(freqs, fourrier_module[:len(freqs)], label = \"freqs (calcul\u00e9e)\")<\/code><\/pre>\n\n\n\n
\"\"<\/a>
La fr\u00e9quence est maintenant correcte, reste un probl\u00e8me de magnitude. Probl\u00e8me d’arrondi ?<\/figcaption><\/figure>\n\n\n\n
Et nous obtenons la bonne fr\u00e9quence pour les deux modes de calculs. Reste maintenant un probl\u00e8me de magnitude maximum, est-ce un probl\u00e8me d’arrondi de la virgule fixe ? Possible.<\/p>\n\n\n\n
Ressources<\/h2>\n\n\n\n
Le code de cet article se trouve sur le d\u00e9p\u00f4t github suivant<\/a>.<\/p>\n","protected":false},"excerpt":{"rendered":"
On dit souvent que pour bien apprendre un sujet en informatique il faut \u00e9crire une doc. Pour des besoins pro j’ai du me re-mettre au traitement num\u00e9rique du signal. Je commence en g\u00e9n\u00e9ral par un bouquin et un projet. Pour le projet comme c’est du pro je c’est \u00e0 ma discr\u00e9tion, par contre pour le … Continuer la lecture de Traitement num\u00e9rique du signal, prise de notes<\/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":[22,1],"tags":[220,56,221],"class_list":["post-2060","post","type-post","status-publish","format-standard","hentry","category-blog","category-non-classe","tag-math","tag-python","tag-signalprocessing"],"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":1,"uagb_excerpt":"On dit souvent que pour bien apprendre un sujet en informatique il faut \u00e9crire une doc. Pour des besoins pro j’ai du me re-mettre au traitement num\u00e9rique du signal. Je commence en g\u00e9n\u00e9ral par un bouquin et un projet. Pour le projet comme c’est du pro je c’est \u00e0 ma discr\u00e9tion, par contre pour le\u2026","_links":{"self":[{"href":"http:\/\/www.fabienm.eu\/flf\/wp-json\/wp\/v2\/posts\/2060","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=2060"}],"version-history":[{"count":48,"href":"http:\/\/www.fabienm.eu\/flf\/wp-json\/wp\/v2\/posts\/2060\/revisions"}],"predecessor-version":[{"id":2286,"href":"http:\/\/www.fabienm.eu\/flf\/wp-json\/wp\/v2\/posts\/2060\/revisions\/2286"}],"wp:attachment":[{"href":"http:\/\/www.fabienm.eu\/flf\/wp-json\/wp\/v2\/media?parent=2060"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"http:\/\/www.fabienm.eu\/flf\/wp-json\/wp\/v2\/categories?post=2060"},{"taxonomy":"post_tag","embeddable":true,"href":"http:\/\/www.fabienm.eu\/flf\/wp-json\/wp\/v2\/tags?post=2060"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}