ARDUINO : pilotage de ventilateurs

ARDUINO : pilotage de ventilateurs

Possédant une alimentation MATRIX MPS-3003D, j'ai le projet d'équiper son ventilateur beaucoup trop bruyant d'une régulation de vitesse.
Dans cet article nous allons essayer de piloter un ventilateur ou un ventirad 12V de PC en PWM à l'aide d'un ARDUINO.

Il existe trois types principaux de ventilateurs :

• les ventilateurs 2 broches
• les ventilateurs 3 broches
• les ventilateurs 4 broches

1. Nombre de broches

Les ventilateurs 2 broches possèdent une broche GND et une broche 12V.

Les ventilateurs 3 broches possèdent une broche GND, une broche 12V et une broche tachymètre.

Les ventilateurs 4 broches possèdent une broche GND, une broche 12V, une broche tachymètre et une broche PWM.

La compatibilité est ascendante, c'est à dire que le brochage de ces ventilateurs avec le temps, au fur et à mesure de l'avancement des technologies, s'est adapté :

• broche 1 : GND
• broche 2 : +12V
• broche 3 : tachymètre
• broche 4 : PWM

On pourra donc brancher un ventilateur 2 broches ou 3 broches sur un connecteur 4 broches sans problème.

Le tachymètre est en général un capteur à effet hall fournissant une impulsion par tour de moteur.

1.1. Ventilateur 2 broches

On pourra faire varier la vitesse d'un ventilateur 2 broches en lui fournissant soit une tension continue variable soit une tension PWM.
L'électronique de pilotage devra supporter la puissance du ventilateur.
En général ce type de ventilateur accepte de démarrer à partir de 5V.

1.2. Ventilateur 3 broches

On pourra faire varier la vitesse d'un ventilateur 3 broches de la même façon qu'avec un ventilateur 2 broches. Le comportement est le même.

Si le pilotage est réalisé en PWM l'alimentation du tachymètre sera hachée à la même fréquence que celui-ci, et le signal produit par le capteur sera également haché, ce qui le rendra donc difficilement exploitable, sauf à sa vitesse maximale.

La seule solution avec un ventilateur 3 fils, si l'on veut exploiter l'information du tachymètre, est de l'alimenter à l'aide d'une source de tension continue et variable, un régulateur ajustable par exemple, dont on fera varier la tension de sortie à l'aide d'un amplificateur opérationnel et d'un microcontrôleur.
On peut s'inspirer de cet article :
https://www.edn.com/design/analog/4363990/Control-an-LM317T-with-a-PWM-signal

1.3. Ventilateur 4 broches

Un ventilateur 4 broches est pilotable en vitesse par une broche de commande PWM et possède sa propre électronique de puissance.
L'électronique de pilotage n'aura pas besoin de supporter la puissance du ventilateur, c'est à dire que l'on pourra relier la broche de commande PWM directement à la sortie d'un microcontrôleur.
L'information du tachymètre sera toujours facilement exploitable, car l'alimentation 12V est permanente.

1.4. Tensions et courants

Sauf exception les ventilateurs de PC fonctionnent sous 12V.

La tension issue du tachymètre est souvent de 12V, c'est à dire qu'elle ne sera pas directement acceptable par l'entrée d'un microcontrôleur. Il faudra limiter cette tension à un voltage acceptable par celui-ci.
Il est souvent indispensable d'ajouter une résistance de charge entre la broche 12V et la sortie tachymètre pour obtenir un signal.

La tension maximale de l'entrée PWM d'un ventilateur 4 broches est en général de 3.3V.
Si la broche PWM est laissée en l'air un ventilateur 4 broches tourne à sa vitesse maximale. On obtient donc le comportement d'un ventilateur 2 ou 3 broches.
Cela veut dire que lorsque notre microcontrôleur va démarrer le ventilateur sera lancé à plein régime.
On peut éviter cela en ajoutant une résistance de 10KΩ entre broche PWM et GND. Comme nous devons réduire la tension PWM, nous utiliserons un pont diviseur 50% : 10KΩ + 10KΩ, ce qui permettra d'assurer les deux fonctions.

La puissance d'un ventilateur de PC est faible : quelques watts. Un gros ventilateur de 120mm consommera environ 200mA, soit 2.4W.
Un petit transistor 2N2222 supporte 800mA et suffira amplement à piloter un ventilateur 2 broches ou 3 broches.
S'il est correctement saturé sa tension Vce sera de 50mV au maximum. La puissance dissipée sera de 0.05V * 0.2A = 10mW.
On peut également utiliser un petit MOSFET, un BS170 par exemple. Voir ici :
https://riton-duino.blogspot.com/2018/08/alimenter-un-relais-transistor.html
Paragraphe 4. Le transistor unipolaire

1.5. PWM

Un ventilateur 4 broches fonctionne normalement avec une fréquence PWM de 25KHz.
Avec un ARDUINO, nous sommes limités par le nombre de rapports de division possible des timers utilisés. Nous utiliserons plutôt une fréquence de 31KHz. La broche utilisée devra être capable de générer cette fréquence. Avec un ATMEGA328, les broches D3, D9, D10 et D11 conviennent. Avec un ATMEGA2560 le choix est plus large.

Le sujet est expliqué ici : https://arduinoinfo.mywikis.net/wiki/Arduino-PWM-Frequency

Cette fréquence n'est pas une obligation, c'est une norme. Techniquement le ventilateur fonctionnera même à la fréquence par défaut du PWM de la librairie ARDUINO (500Hz, ou 1kHz pour les pins D5 et D6).
Un ventilateur 4 broches fonctionnera à 500Hz, un ventilateur à 2 ou 3 broches produira pratiquement à coup sûr un sifflement audible.
Les deux modèles 4 broches Freezer et Scythe que j'ai essayé fonctionnent aussi bien à 500Hz qu'à 31KHz, par contre les quelques modèles 2 broches et 3 broches que j'ai testé sifflent tous à 500Hz.

Un ventilateur 4 broches tourne même avec un rapport PWM de 0%. Le circuit interne au ventilateur le fait simplement tourner à sa vitesse minimale, ce qui est plutôt intéressant.
Certains modèles ne parviennent cependant pas à démarrer avec un facteur de PWM faible, mais ils sont capables de tourner avec un rapport de 0% après avoir été lancés avec un rapport PWM plus élevé.
Je n'ai pas testé un nombre suffisant de ventilateurs pour affirmer que ce sera le cas avec tous les modèles.

Cela ne sera pas le cas avec un ventilateur 2 ou 3 broches. Nous devrons gérer nous même cet aspect.
Pas mal de ventilateurs commencent à tourner avec un rapport PWM de 40% et s'arrêtent si le rapport PWM descend en dessous de 30%.
Le logiciel devra éviter d'utiliser un rapport PWM inférieur, sauf 0% bien entendu pour couper le ventilateur.
Chaque ventilateur est différent, il faudra expérimenter. Le sketch fourni en fin d'article peut aider à déterminer ces valeurs minimales.

2. le schéma

2.1. Ventilateur 2 ou 3 broches

Comme avec toute charge inductive le transistor est protégé par une diode de roue libre.

La sortie du tachymètre d'un ventilateur 3 broches n'est pas exploitable car elle serait hachée par le signal PWM.

2.2. Ventilateur 4 broches

Note : ici la tension issue du tachymètre est abaissée à 4.3V à l'aide d'une diode zener, ce qui permet de protéger l'entrée de l'ARDUINO.

Cependant, la sortie tachymètre de pas mal de ventilateurs est en collecteur ouvert. La diode zener est donc inutile dans ce cas. Une simple résistance de pull-up au +5V (attention, pas au 12V !) suffira dans la majeure partie des cas.

3. Le code

Le code ci-dessous permet de piloter des ventilateurs 2, 3 ou 4 broches en PWM sur la broche D3. Il suffit de changer la valeur de la constante FAN_WIRES.
La broche D2 est utilisée en source d'interruption pour mesurer la vitesse (ventilateur à 4 broches uniquement). La vitesse est mesurée toutes les secondes.

#define FAN_WIRES   4
#define PWM_PIN     3
#define SENSOR_PIN  2

#if FAN_WIRES == 4
volatile unsigned int revs;
#endif

void setup()
{
  Serial.begin(115200);
  Serial.println("FAN CONTROL");
  // prescaller for 31.372KHz
  TCCR2B &= B11111000;
  TCCR2B |= (0 << CS22) | (0 << CS21) | (1 << CS20);
  digitalWrite(PWM_PIN, LOW);
  pinMode(PWM_PIN, OUTPUT);
#if FAN_WIRES == 4
  attachInterrupt(digitalPinToInterrupt(SENSOR_PIN), interruptHandler, FALLING);
#endif
}

void loop()
{
  int pwm, pwmGpio;

  for (pwm = 0 ; pwm <= 100 ; pwm += 10) {
    Serial.print(pwm);
    Serial.print("%: (");
    pwmGpio = pwm * 2.5;
    Serial.print(pwmGpio);
    Serial.print(") ");
    analogWrite(PWM_PIN, pwmGpio);
    delay(2000);
#if FAN_WIRES == 4
    Serial.print(" speed = "); Serial.println(getSpeed());
#else
    Serial.println();
#endif
  }
  for (pwm = 90 ; pwm >= 0 ; pwm -= 10) {
    Serial.print(pwm);
    Serial.print("%: (");
    pwmGpio = pwm * 2.5;
    Serial.print(pwmGpio);
    Serial.print(") ");
    analogWrite(PWM_PIN, pwmGpio);
    delay(2000);
#if FAN_WIRES == 4
    Serial.print(" speed = "); Serial.println(getSpeed());
#else
    Serial.println();
#endif
  }
}

#if FAN_WIRES == 4

unsigned int getSpeed()
{
  static unsigned long lastMillis;
  static unsigned int lastRead;
  unsigned long elapsed = millis() - lastMillis;
  if (elapsed > 1000) {
    detachInterrupt(digitalPinToInterrupt(SENSOR_PIN));
    double correctionFactor = 1000.0 / elapsed;
    lastRead = correctionFactor * revs / 2 * 60;
    revs = 0;
    lastMillis = millis();
    attachInterrupt(digitalPinToInterrupt(SENSOR_PIN), interruptHandler, FALLING);
    return lastRead;
  }
}

void interruptHandler(void)
{
  revs++;
}

#endif

4. Conclusion

Ce n'est pas la première fois que je pilote des ventilateurs 2 broches et 3 broches en PWM, mais ce petit sujet a été l'occasion pour moi d'expérimenter les ventilateurs 4 broches et de mettre en évidence certaines comportements inattendus de ceux-ci, bien plus intelligents qu'il n'y paraît.


Cordialement
Henri