Dans cet article, vous apprendrez comment contrôler un ventilateur avec un Arduino Uno. Nous examinerons les différents types de ventilateurs et les méthodes pour les contrôler. À la fin de cet article, vous aurez une bonne compréhension de la manière de contrôler un ventilateur et serez équipé des connaissances nécessaires pour créer votre propre système de contrôle de ventilateur.
Alors, commençons !
Pièces requises
Vous trouverez ci-dessous les pièces nécessaires pour ce projet. Je suppose que vous avez déjà un ventilateur que vous souhaitez contrôler, mais vous trouverez également des liens vers différents types de ventilateurs dans la section suivante.
Nous allons utiliser un MOSFET 2N7000 pour certains des circuits présentés dans ce blog. J’ai fourni un lien vers un kit contenant divers transistors et MOSFET, ce qui est pratique à avoir. Vous pouvez aussi acheter le 2N7000 MOSFET seul, mais ils sont généralement vendus en paquets de 100 pièces, ce qui est probablement plus que nécessaire.
Si vous souhaitez contrôler des ventilateurs ou des appareils qui consomment plus de 200mA, les petits MOSFET comme le 2N7000 ne seront pas suffisants. Vous aurez besoin de MOSFET de puissance MOSFETs, pouvant aller jusqu’à 100A !
Arduino Uno
Jeu de fils Dupont
Plaque d’essai (Breadboard)
Câble USB pour Arduino UNO
Kit de trimmers
Kit de résistances & LED
Module relais
Kit de transistors
Capteur de mouvement
Capteur de température
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
Dans cette section, nous jetons un rapide coup d’œil aux différents types de ventilateurs que vous souhaitez généralement contrôler avec un Arduino.
Ventilateurs AC versus DC
Lorsqu’il s’agit de contrôler un ventilateur avec un Arduino, une considération clé est de savoir si le ventilateur fonctionne en courant alternatif (AC) ou en courant continu (DC). Comprendre la différence entre les deux est crucial pour choisir le ventilateur approprié et assurer la compatibilité avec votre configuration Arduino.
Ventilateurs AC
Les ventilateurs AC sont conçus pour fonctionner sur l’alimentation électrique domestique standard de 110V ou 220V, par exemple. On les trouve souvent comme ventilateurs de plafond ou dans des appareils comme les climatiseurs. Mais il existe aussi de petits ventilateurs de bureau AC. Les ventilateurs AC fonctionnent généralement à vitesse fixe. Ci-dessous, vous pouvez voir une photo d’un ventilateur AC typique :
Notez qu’il est généralement impossible de déterminer à l’œil si un ventilateur est AC ou DC, ou quelle tension il nécessite. Vous devrez vérifier l’étiquette (voir ci-dessus) qui fournit cette information.
Pour contrôler un ventilateur AC avec un Arduino, vous utiliserez généralement un Relay ou un Thyristor. Les relais ou thyristors agissent comme des interrupteurs contrôlables capables de gérer la haute tension et le courant d’un ventilateur AC. Attention, soyez très prudent avec les hautes tensions !
Ventilateurs DC
Les ventilateurs DC, contrairement aux ventilateurs AC, fonctionnent en courant continu. Ils sont couramment utilisés dans les appareils électroniques tels que les ordinateurs, les portables, et pour d’autres petits systèmes de refroidissement. Ils fonctionnent généralement sous 6V ou 12V et peuvent être facilement contrôlés avec un Arduino.
Les ventilateurs DC existent en différentes configurations, telles que 2 fils, 3 fils et 4 fils. Regardons de plus près ces variantes dans les sections suivantes.
Ventilateur DC 2 fils
Les ventilateurs DC 2 fils sont le type le plus simple de ventilateurs DC. Ils ont deux fils – un fil rouge pour l’alimentation (VCC) et un fil noir pour la masse (GND). Ces ventilateurs fonctionnent nativement à vitesse fixe, mais la vitesse peut être modifiée via la modulation de largeur d’impulsion (PWM). Je vous montrerai plusieurs exemples de cette méthode. Ci-dessous une photo d’un ventilateur DC 12V typique. Notez les deux fils pour l’alimentation et la masse.
Ventilateur DC 3 fils
Les ventilateurs DC 3 fils ont les deux fils habituels pour l’alimentation et la masse (rouge et noir) et un fil supplémentaire (généralement jaune) appelé fil tachymètre (TACH). Ce fil fournit un signal d’impulsion indiquant la vitesse de rotation du ventilateur. En lisant ce signal, vous pouvez surveiller la vitesse du ventilateur dans votre projet Arduino.
Le signal tachymètre est généré par un capteur à effet Hall ou un capteur optique qui détecte le passage de marques ou caractéristiques spécifiques sur le rotor ou le moteur du ventilateur. La sortie est une impulsion, et la fréquence des impulsions correspond à la vitesse du ventilateur. Une vitesse plus élevée (RPM) entraîne une fréquence d’impulsions plus élevée, tandis qu’une vitesse plus basse entraîne une fréquence plus faible.
Beaucoup de ventilateurs de refroidissement d’ordinateur sont des ventilateurs 3 fils, mais ils sont aussi utilisés dans de nombreux autres appareils. Ci-dessous une photo d’un petit ventilateur DC 12V 3 fils pour imprimante 3D :
Ventilateur DC 4 fils
Un ventilateur DC 4 fils est un autre type de ventilateur typiquement utilisé comme ventilateur de refroidissement dans les ordinateurs. C’est une extension du ventilateur 3 fils avec un quatrième fil pour contrôler la vitesse du ventilateur. Comme pour les ventilateurs 2 et 3 fils, le fil d’alimentation positif est généralement rouge et le fil de masse est noir. Le fil du signal tachymètre est jaune. Le fil supplémentaire de contrôle de vitesse est 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. Pour plus de détails, consultez le schéma de circuit suivant.
Ci-dessous une photo d’un ventilateur DC 12V 4 fils typique utilisé comme ventilateur de refroidissement d’ordinateur :
En résumé, les ventilateurs 2 et 3 fils fonctionnent généralement à vitesse constante. Les ventilateurs 3 fils fournissent un signal tachymètre pour surveiller la vitesse. Les ventilateurs 4 fils fonctionnent généralement à vitesse variable, contrôlée via un signal PWM sur le quatrième fil, tout en permettant aussi de surveiller la vitesse via le troisième fil.
Notez que le signal tachymètre et le fil de contrôle de vitesse utilisent tous deux des impulsions comme signaux. Mais le signal tachymètre est une sortie, tandis que le contrôle de vitesse est une entrée. De plus, la vitesse est contrôlée via une modulation de largeur d’impulsion avec un rapport cyclique variable, tandis que le signal tachymètre a un rapport cyclique constant de 50 % mais la fréquence change en fonction de la vitesse.
Dans les sections suivantes, nous examinerons différentes méthodes pour contrôler un ventilateur.
Exemple 1 : Commander un ventilateur avec un relais
Nous commençons par la méthode la plus simple pour contrôler un ventilateur. Nous connectons un des modules relais courants à un Arduino et l’utilisons pour allumer ou éteindre un ventilateur.
Notez qu’il est généralement impossible de connecter un ventilateur directement à une des broches de sortie d’un Arduino. Le courant de sortie sur les broches GPIO d’un Arduino est limité à 20mA (40mA à court terme). À part pour de très petits ventilateurs, presque tous consomment plus de courant que cela et nécessitent aussi des tensions plus élevées que les 5V fournis par les broches GPIO.
Câblage sur breadboard
Connecter un ventilateur via un relais à un Arduino est très simple. Regardez le schéma de câblage ci-dessous.
Connexion du relais à l’Arduino
Connectez d’abord la masse (GND) de l’Arduino à la broche marquée (-) ou GND du relais (fil bleu). Puis connectez la sortie 5V de l’Arduino à la broche d’alimentation positive (+) du relais (fil rouge). Ensuite, connectez le fil de signal (jaune) de la broche 3 à la broche marquée (S) sur le module relais. Ce fil contrôle le relais, qui à son tour allume ou éteint le ventilateur.
Connexion de l’alimentation
Ensuite, connectez le ventilateur à l’alimentation. Vous aurez besoin d’une alimentation ou d’une batterie correspondant aux besoins en puissance du ventilateur. Par exemple, si vous avez un ventilateur 12V, 180mA, vous aurez besoin d’une alimentation ou batterie 12V capable de fournir au moins 180mA. En résumé, la tension de votre batterie ne doit pas être supérieure à celle du ventilateur, mais le courant doit être supérieur.
Dans l’exemple ci-dessus, j’utilise une batterie 9V de 1000mAh pour alimenter un ventilateur 12V, 180mA. Cela fonctionne et convient pour des tests, mais le ventilateur ne tournera pas à pleine vitesse. Pour une application réelle, j’utiliserais une batterie ou alimentation 12V.
Connexion du ventilateur
La connexion du ventilateur est simple. Connectez le fil bleu/noir du ventilateur au pôle moins (-) de la batterie. Le fil rouge va aux bornes de commutation du relais. Une borne sera marquée GND (masse), une NO (normalement ouverte), une NC (normalement fermée). Normalement Ouvert signifie que l’interrupteur est ouvert par défaut et que le ventilateur ne tourne pas tant que le relais n’est pas activé. Connectez les fils rouges de la batterie et du ventilateur à GND et NO. L’ordre n’a pas d’importance.
Notez cependant que beaucoup de ventilateurs (notamment les ventilateurs de refroidissement d’ordinateur) utilisent des moteurs sans balais avec une électronique interne nécessitant une polarité correcte. Alors que vous pouvez inverser le sens de rotation d’un moteur DC simple en inversant les polarités, cela ne fonctionne généralement pas avec les moteurs sans balais. Ils ne tournent que dans un sens avec la bonne polarité. Les avantages des moteurs sans balais sont qu’ils sont silencieux, peuvent fonctionner longtemps et ne nécessitent pas de snubber diode.
Vous pouvez aussi utiliser le circuit ci-dessus pour commuter des ventilateurs AC, mais soyez prudent ! Utilisez impérativement un module relais plutôt qu’un relais simple, car les modules relais ont généralement des optocoupleurs pour assurer l’isolation électrique.
Code pour contrôler un ventilateur avec un relais
Allumer ou éteindre un ventilateur avec un Arduino est maintenant très simple. Vous pouvez voir le code ci-dessous, qui allume et éteint périodiquement le ventilateur toutes les 5 secondes.
// Control a relay to switch on/off a fan
const int relayPin = 3;
void setup() {
pinMode(relayPin, OUTPUT);
}
void loop() {
digitalWrite(relayPin, HIGH);
delay(5000);
digitalWrite(relayPin, LOW);
delay(5000);
}
Passons en revue le code pour comprendre son fonctionnement.
Constantes et variables
Nous commençons par définir la constante relayPin qui spécifie la broche à laquelle le relais est connecté. Ici, il est connecté à la broche 3.
const int relayPin = 2;
Fonction setup
Dans la fonction setup(), nous définissons le mode de la broche relayPin en OUTPUT. Cela est nécessaire car nous allons écrire sur cette broche pour contrôler le relais.
void setup() {
pinMode(relayPin, OUTPUT);
}
Fonction loop
La fonction loop() contient la logique principale de notre code. Dans cette fonction, nous mettons d’abord la broche relayPin à HIGH avec la fonction digitalWrite(). Cela allume le relais et met le ventilateur en marche. Nous attendons ensuite 5000 millisecondes (5 secondes) avec la fonction delay().
void loop() {
digitalWrite(relayPin, HIGH);
delay(5000);
Après ce délai, nous mettons la broche relayPin à LOW avec la fonction digitalWrite(). Cela éteint le relais et arrête le ventilateur. Nous attendons encore 5000 millisecondes (5 secondes) avec la fonction delay().
digitalWrite(relayPin, LOW); delay(5000);
Ce processus d’allumage et d’extinction du ventilateur est répété indéfiniment en boucle, créant un cycle continu de 5 secondes de ventilation puis 5 secondes d’arrêt.
Avec le code et le circuit ci-dessus, vous pouvez allumer ou éteindre un ventilateur pendant des durées données. Vous pourriez maintenant utiliser l’horloge interne de l’Arduino pour allumer le ventilateur à un moment précis et le faire fonctionner pendant une durée fixe, par exemple.
Dans la section suivante, je vous montrerai comment utiliser un module PIR pour allumer un ventilateur lorsqu’un mouvement est détecté.
Exemple 2 : Commander un ventilateur avec un détecteur de mouvement
Dans de nombreux cas, vous souhaitez faire fonctionner un ventilateur uniquement lorsqu’un mouvement est détecté. Par exemple, l’image ci-dessous montre un ventilateur activé par mouvement que j’ai construit pour évacuer les fumées de soudure. Vous pouvez voir le détecteur de mouvement (capteur PIR) à la base du ventilateur.
Circuit pour ventilateur activé par mouvement
Le circuit suivant montre comment construire quelque chose de similaire. Il utilise un capteur infrarouge passif (PIR) pour détecter le mouvement qui active un relais, lequel allume le ventilateur.
Le circuit est essentiellement identique à celui du ventilateur commandé par relais vu précédemment. Il suffit d’ajouter le capteur de mouvement. Connectez donc d’abord la batterie, le relais, le ventilateur et l’Arduino de la même manière. Ensuite, connectez le plus et le moins du capteur PIR aux rails d’alimentation positifs et négatifs de la breadboard (fils bleu et rouge). Enfin, connectez la sortie signal du capteur PIR à la broche 2 de l’Arduino (fil vert).
Code pour ventilateur activé par mouvement
Vous trouverez ci-dessous le code pour le ventilateur activé par mouvement. Il interroge (=lit) le capteur de mouvement toutes les 100 ms et, si un mouvement est détecté, allume le ventilateur pendant 10 secondes. Jetez un coup d’œil rapide, puis nous discuterons des détails.
// Switch on fan for 10 seconds via relay
// if PIR sensor detects motion
const int motionPin = 3;
const int relayPin = 2;
void setup() {
pinMode(motionPin, INPUT);
pinMode(relayPin, OUTPUT);
}
void loop() {
int motionState = digitalRead(motionPin);
if (motionState == HIGH) {
digitalWrite(relayPin, HIGH);
delay(10000); // 10 seconds
digitalWrite(relayPin, LOW);
}
delay(100);
}
Constantes et variables
Nous commençons par définir les constantes motionPin et relayPin qui spécifient les broches auxquelles sont connectés respectivement le capteur PIR et le relais.
const int motionPin = 3; const int relayPin = 2;
Fonction setup
Dans la fonction setup(), nous définissons le mode de motionPin en INPUT et de relayPin en OUTPUT car nous lisons depuis le capteur PIR et écrivons vers le relais.
void setup() {
pinMode(motionPin, INPUT);
pinMode(relayPin, OUTPUT);
}
Fonction loop
Dans la fonction loop(), nous lisons d’abord l’état du capteur PIR avec digitalRead(motionPin) et le stockons dans la variable motionState.
void loop() {
int motionState = digitalRead(motionPin);
Si la variable motionState vaut HIGH, indiquant qu’un mouvement est détecté, nous allumons le ventilateur en mettant la broche relayPin à HIGH avec digitalWrite(relayPin, HIGH). Nous attendons ensuite 10 secondes avec delay(10000) pour garder le ventilateur allumé. Puis, nous éteignons le ventilateur en mettant la broche relayPin à LOW avec digitalWrite(relayPin, LOW).
if (motionState == HIGH) {
digitalWrite(relayPin, HIGH);
delay(10000); // 10 seconds
digitalWrite(relayPin, LOW);
}
Enfin, nous ajoutons un petit délai de 100 ms avec delay(100) pour éviter de lire trop fréquemment le capteur PIR et permettre à l’Arduino d’exécuter d’autres tâches.
delay(100);
Et voilà. Vous avez maintenant un ventilateur activé par mouvement !
Exemple 3 : Contrôler la vitesse du ventilateur avec PWM
Dans les exemples précédents, nous avons simplement allumé ou éteint un ventilateur. Mais que faire si l’on veut contrôler la vitesse du ventilateur ? Dans cet exemple, nous allons apprendre comment faire.
On utilise couramment la modulation de largeur d’impulsion (PWM) pour contrôler la puissance délivrée à un appareil. Le PWM est une technique où la valeur moyenne d’un signal est ajustée en variant le rapport cyclique d’une onde carrée. En changeant le rapport cyclique, on peut contrôler la vitesse du ventilateur. Consultez notre tutoriel sur How use Arduino to control an LED with a Potentiometer pour plus de détails sur le PWM.
Cependant, vous ne pouvez pas connecter directement un ventilateur à un Arduino et le contrôler ainsi, car un ventilateur consomme trop de puissance. Dans les exemples précédents, nous utilisons un relais pour contourner ce problème. Mais les relais sont trop lents pour le PWM et ne supporteraient pas longtemps le stress mécanique causé par un signal PWM.
MOSFET
Nous allons donc utiliser un MOSFET. Un MOSFET (Metal-Oxide-Semiconductor Field-Effect Transistor) est un type de transistor largement utilisé dans les circuits électroniques. C’est un dispositif à trois broches (Drain, Gate, Source) qui peut amplifier et commuter des signaux électroniques. Le MOSFET fonctionne en contrôlant le flux de courant entre ses broches Source et Drain via un champ électrique généré par une tension appliquée à sa broche Gate. Il est connu pour sa grande vitesse de commutation, sa faible consommation d’énergie et sa capacité à gérer des courants et tensions élevés.
Dans cet exemple, j’utiliserai un MOSFET 2N7000. Voici le symbole du circuit et le brochage du 2N7000 ci-dessous.
Pour plus de détails, consultez la fiche technique du 2N7000 :
Le 2N7000 peut commuter jusqu’à 60V et 200mA en continu. Cela suffit pour mon petit ventilateur. Vous pouvez généralement connaître les besoins en tension et courant en regardant l’étiquette. La photo ci-dessous montre l’étiquette de mon ventilateur qui fonctionne en 12V et consomme 0,18A = 180mA. Le MOSFET 2N7000 convient donc pour contrôler mon ventilateur.
Si vous avez un ventilateur plus puissant qui consomme plus de courant, vous aurez besoin d’un MOSFET plus puissant. Il en existe de nombreux types, certains pouvant commuter 100A et plus ! Cherchez simplement un modèle avec une tension (V DSS ) et un courant (I D ) supérieurs aux besoins de votre ventilateur. Le kit de transistors proposé dans les pièces requises offre une bonne sélection.
En règle générale, choisissez un MOSFET avec une marge d’environ 2x pour être sûr et éviter la nécessité d’un refroidissement. Pour les petits ventilateurs comme celui que j’utilise ici, cette marge n’est pas indispensable.
Circuit pour contrôler la vitesse du ventilateur
Dans cette section, je vous montre et explique le circuit nécessaire pour contrôler un ventilateur avec un MOSFET. C’est très simple. Regardez :
Nous connectons une sortie PWM de l’Arduino, ici la GPIO 3, à la broche Gate (G) du MOSFET 2N7000. La résistance de 100Ω (R2) est simplement une résistance de limitation de courant pour des raisons de sécurité. Vous pouvez la supprimer. La deuxième résistance (R1) de 100KΩ est une résistance de tirage à la masse (pulldown) qui garantit que le MOSFET s’éteint lorsque la gate n’est pas connectée.
Le ventilateur est connecté au +12V et au Drain (D) du MOSFET, tandis que la Source (S) est reliée à la masse (GND). Si la Gate du MOSFET reçoit une impulsion PWM, il s’ouvre et le courant peut circuler du Drain vers la Source, ce qui alimente le ventilateur. Rappelez-vous que les ventilateurs sans balais ont une polarité. Donc, si le ventilateur ne tourne pas, vérifiez la polarité et aussi l’orientation correcte du MOSFET.
Si vous utilisez un moteur DC standard ou un ventilateur avec balais, vous devriez ajouter une Flyback Diode en parallèle avec le moteur pour supprimer les pics de tension qu’une charge inductive comme un moteur ou un solénoïde génère. Ci-dessous une photo du circuit avec une diode de roue libre supplémentaire :
Code pour contrôler la vitesse du ventilateur
Voici un exemple de code pour contrôler le ventilateur. Il l’éteint pendant 3 secondes, puis le fait tourner 3 secondes à vitesse moyenne, puis 3 secondes à pleine vitesse.
// Code to control Fan speed via PWM
int fanPin = 3;
void setup() {
pinMode(fanPin, OUTPUT);
}
void loop() {
// Fan off
analogWrite(fanPin, 0);
delay(3000);
// Medium speed
analogWrite(fanPin, 150);
delay(3000);
// Max speed
analogWrite(fanPin, 255);
delay(3000);
}
Analysons le code pour comprendre son fonctionnement.
Constantes et variables
Dans ce code, nous avons une seule variable appelée fanPin. Cette variable stocke le numéro de la broche à laquelle le ventilateur est connecté. Ici, le ventilateur est connecté à la broche 3. Notez que vous devez utiliser une broche PWM ! Les broches PWM sur l’Arduino Uno sont identifiées par un signe « ~ », comme ~3, ~5, ~6, ~9, ~10 et ~11.
int fanPin = 3;
Fonction setup
Dans la fonction setup(), nous définissons le mode de la broche fanPin en OUTPUT. Cela est nécessaire car nous allons écrire sur cette broche pour contrôler la vitesse du ventilateur.
void setup() {
pinMode(fanPin, OUTPUT);
}
Fonction loop
Dans la fonction loop(), nous contrôlons la vitesse du ventilateur avec le PWM. Nous avons trois niveaux de vitesse : arrêt, moyen et maximum.
D’abord, nous éteignons le ventilateur en mettant la valeur PWM à 0 avec analogWrite(fanPin, 0). Nous attendons ensuite 3 secondes avec delay(3000).
// Fan off analogWrite(fanPin, 0); delay(3000);
Ensuite, nous réglons la vitesse du ventilateur à un niveau moyen en mettant la valeur PWM à 150 avec analogWrite(fanPin, 150). Nous attendons encore 3 secondes.
// Medium speed analogWrite(fanPin, 150); delay(3000);
Enfin, nous réglons la vitesse du ventilateur au maximum en mettant la valeur PWM à 255 avec analogWrite(fanPin, 255). Nous attendons encore 3 secondes avant de répéter la boucle.
// Max speed analogWrite(fanPin, 255); delay(3000);
Cette boucle continue indéfiniment, alternant entre les différentes vitesses du ventilateur.
Avec ce code et ce circuit, vous pouvez contrôler la vitesse de presque tous les ventilateurs. Cela fonctionne pour les ventilateurs sans balais et avec balais, 2 et 3 fils. Si vous avez un ventilateur 4 fils, qui possède déjà un circuit de contrôle interne de la vitesse, vous n’aurez pas besoin du circuit MOSFET montré ci-dessus, mais pourrez fournir directement le signal PWM.
Exemple 3 : Ventilateur contrôlé par la température
Un cas d’usage très courant est de réguler la vitesse du ventilateur en fonction de la température ambiante. Je vous montre comment faire dans cet exemple.
D’abord, il nous faut un capteur pour mesurer la température. Il existe de nombreux types de capteurs de température et peu importe lequel vous choisissez. Ici, j’utiliserai le capteur de température & humidité DHT11. Vous pouvez les trouver en modules ou en capteurs seuls. Les deux conviennent et fonctionnent de la même manière.
Si vous avez besoin de plus de détails sur le DHT11 et son cousin le DHT22, consultez notre tutoriel : DHT11/DHT22 Sensor with Arduino Tutorial. Au lieu du DHT11, vous pouvez aussi utiliser le TMP36, le LM35 ou le DS18B20. Ce sont d’autres capteurs de température adaptés, mais vous devrez ajuster un peu le circuit et le code si vous les utilisez.
Circuit pour ventilateur contrôlé par la température
Le circuit pour contrôler la vitesse du ventilateur avec un DHT11 est montré ci-dessous. Vous pouvez remplacer le DHT11 par un DHT21 ou DHT22 sans changer le circuit.
Comme vous pouvez le voir, nous utilisons le même circuit à base de MOSFET pour contrôler le ventilateur via PWM depuis la broche 3 de l’Arduino. Nous ajoutons simplement le DHT11 et connectons sa broche IO à la broche 2 de l’Arduino. Pour l’alimentation, connectez la broche VCC au 5V et la broche GND à la masse. L’image suivante montre le brochage du DHT11.
Notez que la broche 3 n’est pas utilisée. C’est pourquoi les modules DHT ont seulement trois broches, alors que le capteur en a 4.
Ci-dessous une photo du circuit complet utilisant un petit ventilateur, une batterie 9V et une breadboard.
Code pour ventilateur contrôlé par la température
Le code suivant montre comment utiliser le PWM (modulation de largeur d’impulsion) et les mesures de température du capteur DHT11 pour ajuster la vitesse du ventilateur.
// Control fan speed using PWM based
// on temperature reading from DHT11 sensor
#include "Adafruit_Sensor.h"
#include "DHT.h"
const int tempPin = 2;
const int fanPin = 3;
// Sensor types: DHT11, DHT22, DHT21
DHT dht = DHT(tempPin, DHT11);
void setup() {
dht.begin();
pinMode(fanPin , OUTPUT);
}
void loop() {
float temp = dht.readTemperature(); // Celsius
if (isnan(temp)) return;
int fanSpeed = map(temp, 20, 40, 0, 255);
fanSpeed = constrain(fanSpeed, 0, 255);
analogWrite(fanPin, fanSpeed);
delay(5000);
}
Analysons le code pour comprendre son fonctionnement.
Bibliothèques
Le DHT11 utilise un protocole de communication relativement complexe (voir Datasheet). Vous pourriez l’implémenter vous-même, mais il est plus simple d’utiliser une bibliothèque. Il existe plusieurs bibliothèques Arduino pour le capteur DHT11. Ici, nous utilisons celle d’Adafruit.
#include "Adafruit_Sensor.h" #include "DHT.h"
Vous devrez installer la bibliothèque de base « Adafruit_Sensor.h » ainsi que leur bibliothèque « DHT.h ». Consultez notre tutoriel : DHT11/DHT22 Sensor with Arduino Tutorial, si vous avez besoin de plus de détails.
Constantes et variables
Nous commençons par définir deux constantes : tempPin et fanPin. tempPin représente le numéro de broche auquel le capteur DHT11 est connecté, et fanPin représente le numéro de broche auquel le ventilateur est connecté.
const int tempPin = 2; const int fanPin = 3;
Ensuite, nous créons une instance de la bibliothèque DHT et l’initialisons avec la broche tempPin et le type de capteur, ici DHT11. Si vous souhaitez utiliser un DHT21 ou DHT22 à la place, changez simplement la constante.
// Sensor types: DHT11, DHT22, DHT21 DHT dht = DHT(tempPin, DHT11);
Fonction setup
Dans la fonction setup(), nous initialisons le capteur DHT avec la fonction dht.begin(). Nous définissons aussi la broche fanPin comme sortie avec la fonction pinMode().
void setup() {
dht.begin();
pinMode(fanPin , OUTPUT);
}
Fonction loop
Dans la fonction loop(), nous lisons d’abord la température en degrés Celsius depuis le capteur DHT avec la fonction dht.readTemperature(). Si vous préférez utiliser Fahrenheit, appelez simplement dht.readTemperature(true).
Si le capteur ne peut pas lire la température, il renvoie Not-a-Number (NaN). Dans ce cas, nous quittons la fonction avec l’instruction return.
Sinon, nous convertissons la valeur de température de la plage 20 à 40 degrés Celsius vers une plage de 0 à 255. Cela servira à contrôler la vitesse du ventilateur. Cela signifie qu’à 20 degrés Celsius, la vitesse du ventilateur est 0, mais au-dessus de 20 degrés, le ventilateur commence à tourner très lentement jusqu’à atteindre sa vitesse maximale (255) à 40 degrés Celsius.
Pour de nombreuses applications, vous voudrez peut-être modifier ce comportement et démarrer le ventilateur à une vitesse moyenne dès qu’un certain seuil de température est atteint, car les très basses vitesses ont presque aucun effet de refroidissement et le ventilateur pourrait ne même pas démarrer pour de petites valeurs PWM.
float temp = dht.readTemperature(); if (isnan(temp)) return; int fanSpeed = map(temp, 20, 40, 0, 255);
Notez que la fonction map() ne garantit pas que fanSpeed sera dans la plage autorisée [0..255]. Par exemple, pour des températures inférieures à 20 degrés Celsius, elle renverra des valeurs négatives !
Nous ne voulons pas cela, donc nous utilisons la fonction constrain() pour contraindre la valeur de fanSpeed à la plage 0 à 255.
fanSpeed = constrain(fanSpeed, 0, 255);
Enfin, nous utilisons la fonction analogWrite() pour régler la vitesse du ventilateur en fournissant la broche fanPin et la valeur de vitesse. Comme mentionné, pour de petites valeurs PWM (fanSpeed < 10), le ventilateur pourrait ne pas démarrer. Testez avec votre ventilateur et trouvez une valeur minimale adaptée à votre application. Peut-être voulez-vous démarrer le ventilateur à une vitesse de 100 lorsque la température dépasse 20 degrés Celsius.
analogWrite(fanPin, fanSpeed);
Enfin, nous ajoutons un délai de 5 secondes avec la fonction delay() avant que la boucle ne recommence. Nous échantillonnons donc la température ambiante toutes les 5 secondes et ajustons la vitesse du ventilateur en conséquence.
delay(5000);
Et voilà un ventilateur contrôlé par la température !
Conclusions
Dans cet article, nous avons appris comment contrôler un ventilateur avec Arduino. Nous avons commencé par discuter des pièces nécessaires pour ce projet, incluant une carte Arduino, un ventilateur et divers composants électroniques comme des relais, MOSFET et capteurs de température.
Ensuite, nous avons exploré les différents types de ventilateurs disponibles sur le marché, tels que les ventilateurs AC et DC. Nous avons discuté des avantages et inconvénients de chaque type et comment ils peuvent être utilisés dans différents scénarios.
Nous avons ensuite approfondi le contrôle des ventilateurs DC, en particulier les configurations 2, 3 et 4 fils. Nous avons expliqué comment chaque fil est utilisé pour différentes fonctions, comme l’alimentation, la masse, le signal tachymètre et le contrôle PWM.
Pour illustrer, nous avons présenté diverses méthodes de contrôle des ventilateurs avec Arduino. Nous avons montré comment commuter un ventilateur AC ou DC avec un relais.
De plus, nous avons exploré des techniques plus avancées comme le contrôle de la vitesse du ventilateur via PWM avec un MOSFET. Nous avons expliqué comment la modulation de largeur d’impulsion peut être utilisée pour varier la vitesse du ventilateur, permettant un contrôle précis selon les besoins de refroidissement.
Enfin, nous avons présenté un exemple de contrôle de la vitesse du ventilateur basé sur la température ambiante avec un MOSFET. Cette application est utile dans des environnements où la régulation thermique est cruciale, comme dans des boîtiers électroniques ou des salles serveurs.
Nous espérons que cet article vous a apporté des informations précieuses et de l’inspiration pour vos projets de contrôle de ventilateurs. N’hésitez pas à expérimenter et explorer d’autres possibilités avec Arduino et les ventilateurs !
Questions fréquemment posées
Voici quelques questions fréquemment posées sur le contrôle d’un ventilateur avec Arduino :
Q : Quelle est la différence entre les ventilateurs AC et DC ?
R : La principale différence entre les ventilateurs AC et DC est le type d’alimentation qu’ils nécessitent. Les ventilateurs AC sont conçus pour fonctionner sur le réseau électrique domestique, qui est un courant alternatif. Les ventilateurs DC, en revanche, sont conçus pour fonctionner sur une source de courant continu, comme une batterie ou une alimentation.
Q : Comment commuter un ventilateur avec un relais ?
R : Pour commuter un ventilateur avec un relais, vous devez connecter le module relais à l’Arduino. L’Arduino peut alors contrôler le relais, qui à son tour allume ou éteint le ventilateur. Vous devrez connecter la broche d’entrée du relais à une des broches numériques de l’Arduino, et les broches de sortie du relais à l’alimentation du ventilateur.
Q : Comment contrôler la vitesse d’un ventilateur avec Arduino ?
R : Pour contrôler la vitesse d’un ventilateur avec Arduino, vous pouvez utiliser un module MOSFET. En connectant le module MOSFET à l’Arduino, vous pouvez varier la tension fournie au ventilateur, contrôlant ainsi sa vitesse. Cela peut être réalisé en utilisant des signaux de modulation de largeur d’impulsion (PWM) générés par l’Arduino.
Q : Puis-je lire le signal de vitesse d’un ventilateur avec Arduino ?
R : Oui, vous pouvez lire le signal de vitesse d’un ventilateur avec Arduino. Certains ventilateurs ont une sortie tachymètre qui fournit un signal d’impulsion proportionnel à la vitesse du ventilateur. En connectant ce signal à une des broches numériques de l’Arduino, vous pouvez mesurer la vitesse du ventilateur. Si le ventilateur n’a pas de fil de vitesse, vous pouvez construire votre propre moniteur de vitesse. Voir notre tutoriel Build Arduino Tachometer Using A3144 Hall Effect Sensor.
Q : Puis-je contrôler la vitesse du ventilateur en fonction de la température ambiante ?
R : Oui, vous pouvez contrôler la vitesse du ventilateur en fonction de la température ambiante avec Arduino. En connectant un capteur de température à l’Arduino, vous pouvez mesurer la température ambiante et ajuster la vitesse du ventilateur en conséquence.
Q : Puis-je contrôler la vitesse du ventilateur en fonction de la lumière ambiante ?
R : Oui, vous pouvez contrôler la vitesse du ventilateur en fonction de la lumière ambiante. En connectant un capteur de lumière dans un montage diviseur de tension à l’Arduino, vous pouvez mesurer la luminosité ambiante et ajuster la vitesse du ventilateur en conséquence. Voici le circuit de base pour mesurer la lumière.
Pour plus de détails, consultez notre tutoriel How to detect light using an Arduino.
Q : Puis-je utiliser un capteur de température DS18B20 à la place d’un DHT11 ?
Oui, vous pouvez, mais vous devrez modifier le code. Voici un court exemple pour lire les données de température du DS18B20 :
// https://github.com/matmunk/DS18B20
#include "DS18B20.h"
const int tempPin = 2;
DS18B20 ds(tempPin);
void setup() {
Serial.begin(9600);
}
void loop() {
while (ds.selectNext()) {
float temp = ds.getTempC();
...
delay(1000);
}
}
Q : Puis-je contrôler le sens de rotation d’un ventilateur avec Arduino ?
Cela dépend. Les ventilateurs sans balais et les ventilateurs AC tournent généralement dans un seul sens. Inverser la polarité pour changer le sens ne fonctionne pas avec ces ventilateurs. En revanche, si le ventilateur utilise un moteur DC à balais simple, vous pouvez contrôler le sens. Vous aurez besoin d’un pont en H ou d’un pilote moteur pour cela.
Q : Puis-je contrôler plusieurs ventilateurs avec Arduino ?
Oui, vous pouvez contrôler plusieurs ventilateurs avec Arduino en utilisant des composants électroniques appropriés comme des relais ou des MOSFET. Chaque ventilateur nécessitera son propre circuit de contrôle, mais tous peuvent être commandés par une seule carte Arduino.
Ce ne sont que quelques-unes des questions fréquemment posées sur le contrôle d’un ventilateur avec Arduino. Si vous avez d’autres questions, n’hésitez pas à les poser dans la section commentaires ci-dessous.
