[Tuto] Arduino et Mosfet

Posté sur: nov. 1, 2022

Catégories: Arduino

Auteur: Thomas D

Pour commander un moteur avec un Arduino, il faut un dispositif capable de générer une intensité suffisante. Les broches de l’Arduino peuvent envoyer un courant de 40mA maxi ce qui est généralement trop peu pour entraîner un moteur.

On peut bien sûr se procurer des shields ou des modules moteurs tout faits qui fonctionnent très bien, ou utiliser un DFRduino qui combine un Arduino et un module moteur.

L’objet de ce post est de montrer qu’on peut aussi utiliser un type de transistor particulier, un MOSFET, qui permet de mettre en marche et de faire varier la vitesse de moteurs à courant continu.

Exemple d'utilisation avec un IRF540

Ici on a utilisé un MOSFET de type IRF540N ; il en existe de très nombreux types, il ne sont pas tous compatibles avec l’Arduino. En particulier, il faut que la valeur Vgs (Gate Threshold voltage) soit en gros autour de 2 ou 4V. Il existe des Mosfet dits logiques avec des valeurs de Vgs basses (entre 1 et 2V) comme le IRL540N qui fonctionne ausi très bien. D’autres Mosfet, enfin, ont des valeurs Vgs trop élevées que ne pourrait pas atteindre directement en sortie d’une broche Arduino (Maxi 5V).

Autre paramètre important, la valeur Rds(on) que l’on souhaite basse , elle conditionne la chaleur dégagée par le composant en utilisation. Ici on a Rds=0,044 ohms, c’est pas mal mais on trouve mieux.

Le principe du fonctionnement de ce type de transistor est que lorsque la tension de la Gate atteint une valeur suffisante, le courant passe entre le Drain et la Source. (d’autres types de transistors sont commandés en courant, le Mosfet est commandé en tension).

Il existe aussi de très nombreux types de transistors utilisables qui ne sont pas des MOSFET mais ils semblent moins performants pour ce type d’application (chute de tension, chaleur dégagée). Voici un schéma de branchement pour un Mosfet de type N – Channel :


Ces Mosfet sont de braves transistors capables de supporter des intensités étonnantes (33A pour ce modèle !). Mais, attention, si les intensités deviennent importantes, il faut s’équiper d’un radiateur sous peine de destruction du transistor. D’autre part, pour de grosses intensités, une breadboard n’est pas une bonne solution (maxi raisonnable 1A).

Les Mosfet sont costauds ne coûtent pas cher mais sont vulnérables à l’électricité statique.

On peut, avec un potentiomètre sur une entrée analogique et une Pin capable d’envoyer du PWM reliée à la Gate, obtenir simplement une variation de vitesse d’un moteur à courant continu.

Par contre on ne peut pas gérer l’inversion de sens avec ce simple Mosfet. (une solution est de se tourner vers un pont en H). Si le but est simplement de mettre en marche est d’arrêter mais pas de faire varier la vitesse, un relais peut être une solution plus simple.

On peut bien sûr alimenter d’autres dispositifs gourmands en intensité (lampes, bandeaux de LED, solénoïdes…) avec ce montage. De même, imaginer plusieurs potentiomètres commandant la vitesse de rotation de plusieurs moteurs avec un seul Arduino et plusieurs Mosfet ne semble pas compliqué.

Programmation d'une commande moteur répondant à un potentiomètre

Voilà un exemple de code pour un potentiomètre commandant la vitesse de rotation d’un moteur :

  // Controle de vitesse d'un moteur en pwm
// avec un Arduino et un Mofset IRF540N
// voir aussi http://bildr.org/2012/03/rfp30n06le-arduino/


int motorPin = 3; // Controle de vitesse PWM vers la gate du Mofset
int potarPin=0; // on branche un potentiomètre sur la PIn A0
int sensorValue=0; // la valeur entre 0 et 1023 déduite de la position du potentiomètre
int outputValue=0; // la valeur entre 0 et 255 que l'on va utiliser pour régler la vitesse du moteur

// Executee une seule fois

void setup() {
// initialiser la communication serie
Serial.begin(19200);
pinMode(motorPin, OUTPUT); // motorPin est utilisee en sortie
}

// executee en boucle
void loop() {
// lire la valeur en entrée de la Pin A0
sensorValue = analogRead(potarPin);
// afficher sur le moniteur série la valeur lue, pas obligatoire mais toujours intéressant
Serial.println(sensorValue);
// conversion de la valeur sensorvalue (qui va de 0 à 1023) en une valeur entre 0 et 255, outputvalue
outputValue = map(sensorValue, 0, 1023, 0, 255);
// outputvalue permet de controler la vitesse du moteur
analogWrite(motorPin,outputValue ); // valeur de 0 à 255
delay(100);
}

La résistance de 10 kOhms est importante, elle est du type pull-down : elle ramène la Pin à l’état bas quand la Pin n’est pas alimentée. (risque sinon que la Pin soit dans un état incertain …).

La diode est de type 1N4007 (elle supporte 1000v et 1A) ; placée aux bornes du moteur, elle protège le transistor des tensions importantes qui naissent quand le courant est coupé, elle est indispensable.

Ici j’ai branché deux moteurs pour charger un peu la bête. Le transistor chauffe vraiment peu.(L’intensité consommée par les moteurs est modeste environ 250mA au total).

Remarque : sur le web on trouve plusieurs fois la suggestion de placer une petite résistance entre la Pin en Output de l’Arduino et la Gate du Mosfet. On trouve également plusieurs fois la suggestion… de ne pas utiliser cette petite résistance. Perplexité …

Du coup, j’ai essayé avec une 220 ohms (ça se voit sur la photo). Si on veut dépasser 500 mA en sortie, le transistor chauffe énormément et on ne récupère que peu de volts et d’intensité pour le moteur.

En résumé, ne pas se casser la tête et, au moins pour ce Mosfet, se conformer au schéma en début d’article avec pour seule résistance la 10 KOhms en pull-down ce qui fonctionne très bien.

laissez un commentaire

Se connecter