EasyFFT – Bibliothèque FFT fiable pour projets Arduino

Composants et fournitures

Arduino Nano R3

×

1

Applications et services en ligne

• Arduino IDE

À propos de ce projet

La mesure de fréquence à partir d'un signal capturé peut être une tâche difficile, surtout sur Arduino qui a une puissance de calcul limitée. Il existe des méthodes pour capturer le passage à zéro où la fréquence est déterminée en comptant combien de fois le signal franchit la ligne zéro dans un temps donné. Cette méthode peut ne pas fonctionner quand le signal est une combinaison de plusieurs fréquences.

C'est d'autant plus difficile à coder si vous n'avez pas de formation en traitement de signal. Mais pour un bidouilleur, ce code peut être très utile pour divers projets liés à la musique, l'analyse de signaux. L'objectif de ce projet était de préparer un code facile à implémenter sur Arduino sans entrer dans les détails mathématiques.

Ce projet n'explique pas le fonctionnement de la FFT mais son application. Le même processus est aussi expliqué dans la vidéo jointe.

Si vous n'êtes intéressé que par l'application du code et non par son explication, vous pouvez passer directement à l'étape 3.

Si vous avez besoin d'effectuer une FFT à haute vitesse (3x) avec un léger compromis sur la précision (environ 5%), consultez mon autre article sur ApproxFFT : https://create.arduino.cc/projecthub/abhilashpatel121/approxfft-fastest-fft-function-for-arduino-fd4917?ref=user&ref_id=1593632&offset=0

Étape 1 : Transformée de Fourier Rapide

Pour accélérer le calcul de la TFD (Transformée de Fourier Discrète), l'algorithme FFT a été développé par James Cooley et John Tukey. Cet algorithme est considéré comme l'un des plus importants du 20e siècle. Il divise un signal en parties à indices pairs et impairs, ce qui réduit le nombre de calculs requis. En l'utilisant, le nombre total de multiplications complexes passe de N² (TFD classique) à N·logN, ce qui est un avantage significatif pour de grands échantillons.

Références pour comprendre les mathématiques derrière la FFT :

1. https://flylib.com/books/en/2.729.1/derivation_of_...
2. https://jakevdp.github.io/blog/2013/08/28/understa...
3. https://cnx.org/contents/8D0YvnW1@7.1:zmcmahhR@7/D...
4. https://en.wikipedia.org/wiki/Fast_Fourier_transfo...

Étape 2 : Explication du code

1. Sinus et cosinus rapides

Le calcul de la FFT nécessite les valeurs de nombreux sinus et cosinus. La fonction intégrée d'Arduino n'est pas assez rapide et double le temps d'exécution pour 64 échantillons. Pour contrer ce problème, les valeurs du sinus de 0 à 90 degrés sont stockées comme multiples de 255. Cela élimine le besoin de stocker des nombres en float : on peut les stocker en byte (1/4 de l'espace). Le tableau sine_data[] doit être placé au début du code pour être déclaré comme variable globale.

En plus de sine_data, un tableau f_peaks[] déclaré en variable globale est mis à jour après chaque exécution de la fonction FFT. f_peaks[0] contient la fréquence la plus dominante, les suivantes dans l'ordre décroissant.

byte sine_data[91] = { 
  0, 4, 9, 13, 18, 22, 27, 31, 35, 40, 44, 49, 53, 57, 62, 66, 70, 75, 79, 83, 87, 
  91, 96, 100, 104, 108, 112, 116, 120, 124, 127, 131, 135, 139, 143, 146, 150, 153, 
  157, 160, 164, 167, 171, 174, 177, 180, 183, 186, 189, 192, 195, 198, 201, 204, 206, 
  209, 211, 214, 216, 219, 221, 223, 225, 227, 229, 231, 233, 235, 236, 238, 240, 241, 
  243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 253, 254, 254, 254, 255, 255, 255, 255 
}; 
float f_peaks[5];

Comme nous avons stocké les valeurs du sinus de 0 à 90°, toute valeur de sinus ou cosinus peut être calculée. La fonction ci-dessous arrondit l'angle au degré le plus proche et renvoie la valeur stockée. Cette méthode ne nécessite qu'une seule division flottante. On pourrait encore la réduire en stockant directement les valeurs du sinus (pas multiples de 255), mais cela consommerait plus de mémoire sur Arduino.

Cette procédure réduit la précision mais améliore la vitesse. Pour 64 points, gain de 8 ms ; pour 128 points, gain de 20 ms.

Étape 3 : Explication du code – Fonction FFT

La FFT ne peut être effectuée que pour des tailles d'échantillon de 2, 4, 8, 16, 32, 64, etc. Si la valeur n'est pas une puissance de 2, elle prendra la valeur inférieure. Par exemple, pour 70 échantillons, seuls les 64 premiers seront considérés.

Il est toujours recommandé d'avoir une taille d'échantillon de 2^n : 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048...

Deux tableaux float out_r et out_im consomment beaucoup de mémoire. Sur Arduino Nano, cela ne fonctionnera pas pour plus de 128 échantillons (et parfois même 128) par manque de mémoire.

unsigned int data[13] = {1,2,4,8,16,32,64,128,256,512,1024,2048}; 
int a, c1, f, o, x; 
a = N; 
for(int i = 0; i < 12; i++) { 
  if(data[i] <= a) { o = i; } 
} 
int in_ps[data[o]] = {}; 
float out_r[data[o]] = {}; 
float out_im[data[o]] = {};

Le flux est le suivant :

1. Le code génère un ordre à bits inversés pour la taille d'échantillon donnée (détails sur l'inversion de bits dans les références : étape 2)
2. Les données d'entrée sont ordonnées selon cet ordre
3. La FFT est effectuée
4. L'amplitude des nombres complexes est calculée
5. Les pics sont détectés et ordonnés par ordre décroissant
6. Les résultats sont accessibles via f_peaks[]

[Pour accéder à d'autres données (hors fréquence de pointe), le code doit être modifié pour copier les variables locales vers des variables globales prédéfinies]

Étape 4 : Test du code

Une onde triangulaire d'échantillonnage est donnée en entrée. Fréquence d'échantillonnage : 10 Hz, fréquence de l'onde : 1,25 Hz.

La sortie brute correspond aux résultats FFT calculés par Scilab, bien que les valeurs ne soient pas exactement identiques en raison de la précision réduite du sinus rapide.

Dans le tableau des fréquences de sortie, on trouve 1,25 et 3,75 Hz. Il n'est pas nécessaire d'obtenir la valeur exacte à chaque fois ; ce sont généralement des "bins de fréquence", la valeur de sortie pouvant se situer n'importe où dans le bin spécifié.

Vitesse sur Arduino Nano :

• 16 points : 4 ms
• 32 points : 10 ms
• 64 points : 26 ms
• 128 points : 53 ms

Étape 5 : Conclusion

Ce code FFT peut être utilisé en temps réel, prenant environ 30 ms pour le calcul. Cependant, sa résolution est limitée par le nombre d'échantillons, lui-même limité par la mémoire de l'Arduino. En utilisant un Arduino Mega ou une carte plus performante, la précision peut être améliorée.

Pour toute question, suggestion ou correction, n'hésitez pas à commenter.