Dans ce tutoriel, vous apprendrez comment lire le signal de vitesse ou de tachymètre d’un ventilateur à 3 ou 4 fils avec un Arduino.
Les ventilateurs sont un composant essentiel dans de nombreux appareils électroniques, assurant le refroidissement et la ventilation pour éviter la surchauffe. Surveiller la vitesse d’un ventilateur peut être crucial pour maintenir des performances optimales et prévenir d’éventuelles pannes.
Pièces requises
Voici la liste des pièces nécessaires. J’ai ajouté des LED au cas où vous voudriez faire clignoter une LED d’alerte si la vitesse du ventilateur descend en dessous d’un certain seuil.
Arduino Uno
Jeu de fils Dupont
Plaque d’essai (breadboard)
Câble USB pour Arduino UNO
Kit résistances & LED
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
Types de ventilateurs
Il existe de très nombreux types de ventilateurs. Nous allons ici nous concentrer sur ceux couramment utilisés pour le refroidissement dans les ordinateurs, imprimantes 3D, petits refroidisseurs évaporatifs, etc. La plupart de ces ventilateurs sont brushless DC des ventilateurs à 2, 3 ou 4 fils fonctionnant en 12V.
Ventilateur DC à 2 fils
Les ventilateurs DC à 2 fils sont les plus simples. Ils ont deux fils : un rouge pour l’alimentation (VCC) et un noir pour la masse (GND). Voici une photo d’un ventilateur typique à 2 fils.
Ces ventilateurs tournent à vitesse fixe, mais la vitesse peut être modifiée via Pulse Width Modulation (PWM). Voir notre tutoriel sur How To Control Fan using Arduino . Les ventilateurs à 2 fils ne fournissent pas de signal de vitesse lisible directement. Cependant, vous pouvez utiliser un aimant et un capteur à effet Hall pour créer votre propre signal : Build Arduino Tachometer Using A3144 Hall Effect Sensor
Ventilateur DC à 3 fils
Les ventilateurs DC à 3 fils ont les deux fils habituels pour l’alimentation et la masse (rouge et noir) ainsi qu’un fil supplémentaire (généralement jaune) appelé fil tachymètre (TACH). Ce fil fournit un signal d’impulsions indiquant la vitesse de rotation du ventilateur. En lisant ce signal, vous pouvez surveiller la vitesse ou le nombre de tours par minute (RPM).
Le signal tachymètre est généré par un capteur à effet Hall ou un capteur optique qui détecte le passage de marques spécifiques ou d’aimants sur le rotor ou le moteur du ventilateur. La sortie est une impulsion, et la fréquence des impulsions (ainsi que leur durée) correspond à la vitesse du ventilateur.
La plupart des ventilateurs de refroidissement pour ordinateurs sont à 3 fils, mais ils sont aussi utilisés dans de nombreux autres appareils. Voici une photo d’un petit ventilateur DC 3 fils 12V pour imprimante 3D :
Ventilateur DC à 4 fils
Les ventilateurs à 4 fils sont les plus avancés et offrent des fonctionnalités supplémentaires. Ils ont quatre fils : un pour l’alimentation (généralement rouge), un pour la masse (généralement noir), un pour le signal de vitesse (généralement jaune) et un pour le contrôle de la vitesse (généralement bleu).
La vitesse du ventilateur est régulée en envoyant un signal PWM ( Pulse Width Modulation ) sur le fil de contrôle de vitesse, qui est connecté à un MOSFET contrôlant le moteur. Voir le schéma de circuit ci-dessous.
Voici une photo d’un ventilateur DC 12V 4 fils typique utilisé pour le refroidissement d’ordinateur :
Vous pouvez contrôler la vitesse d’un ventilateur à 2 ou 3 fils de la même manière en construisant vous-même le circuit de contrôle. Consultez notre tutoriel sur How To Control Fan using Arduino pour plus de détails.
En résumé, les ventilateurs à 2 et 3 fils tournent généralement à vitesse constante. Les ventilateurs à 3 fils fournissent un signal tachymètre pour surveiller la vitesse. Les ventilateurs à 4 fils tournent généralement à vitesse variable, contrôlée par un signal PWM sur le quatrième fil, tout en permettant aussi de surveiller la vitesse via le troisième fil.
Comprendre le signal de vitesse du ventilateur
Comme mentionné plus haut, à l’intérieur d’un ventilateur à 3 ou 4 fils se trouve typiquement un Hall Effect Sensor qui détecte le passage de deux aimants fixés sur la partie tournante du ventilateur pour mesurer la vitesse. Deux aimants sont généralement utilisés pour éviter une répartition inégale de la masse des pièces en rotation, ce qui provoquerait des vibrations. Voir la photo ci-dessous.
Le signal de vitesse peut être mesuré en utilisant une résistance de tirage (pull-up) et en connectant un oscilloscope comme montré dans le circuit ci-dessus. Voici une photo de mon oscilloscope affichant le signal tachymètre d’un petit ventilateur.
Comme vous pouvez le voir, le signal tachymètre est une impulsion rectangulaire avec un rapport cyclique de 50 % et une fréquence correspondant à la vitesse de rotation du ventilateur. Plus le ventilateur tourne vite, plus la durée de l’impulsion est courte, et inversement.
Si vous regardez de près, vous verrez que la tension de crête de l’impulsion est d’environ 5V, alors que le ventilateur est un 12V. Cela vient du fait que j’utilise un circuit légèrement différent, que nous détaillerons dans la section suivante.
Connexion du signal de vitesse à un Arduino
Dans cette section, je vous montre comment connecter le signal de vitesse (signal tachymètre) d’un ventilateur à 3 ou 4 fils à un Arduino pour mesurer la vitesse du ventilateur.
Vous ne pouvez pas simplement connecter le fil jaune d’un ventilateur à 3 ou 4 fils à une entrée numérique de l’Arduino pour lire la vitesse. Ça ne fonctionnera pas ! Vous avez besoin d’un pull-up resistor . Le schéma de câblage ci-dessous vous montre comment faire.
Connectez une résistance de 1 kΩ ou 10 kΩ entre la broche +5V et la broche 2 de votre Arduino. Dans l’exemple ci-dessus, j’utilise une résistance de 1 kΩ, mais toute résistance entre 1 kΩ et 10 kΩ convient et est couramment utilisée comme résistance de tirage. Ensuite, connectez aussi le fil tachymètre jaune du ventilateur à la broche 2 de l’Arduino. Il faut aussi connecter le fil noir de masse (GND) du ventilateur à la broche GND de l’Arduino. Enfin, alimentez le ventilateur avec la tension requise. Dans l’exemple, c’est 12V.
Caractéristiques du ventilateur
Mais vérifiez l’étiquette de votre ventilateur pour connaître la tension requise dans votre cas. La photo ci-dessous montre l’étiquette d’un de mes ventilateurs, indiquant 12V avec un courant de 0,18A = 180mA.
Les tensions typiques sont 5V, 6V, 12V et 24V, et les courants autour de 200 à 300mA pour les ventilateurs de refroidissement d’ordinateur. Notez que vous ne pouvez pas utiliser une broche GPIO de votre Arduino comme source d’alimentation pour un ventilateur. Le ventilateur tire trop de courant et endommagerait votre Arduino ! Vous pouvez utiliser la broche 5V de votre Arduino Uno si votre ventilateur consomme moins de 500mA (et est un ventilateur 5-6V).
Circuit sur breadboard
Vous pouvez tester ce circuit avec un ventilateur 12V et une pile 9V si vous n’avez pas d’alimentation 12V. Le ventilateur tournera, juste un peu plus lentement. L’image ci-dessous montre le câblage complet sur une breadboard. C’est le même circuit qu’avant, avec en plus la pile et sur une breadboard.
Dans la section suivante, nous écrirons le code pour mesurer la vitesse du ventilateur avec ce circuit.
Code pour lire le signal de vitesse du ventilateur
Ici, nous allons lire le signal de vitesse du ventilateur pour mesurer les RPM (tours par minute). Cela suppose que vous avez un ventilateur à 3 ou 4 fils fournissant un signal de sortie tachymètre. Si vous avez un ventilateur à 2 fils, pas de souci. Vous pouvez créer un signal tachymètre vous-même. Voir notre tutoriel Build Arduino Tachometer Using A3144 Hall Effect Sensor .
Comme vous l’avez vu plus haut, le signal de vitesse ou tachymètre est une impulsion rectangulaire. Si nous comptons combien d’impulsions nous recevons en une minute, nous pouvons calculer le nombre de rotations du ventilateur par minute. Cette mesure de vitesse s’appelle RPM (tours par minute).
La façon la plus simple de compter les impulsions est de détecter un front montant ou descendant dans le signal. L’image ci-dessous montre une impulsion rectangulaire avec un front descendant marqué.
Compter les fronts descendants revient à compter les impulsions. Le code suivant fait cela en attachant une interruption au signal tachymètre qui incrémente un compteur à chaque front descendant détecté. Jetez un œil rapide au code, puis nous en discuterons en détail.
const int tachoPin = 2;
volatile unsigned long counter = 0;
void countPulses() {
counter ++;
}
void setup() {
Serial.begin(9600);
attachInterrupt(digitalPinToInterrupt(tachoPin), countPulses, FALLING);
}
void loop() {
delay(1000);
long rpm = counter * 60 / 2;
Serial.print("RPM:");
Serial.println(rpm);
counter = 0;
}
Constantes et variables
Nous commençons par les constantes et variables. D’abord, nous définissons la constante tachoPin qui spécifie la broche à laquelle le signal tacho du ventilateur est connecté. Nous définissons aussi une variable counter pour suivre le nombre d’impulsions reçues du signal tacho. Elle doit être de type » volatile « , car elle est utilisée dans une interrupt service routine (ISR).
const int tachoPin = 2; volatile unsigned long counter = 0;
Fonction de comptage des impulsions
Dans la fonction countPulses() , nous incrémentons la variable counter de un à chaque impulsion reçue du signal tacho. Cette fonction est appelée à chaque front descendant détecté sur la broche tachoPin grâce à la fonction attachInterrupt() .
void countPulses() {
counter ++;
}
Fonction setup
Dans la fonction setup() , nous initialisons la communication série à 9600 bauds avec Serial.begin() . Cela nous permet d’afficher les valeurs de RPM sur le moniteur série et le traceur série. Nous attachons aussi une interruption à la broche tachoPin avec attachInterrupt() en spécifiant que l’interruption doit se déclencher sur un front FALLING . À chaque front descendant détecté sur la broche tachoPin , la fonction countPulses() sera appelée. Vous pouvez aussi utiliser le front montant si vous préférez.
void setup() {
Serial.begin(9600);
attachInterrupt(digitalPinToInterrupt(tachoPin), countPulses, FALLING);
}
Fonction loop
Dans la fonction loop() , nous attendons d’abord 1000 ms = 1 seconde avec delay() . Pendant ce délai, la routine d’interruption countPulses() tourne en arrière-plan, comptant les fronts descendants du signal tachymètre.
Nous calculons ensuite les RPM en multipliant la variable counter par 60 (pour convertir les impulsions par seconde en impulsions par minute) et en divisant par 2 (car chaque rotation du ventilateur génère 2 impulsions). Nous affichons la valeur calculée des RPM sur le moniteur série avec Serial.print() et Serial.println() . Enfin, nous remettons la variable counter à 0 pour recommencer à compter les impulsions pour la prochaine période (1 seconde).
void loop() {
delay(1000);
long rpm = counter * 60 / 2;
Serial.print("RPM:");
Serial.println(rpm);
counter = 0;
}
Notez que certains ventilateurs ne génèrent qu’une impulsion par rotation. Dans ce cas, il faut supprimer la division par 2, car chaque impulsion correspond alors à une rotation.
Si vos mesures de vitesse varient beaucoup, vous pouvez augmenter le temps de délai. Par exemple, un délai de 2 secondes donnera des mesures plus stables, mais il faudra alors changer le multiplicateur de 60 à 30. Inversement, pour des mesures plus rapides, vous pouvez réduire le délai à 500 ms, mais il faudra changer le multiplicateur de 60 à 120.
Exemple de sortie
Si je lance ce code avec mon ventilateur et que je ralentis temporairement le ventilateur en appuyant sur l’axe central avec mon doigt, j’obtiens la sortie suivante sur le traceur série :
Et voilà ! Vous savez maintenant comment mesurer la vitesse d’un ventilateur à 3 ou 4 fils en utilisant son signal tachymètre et un Arduino.
Conclusions
Dans cet article, nous avons appris à lire les signaux de vitesse (tachymètre) des ventilateurs avec Arduino. Nous avons commencé par comprendre les différents types de ventilateurs, y compris ceux à 2, 3 et 4 fils.
Nous avons ensuite examiné le signal de vitesse lui-même. Les signaux de vitesse sont généralement fournis sous forme d’impulsions rectangulaires dont la fréquence est proportionnelle à la vitesse du ventilateur, mesurée en tours par minute (RPM).
Ensuite, nous avons vu comment connecter le fil du signal de vitesse au Arduino. Nous avons fourni un guide étape par étape pour réaliser les connexions nécessaires.
Enfin, nous avons abordé la rédaction du code pour lire le signal de vitesse. Nous avons expliqué comment utiliser les interruptions pour capturer les impulsions du ventilateur et calculer la vitesse en fonction du nombre d’impulsions reçues en une seconde.
Si vous avez d’autres questions ou besoin de précisions sur un des sujets abordés dans cet article, veuillez consulter la section FAQ ci-dessous.
Foire aux questions
Voici quelques questions fréquemment posées sur la lecture des signaux de vitesse des ventilateurs avec Arduino :
Q : De quels types de ventilateurs puis-je lire le signal de vitesse ?
R : Vous pouvez lire le signal de vitesse des ventilateurs à 3 et 4 fils. Ce sont des types courants utilisés dans divers appareils électroniques et systèmes informatiques.
Q : Comment identifier le fil du signal de vitesse sur un ventilateur ?
R : Le fil du signal de vitesse est généralement étiqueté « TACH » ou « SIGNAL » sur le ventilateur. Il est typiquement jaune, tandis que les fils d’alimentation et de masse sont rouge et noir. Pour un ventilateur à 4 fils, on trouve souvent un fil bleu supplémentaire pour le contrôle de vitesse.
Q : Comment avertir si la vitesse du ventilateur est trop basse ?
Voici un exemple de code qui allume la LED intégrée si la vitesse du ventilateur descend en dessous de 500 RPM :
const int tachoPin = 2;
volatile unsigned long counter = 0;
void countPulses() {
counter ++;
}
void setup() {
pinMode(LED_BUILTIN, OUTPUT);
attachInterrupt(digitalPinToInterrupt(tachoPin), countPulses, FALLING);
}
void loop() {
delay(1000);
long rpm = counter * 60 / 2;
counter = 0;
int warn = rpm < 500 ? HIGH : LOW;
digitalWrite(LED_BUILTIN, warn);
}
Q : Puis-je connecter plusieurs ventilateurs à l’Arduino pour lire leurs signaux de vitesse ?
R : Oui, vous pouvez connecter plusieurs ventilateurs à l’Arduino en utilisant des broches d’entrée numérique séparées pour chaque fil de signal de vitesse. Assurez-vous d’adapter votre code pour lire les signaux de plusieurs broches.
Q : Quel est le niveau de tension du signal de vitesse du ventilateur ?
R : Le niveau de tension du signal de vitesse dépend de la tension à laquelle la résistance de tirage est connectée. Pour lire un signal tachymètre avec un Arduino, on utilise un signal 5V. Pour d’autres microcontrôleurs, comme l’ESP32, on utilise un signal à 3,2V.
Q : Comment calculer la vitesse du ventilateur à partir du signal de vitesse ?
R : La vitesse du ventilateur est généralement fournie sous forme d’une série d’impulsions par révolution (PPR) ou de tours par minute (RPM).
Q : Puis-je contrôler la vitesse du ventilateur avec un Arduino ?
R : Lire le signal de vitesse avec Arduino permet de surveiller la vitesse, mais ne la contrôle pas directement. Pour contrôler la vitesse, vous aurez besoin d’un circuit supplémentaire, comme un driver moteur ou un contrôleur PWM, selon le type de ventilateur.
Cependant, si vous contrôlez la vitesse avec un signal PWM, cela perturbera la mesure de vitesse. Il faudra alors suspendre le PWM pendant la mesure ou utiliser un ventilateur à 4 fils avec un fil de contrôle de vitesse séparé.
Q : Y a-t-il des précautions de sécurité à prendre en compte quand on travaille avec des ventilateurs et un Arduino ?
R : Oui, ne pas alimenter le ventilateur depuis les broches GPIO de l’Arduino ! Utilisez une alimentation ou une batterie séparée avec la tension et le courant adaptés, et assurez-vous de connecter les masses de l’alimentation et de l’Arduino. N’utilisez pas non plus les circuits présentés ici avec un ventilateur AC fonctionnant en 110V ou 220V !
Si vous avez d’autres questions spécifiques, n’hésitez pas à les poser dans la section commentaires ci-dessous.
