Roue multicolore motorisée

Mettre en mouvement des choses consomme beaucoup d'énergie. Les moteurs nécessitent généralement plus de courant que ce que l'Arduino peut fournir. Certains moteurs nécessitent aussi une tension plus élevée. Pour commencer à tourner, en particulier quand il a une charge lourde attachée, un moteur consommera autant de courant que possible. L'Arduino ne peut fournir que 40 milliampères (mA) à partir de ses broches numériques, beaucoup moins que ce dont la plupart des moteurs ont besoin pour travailler.

1. Branchez l'alimentation et la masse à votre platine d'expérimentation à partir de l'Arduino.
2. Ajoutez un bouton poussoir à la carte, en connectant un côté à l'alimentation et l'autre côté à la broche numérique 2 de l'Arduino. Ajouter une résistance « pull-down » de 10 kΩ entre la masse et la broche de l'interrupteur connectée à l'Arduino.
3. Lorsque vous utilisez des circuits avec différentes tensions, vous devez connecter leur masse ensemble pour créer une masse commune. Branchez le connecteur de pile 9 V à la platine d'expérimentation. Connectez la masse de la pile (pôle -) à la masse de votre Arduino sur la platine d'expérimentation avec un cavalier, comme le montre la figure du circuit ci-dessus. Ensuite, branchez l'autre borne de la pile (pôle +) au 9 V sur la platine d'expérimentation.
4. Placez le transistor sur la carte. Placez le composant de sorte que la languette métallique soit face à vous, à l'opposé de l'Arduino. Connectez la broche numérique 9 à la broche à gauche sur le transistor. Cette borne est appelée la Grille. Une variation de la tension sur la Grille assure une liaison entre les deux autres broches. Connectez une extrémité du moteur à la broche intermédiaire du transistor. Cette borne est appelée le Drain. Lorsque l'Arduino active le transistor en appliquant une tension sur la Grille, cette borne sera connectée à la troisième borne, appelée la Source. Connectez la source à la masse.
5. Ensuite, connectez les fils d'alimentation du moteur au moteur à la platine d'expérimentation. Le dernier composant à ajouter est la diode. La diode est un composant polarisé, il ne peut être monté que dans un sens dans le circuit. Remarquons que la diode possède une bande à une extrémité. Cette extrémité est la broche négative, ou cathode, de la diode. L'autre extrémité est la broche positive, ou anode. Connecter l'anode de la diode à la masse du moteur et la cathode de la diode à l'alimentation 9 V du moteur. Voir la figure du circuit ci-dessus. Cela peut sembler être à l'envers, et en fait, ça l'est. La diode servira à empêcher que la tension inverse générée par le moteur retourne dans votre circuit. Rappelez-vous, la tension inverse circule dans le sens inverse de la tension que vous fournissez.

Les LEDs sont aussi des diodes, au cas où vous vous demanderiez pourquoi leurs broches sont aussi appelées anodes et cathodes. Il y a quantité de types de diodes, mais elles partagent toutes la même caractéristique. Elles permettent au courant de circuler de l'anode vers la cathode, mais pas l'inverse.

• Définissez les constantes et les variables

Avant tout, définissez les constantes correspondant à la broche d'état de l'interrupteur switchPin (interrupteurBroche) et celle de commande du moteur motorPin (moteurBroche), ainsi qu'une variable switchState (interrupteurEtat) qui stockera l'état de l'interrupteur.

const int switchPin   = 2;
const int motorPin    = 9;
      int switchState = 0;

• Déclarer le mode d'utilisation des broches

Dans le setup(), déclarer le pinMode() des broches du moteur (OUTPUT) et de l'interrupteur (INPUT).

void setup() {
    pinMode(switchPin, INPUT);
    pinMode(motorPin, OUTPUT);
}

• Lire l'entrée, et placer la sortie à l'état haut si l'interrupteur est appuyé

La fonction loop() est simple. Vérifier l'état de la broche switchPin avec digitalRead().

Si l'interrupteur est appuyé, mettre la broche motorPin à l'état haut (HIGH). S'il n'est pas appuyé, mettre la broche à l'état bas (LOW). À l'état HIGH, le transistor est activé, on dit qu'il est passant, le circuit alimentant le moteur est fermé, donc il tourne. À l'état LOW, le transistor n'est pas activé, on dit qu'il est bloquant, le circuit alimentant le moteur est ouvert, il ne tourne donc pas.

void loop() {
    switchState = digitalRead(switchPin);
    if (switchState == HIGH) {
        digitalWrite(motorPin, HIGH);
    } else {
        digitalWrite(motorPin, LOW);
    }
}

Les moteurs ont une valeur optimale de leur tension de fonctionnement. Ils pourront fonctionner dès que la tension atteint 50 % de cette valeur et jusqu'à 50 % au-delà de cette valeur. Si vous faites varier la tension, vous pourrez modifier la vitesse à laquelle le moteur tourne. Cependant, ne le faites pas varier au-delà de la limite, ou vous pourriez griller votre moteur. Lorsqu'ils sont pilotés par des microcontrôleurs, les moteurs nécessitent des dispositions particulières. Habituellement, un microcontrôleur ne peut pas fournir assez de courant et/ou de tension pour alimenter directement un moteur. À cause de cela, vous devez utiliser des transistors pour faire l'interface entre les deux. C'est aussi une bonne chose d'utiliser des diodes pour éviter tout dommage au circuit.

Les transistors sont des composants statiques, c'est-à-dire qu'ils n'ont pas de parties mobiles. Grâce à cette caractéristique, vous pouvez les activer et les éteindre très rapidement. Essayez de brancher un potentiomètre à une entrée analogique et d'utiliser la valeur lue pour piloter la broche PWM qui pilote le transistor. Que pensez-vous qu'il arrivera à la vitesse de rotation du moteur si vous faites varier sa tension d'alimentation ? Avec les illustrations sur votre disque tournant, pouvez-vous obtenir différents effets visuels ?

Assemblez le support CD comme illustré à l'étape 1, et fixez-le au moteur comme illustré à l'étape 2. Fixez la forme prédécoupée à un CD comme indiqué à l'étape 3. Clipsez le CD au support et sécurisez le tout avec une pointe de colle. Laissez sécher avant de continuer. Branchez une pile 9 V au connecteur de pile 9 V. Alimentez l'Arduino via le port USB. Lorsque vous appuierez sur l'interrupteur situé sur la platine d'expérimentation, le moteur se mettra à tourner très rapidement.

	1. Insérez l'élément C dans l'élément B, et enfichez doucement l'élément D par-dessus.
2. Insérez l'axe du moteur dans le trou situé à l'arrière de l'élément B.
	3. Placez la forme prédécoupée en papier sur un CD et rabattez les volets vers l'arrière pour solidariser l'ensemble.
4. Fixez le CD à la croix formée par les éléments C et D. Utilisez une pointe de colle pour empêcher le CD de se détacher.

Le moteur tournant très rapidement, vous pourrez probablement aussi fabriquer une grande hélice. Attention cependant à ce qu'elle ne se détache pas et blesse quelqu'un. Essayez différentes formes et illustrations et comparez les effets visuels obtenus.

1. Ajoutez un potentiomètre sur la plaque d'expérimentation, et connectez une des broches sur le côté à la masse et celle de l'autre côté au +5 V. Un potentiomètre est en quelque sorte un pont diviseur de tension. Lorsque vous tournez le bouton, vous modifiez le ratio de tension entre la broche centrale du potentiomètre et l'alimentation. Vous pouvez lire cette modification sur une entrée analogique. Connectez la broche centrale à la broche de l'entrée analogique A0. Cela permettra de contrôler la vitesse de rotation du moteur.
   Placez un condensateur de 100 µF entre les broches du potentiomètre reliées à la masse et l'alimentation. Ce condensateur est appelé « condensateur de découplage » parce qu'il réduit, ou découple, les modifications causées par les composants du reste du circuit. Soyez très prudent et assurez-vous que vous avez connecté la cathode à la masse (c'est le côté avec une bande noire) et l'anode à l'alimentation. Si vous mettez le condensateur à l'envers, il pourrait exploser.

• Définissez les constantes et les variables

Le programme est similaire au programme précédent, vous allez simplement modifier l'utilisation de l'interrupteur et ajouter le pilotage de la vitesse du moteur via le potentiomètre.

Le moteur restera allumé ou éteint entre deux pressions sur l'interrupteur permettant de libérer vos mains pour manipuler le potentiomètre.

Le potentiomètre permettra de mettre en marche le moteur à partir d'une valeur limite permettant de délivrer une tension minimale au moteur, compatible avec sa tension minimale de démarrage.

Le programme permet de calibrer les positions « Min » et « Max » du potentiomètre pendant cinq secondes après le démarrage du montage. La LED « L » reste allumée pendant ce laps de temps.

Enfin, les valeurs lues sur les broches du potentiomètre et la valeur correspondante transmise au moteur sont affichées dans la console Série.

Avant tout, définissez les constantes correspondant à la broche d'état de l'interrupteur switchPin (interrupteurBroche), celle de commande du moteur motorPin (moteurBroche), celle de la LED « L » LEDPin (LEDBroche), et celle du potentiomètre potPin (potentiometreBroche).

// Pins
const int switchPin = 2;
const int motorPin  = 9;
const int LEDPin    = 13; // LED 'L' intégrée
const int potPin    = A0;

Ensuite, définissez les constantes correspondant à la vitesse du moteur lorsque le potentiomètre est en position « Max » motMax (moteurMax), à la valeur de démarrage du moteur motThreshold (moteurSeuil), et à la durée en milliseconde (ms) de la période de calibrage du potentiomètre calibrationTime (calibrageTemps).

// Constants
const int motMax          = 150;  // vitesse maximale du moteur [0 - 255]
const int motThreshold    = 20;   // vitesse démarrage du moteur [0 - 255]
const int calibrationTime = 5000; // durée en ms

Enfin, initialisez les autres variables nécessaires au fonctionnement du programme.

Premièrement, les valeurs analogiques potMin et potMax qui contiendront, après le calibrage du potentiomètre, les valeurs des positions 'Min' et 'Max' du potentiomètre, puis potValue et motorValue, qui contiendront respectivement la valeur lue sur le potentiomètre et celle transmise au moteur.

// Variables
int potMin     = 1023; // valeur minimale du calibrage du potentiomètre
int potMax     = 0;    // valeur maximale du calibrage du potentiomètre
int potValue   = 0;
int motorValue = 0;

Deuxièmement, les valeurs numériques LEDstate (LEDEtat), qui déterminera si la LED 'L' est allumée ou éteinte, switchState (interrupteurEtat) qui contient l'état actuel de l'interrupteur, et previousSwitchState (precedentInterrupteurEtat) qui contient l'état de l'interrupteur lors de la précédente lecture.

int LEDState            = LOW;
int previousSwicthState = LOW;
int switchState         = LOW;

• Déclarer le mode d'utilisation des broches

Dans le setup(), ouvrez la liaison série et déclarez le pinMode() des broches du moteur (OUTPUT), de la LED (OUTPUT), du potentiomètre (INPUT) et de l'interrupteur (INPUT).

void setup() {

    Serial.begin(9600);

    pinMode(switchPin, INPUT );
    pinMode(motorPin , OUTPUT);
    pinMode(potPin   , INPUT );
    pinMode(LEDPin   , OUTPUT);

Ensuite, effectuez le calibrage du potentiomètre.

// Calibrage durant les cinq premières secondes

    // Allumer la LED 'L'
    digitalWrite(LEDPin, HIGH);

    while (millis() < calibrationTime ) {
        potValue = analogRead(potPin);

        // Enregistrer la valeur maximale du potentiomètre
        if (potValue > potMax) {
            potMax = potValue;
        }

        // Enregistrer la valeur minimale du potentiomètre
        if (potValue < potMin) {
            potMin = potValue;
        }
    }

    // Eteindre la LED 'L'
    digitalWrite(LEDPin, LOW);
}

• Lire l'entrée sur le potentiomètre, et placer la sortie à l'état correspondant si l'interrupteur a été appuyé.

Dans la fonction loop(), vérifier l'état de la broche switchPin avec digitalRead() afin de déterminer si l'interrupteur a changé de position depuis la dernière vérification.

Si l'interrupteur est enfoncé, changer l'état du moteur. S'il était arrêté, mettre la broche motorPin à l'état haut (HIGH), s'il était démarré, mettre la broche à l'état bas (LOW). À l'état HIGH, le transistor est activé, on dit qu'il est passant, le circuit alimentant le moteur est fermé, donc il tourne. À l'état LOW, le transistor n'est pas activé, on dit qu'il est bloquant, le circuit alimentant le moteur est ouvert, il ne tourne donc pas. La LED 'L' reflète l'état du moteur : allumée, le moteur est en marche ; éteinte, le moteur est arrêté.

void loop() {
    switchState = digitalRead(switchPin);
    
    // Si l'état du bouton est changé (ON/OFF), on change l'état du moteur (STOP/START)
    if (previousSwicthState != switchState) {
    previousSwicthState = switchState;
        if (switchState == HIGH) { // Le bouton est pressé
            if (LEDState == HIGH) {
                LEDState = LOW; // Le moteur est à présent éteint
                analogWrite(motorPin,0);
            } else {
                LEDState = HIGH; // Le moteur est à présent allumé
            }
            digitalWrite(LEDPin, LEDState);
        }
    }

Ainsi, la variable d'état de la LED est aussi utilisée pour déterminer si le moteur est en marche.

Dans ce cas, vérifier la valeur de la broche potPin avec analogRead() afin de déterminer la position du potentiomètre potValue entre [potMin,potMax], et calculer la valeur de la tension à envoyer au moteur sur la plage [0, motMax].

Ces deux valeurs sont affichées sur la liaison série.

Par précaution, afin de n'endommager ni la pile 9 V, ni le moteur, si la valeur calculée pour alimenter le moteur est inférieure à la valeur minimale permettant au moteur de démarrer, la valeur est forcée à 0 afin de laisser le moteur à l'arrêt. De même, si la valeur calculée est en dehors des limites admises par Arduino [0, 255], la valeur est repositionnée dans l'intervalle.

Enfin, la valeur est envoyée via analogWrite() à la broche motorPin.

    // PWM
    if (LEDState == HIGH) {
        potValue = analogRead(potPin);
        motorValue = map(potValue,potMin,potMax,0,motMax);
        
        Serial.print("Potentiometre : ");
        Serial.print(potValue);
        Serial.print(" / Moteur : ");
        Serial.println(motorValue);
        
        // Au cas où la valeur du moteur est inférieure à la valeur minimale de démarrage
        if (motorValue<motThreshold) {
            motorValue = 0;
        }

        // Au cas où la valeur du moteur est en dehors de la plage de fonctionnement obtenue pendant le calibrage
        motorValue = constrain(motorValue, 0, 255);

        analogWrite(motorPin,motorValue);
    }
}

Ce tutoriel est une traduction du livret d'accompagnement du kit de démarrage (document original disponible en licence Creative Commons BY-NC-SA) disponible sur le site http://astenor.free.fr/Arduino/. Le kit comprend une sélection de composants électroniques les plus courants et les plus utiles, accompagnée d'un livre de 15 projets. Depuis les bases de l'électronique, jusqu'à des projets plus complexes et intéressants, le kit vous aidera à contrôler notre monde physique avec des capteurs et des actionneurs.