arduino
PWM - Modulation de la largeur d'impulsion

Contrôler un moteur à courant continu via le port série en utilisant PWM

Dans cet exemple, nous visons à accomplir l’une des tâches les plus courantes: un petit moteur à courant continu est installé, comment puis-je utiliser mon Arduino pour le contrôler? Facile, avec communication PWM et série, en utilisant la fonction analogWrite() et la bibliothèque Serial .

Les bases

La modulation de largeur d'impulsion ou PWM en abrégé est une technique permettant d'imiter des signaux analogiques en utilisant une sortie numérique. Comment cela marche-t-il? En utilisant un train d'impulsions dont la relation D (rapport cyclique) entre le temps à haut niveau (numérique 1, généralement 5V) et le temps à bas niveau (numérique 0, 0V) dans chaque période peut être modifiée pour produire une tension moyenne entre ces deux niveaux:

En utilisant la fonction analogWrite(pin,value) Arduino analogWrite(pin,value) nous pouvons faire varier la value du rapport cyclique de la sortie de la pin . Notez que la pin doit être mise en mode de sortie et que la value doit être comprise entre 0 (0V) et 255 (5V). Toute valeur intermédiaire simulera une sortie analogique intermédiaire proportionnelle.

Cependant, la fonction des signaux analogiques est généralement liée au contrôle de systèmes mécaniques qui nécessitent plus de tension et de courant que la carte Arduino seule. Dans cet exemple, nous allons apprendre à amplifier les capacités PWM d'Arduino.

Pour cela, une diode MOSFET est utilisée. Essentiellement, cette diode agit comme un commutateur. Il permet ou interrompt le flux électrique entre ses bornes de source et de drain . Mais au lieu d'un commutateur mécanique, il dispose d'un troisième terminal appelé gate . Un très petit courant (<1mA) "ouvrira" cette porte et permettra au courant de circuler. Ceci est très pratique, car nous pouvons envoyer la sortie PWM d'Arduino à cette porte, créant ainsi un autre train d'impulsions PWM avec le même rapport cyclique à travers le MOSFET, ce qui permet des tensions et des courants qui pourraient détruire l'Arduino.

Bill of materials: de quoi avez-vous besoin pour construire cet exemple?

• Diode MOSFET: par exemple, le populaire BUZ11
• Diode de protection pour le moteur: Schottky SB320
• Résistance: rien 10K ~ 1M Ohm
• Moteur: Un petit moteur typique (un moteur typique peut être 12V)
• Une source d'alimentation compatible avec le moteur que vous avez sélectionné
• Une planche à pain
• Câbles colorés!
• Un Arduino, mais tu le savais déjà.

La construction

Mettez tout ensemble! Alimentez les rails de la maquette et placez-y la diode MOSFET. Connectez le moteur entre le rail positif et le drain MOSFET. Connecter la diode de protection de la même manière: entre le drain MOSFET et le rail positif. Connectez la source du MOSFET au rail de terre commun. Enfin, connectez la broche PWM (nous utilisons la broche 10 dans cet exemple) à la grille du MOSFET et également à la terre commune via la résistance (nous avons besoin d'un courant très faible!).

Voici un exemple de l'apparence de cette construction. Si vous préférez un schéma, en voici un.

Le code

Maintenant, nous pouvons connecter l'Arduino à un ordinateur, télécharger le code et contrôler le moteur en envoyant des valeurs via la communication série. Rappelons que ces valeurs doivent être des entiers compris entre 0 et 255. Le code réel de cet exemple est très simple. Une explication est fournie dans chaque ligne.

int in = 0;                   // Variable to store the desired value
byte pinOut = 10;             // PWM output pin

void setup() {                // This executes once
  Serial.begin(9600);             // Initialize serial port
  pinMode(pinOut, OUTPUT);        // Prepare output pin
}

void loop() {                 // This loops continuously
  if(Serial.available()){         // Check if there's data
    in = Serial.read();           // Read said data into the variable "in"
    analogWrite(pinOut, in);      // Pass the value of "in" to the pin
  }
}

Et c'est tout! Vous pouvez désormais utiliser les fonctionnalités PWM d'Arduino pour contrôler les applications qui nécessitent des signaux analogiques, même lorsque les besoins en énergie dépassent les limites de la carte.

PWM avec un TLC5940

Le TLC5940 est un élément pratique à avoir lorsque vous manquez de ports PWM sur l’Arduino. Il dispose de 16 canaux, chacun individuellement contrôlable avec 12 bits de résolution (0-4095). Une bibliothèque existante est disponible à l' adresse http://playground.arduino.cc/Learning/TLC5940 . Il est utile pour contrôler plusieurs servos ou LED RVB. N'oubliez pas que les LED doivent être des anodes communes pour fonctionner. De plus, les puces peuvent être chaînées en série, permettant encore plus de ports PWM.

Exemple:

// Include the library
#include <Tlc5940.h>

void setup() {
    // Initialize
    Tlc.init();
    Tlc.clear(); 
}

unsigned int level = 0;
void loop() {
    // Set all 16 outputs to same value
    for (int i = 0; i < 16; i++) {
        Tlc.set(i, level);
    }
    level = (level + 1) % 4096;
    // Tell the library to send the values to the chip
    Tlc.update();
    delay(10);
}