Cours complet pour apprendre à programmer un Arduino

Comme le moteur nécessite une tension différente de celle fournie par la carte Arduino, nous devons monter deux circuits différents. Un circuit de commande où figure l'Arduino et un circuit de puissance où se trouve le moteur. Le transistor sert de « lien » entre les deux circuits en ce sens qu'il reçoit l'information de commande de la carte Arduino pour ouvrir et fermer le circuit de puissance qui active le moteur. Pour plus d'information sur les circuits de puissance, veuillez lire la partie « Circuit de commande et circuit de puissance » du chapitre « Précautions d'utilisation » dans la section « Électronique ».

Pour ce montage, nous allons d'abord connecter le transistor 2N3904. Si ce transistor ne vous est pas disponible, il est possible d'utiliser un autre transistor qui est également de type NPN. Ces transistors comportent trois bornes réparties différemment selon les modèles. Lorsqu'on fait face au 2N3904 par exemple (à sa partie « plate »), la borne de gauche s'appelle l'émetteur, la borne centrale la base et la borne de droite le collecteur.

Bornes du transistor 2N3904 (le brochage peut changer selon le modèle) :

• L'émetteur doit aller se brancher en direction d'un pôle négatif ou Gnd.
• La base doit se connecter à la branche de contrôle.
• Le collecteur doit aller se brancher en direction d'un pôle positif.

Donc, commencez par connecter l'une des bornes de la résistance 2.2k à la pin 9 de l'Arduino. L'autre borne de  la pin devra se connecter la base du transistor. Vous pouvez également utiliser un fil pour passer de la pin 9 Arduino à la platine d'essai, puis y insérer la base du transistor si cela est plus facile. Ensuite, la borne « émetteur » du transistor doit aller au Gnd. Finalement, la borne « collecteur » du transistor doit aller dans une branche de la platine d'essai.

Maintenant, nous allons ajouter le moteur. Connectez un des fils du moteur (le négatif, si possible), dans la branche de la platine d'essai où se trouve déjà la partie « collecteur » du transistor. L'autre fil (le positif) du moteur doit aller directement dans la branche principale positive (9 V) de la platine d'essai. Ensuite, connectez la borne négative de la diode (celle qui provient du côté de la diode marqué d'un trait) dans la branche principale positive et la patte positive de la diode dans la branche de la platine où le transistor et le moteur sont connectés. Vous aurez peut-être remarqué que la diode est branchée à l'envers (le négatif dans le positif). Cela est normal. Il s'agit d'un principe de diode « de roue libre ». Le rôle ici de la diode est d'éviter une surtension et sert à protéger les composants comme le transistor. (voir chapitre « Les bases de l'électroniqueLes bases de l'électronique »).

Il vous faut brancher l'alimentation à la platine d'essai, le pôle négatif de la batterie ou du transformateur dans la branche principale négative de la platine et le pôle positif dans la branche positive principale. Finalement, pour lier les masses ou le Gnd des deux circuits (celui de commande comprenant l'Arduino et celui de puissance qui comporte le moteur). Pour ce faire, connectez un fil à l'une des pins Gnd de la carte Arduino à la branche principale négatif de la platine d'essai.

Le programme suivant fera accélérer puis décélérer le moteur de manière graduelle et répétitive.

// déclarer la variable pour contenir la pin associée au moteur
int pinMoteur = 9;

void setup()
{
    // spécifier que la pin liée au moteur est une sortie
    pinMode(pinMoteur, OUTPUT);
}

void loop()
{
    // boucle pour faire accélérer le moteur
    for (int i = 0 ; i <= 255 ; i++)
    {
        //envoyer la valeur de 0 à 255
        analogWrite( pinMoteur, i);
        // attendre 10 millisecondes pour donner le temps de réaliser l'accélération
        delay(10);
    }

    // boucle pour faire décélérer le moteur
    for (int j = 0 ; j <= 255 ; j++)
    {
        //envoyer la valeur de 255 à 0
        analogWrite( pinMoteur, 255 - j);
        // attendre 10 millisecondes pour donner le temps de réaliser l'accélération
        delay(10);
    }
}

Le code ci-dessus nous permet d'abord de tester le contrôle du moteur. Nous utilisons la commande analogWrite(); pour envoyer un signal au transistor. Pour plus d'informations sur le PWM, veuillez lire la partie « Entrées / Sorties » du chapitre « Micro-contrôleurs » de la section « Électronique ». Ce signal nous permet de varier la vitesse de rotation du moteur en envoyant de courtes impulsions « on/off ». La commande analogWrite(); prend deux paramètres : la pin à laquelle nous voulons nous adresser et une valeur entre 0 et 255, correspondant dans notre projet à une intensité « très faible » pour le 0 jusqu'à une quasi pleine intensité pour 255.

L'autre fonction que nous utilisons dans ce programme est la boucle for();. Celle-ci permet de répéter un certain nombre de fois une série d'instructions. Dans notre code, nous répétons 256 fois la commande analogWrite(); en incrémentant à chaque fois la valeur passée en paramètre. Notre boucle for(); nécessite l'utilisation d'une variable et la spécification de trois instructions pour son bon fonctionnement :

for (int i = 0 ; i <= 255 ; i++)

1. Le premier élément déclare la variable à utiliser et son état de départ. Dans notre exemple, nous déclarons la variable : int i = 0; ;
2. Le deuxième élément précise la condition à remplir pour arrêter la boucle : i <= 255; cela signifie que tant que i sera plus petite ou égale à 255, les instructions comprises entre les accolades seront répétées.
3. le dernier élément précise l'opération à exécuter après chaque boucle : i++;. Donc, dès que les instructions entre accolades sont exécutées une première fois, la valeur de i sera incrémentée de 1. i++; est un raccourci qui est équivalent à écrire i = i + 1;.

Au départ, i prend donc la valeur 0. Nous spécifions cette valeur à analogWrite();. Puis, le programme attend 10 millisecondes avec la fonction delay(10); pour laisser un temps au moteur de bouger un peu. Un délai plus long ferait en sorte que le moteur change d'état plus lentement (la boucle s'exécuterait avec plus de temps d'attente entre chaque étape). Lorsque ces instructions sont terminées, la boucle reprend et i est incrémenté. La variable a donc maintenant une valeur de 1. La condition est testée i <= 255 et retourne “faux”, donc la boucle continue. Les instructions sont exécutées, le moteur tourne un peu plus vite et i est ensuite incrémenté à 2. Et ainsi de suite jusqu'à ce que i soit incrémenté à 256, ce qui rend la condition « vraie » et qui fait sortir le programme de la boucle for();.

La deuxième boucle du programme s'exécute de la même manière, à la différence que nous utilisons la variable j et que pour effectuer une décélération du moteur, nous utilisons l'opération 255-j pour spécifier la valeur à prendre pour analogWrite(). En effet, lorsque j est égal à 0, la valeur retournée par 255-j est égale à 255. Et ainsi de suite. Notre boucle for() passera donc en réalité les valeurs de 255 à 0 à analogWrite().

À présent, il nous faut incorporer notre capteur de souffle au circuit. Notez que vous pouvez utiliser un potentiomètre pour simuler ce capteur et réaliser le projet. Il est toutefois inutile de souffler sur le potentiomètre, il ne réagira pas! Le capteur que nous utilisons ici a trois fils. Le fil négatif (-) doit aller à la pin Gnd de l'Arduino. Le fil positif (+) doit être connecté à la pin 5 V de la carte Arduino. Finalement, le fil du signal doit être connecté à la pin 0 de l'Arduino.

// déclarer la variable pour contenir la pin associée au moteur
int pinMoteur = 9;
// déclarer la variable pour contenir la pin associée au capteur
int pinCapteur = A0;
// déclarer la variable pour contenir la valeur du capteur
int valeurCapteur;
// déclarer la valeur minimale pour déclencher le moteur
int seuilCapteur = 550;
// déclarer la variable pour contenir accumuler des valeurs tampon
int tampon = 0;
// déclarer la variable pour contenir la valeur d'arrêt pour le tampon
int seuilTampon = 5;

void setup()
{
    // établir connection sérielle
    Serial.begin(9600);
    // spécifier les entrées et sorties
    pinMode(pinMoteur, OUTPUT);
    pinMode(pinCapteur, INPUT);
}

void loop()
{
    // lire le capteur et mettre dans variable
    valeurCapteur = analogRead(pinCapteur);
    // afficher la valeur pour déboguer
    Serial.println(valeurCapteur);

    // si la valeur du capteur est supérieure au seuil fixé
    if(valeurCapteur > seuilCapteur)
    {
        // transformer les valeurs analogiques 0-1023 à 100 à 255
        valeurCapteur =  map(valeurCapteur, 0, 1023, 100, 255);
        // envoyer valeur au moteur
        analogWrite(pinMoteur, valeurCapteur);
        // remettre le compteur tampon à zéro
       tampon = 0;
    }
    else{ // si le capteur est inférieur
        // incrémenter le tampon
        tampon++;
    }

    // si le compteur tampon a dépassé le seuil
    if(tampon >= seuilTampon)
    {
        // arrêter le moteur
        analogWrite(pinMoteur, 0);
    }

    // attendre 100 millisecondes pour avoir moins d'erreurs de lecture
    delay(100);
}

Jetons d'abord un œil à nos variables :

• pinMoteur sert à identifier la pin liée au moteur ;
• pinCapteur sert à identifier la pin liée au capteur ;
• valeurCapteur sert à emmagasiner la valeur du capteur ;
• seuilCapteur le seuil sert à préciser à partir de quelle valeur du capteur nous pouvons considérer l'entrée d'information comme un « souffle ». Plus l'utilisateur souffle fort dans le capteur, plus la valeur augmente. C'est pourquoi nous retrouvons la fonction if(valeurCapteur >= seuilCapteur) dans notre code.

tampon et seuilTampon servent à une fonction spéciale. Le micro électret convertit du son en information numérique. Un signal sonore représenté numériquement est en fait une oscillation, une modulation d'amplitude de signal à travers le temps. Un son continu à l'oreille ne l'est pas en réalité, puisque c'est une vibration. Les données numériques associées à ce son comportent donc des valeurs qui peuvent avoir de grandes variations.

Nous voulons que le moteur ne s'enclenche qu'à partir d'un certain seuil de volume (valeurCapteur) mais la variation de l'amplitude d'un son, même suffisamment fort, comportera des valeurs inférieures à ce seuil et qui feront s'arrêter le moteur. Pour éviter cela, nous utilisons le tampon. En effet, à chaque fois que valeurCapteur descend en bas de seuilCapteur, et ce, même lors d'un son continu, nous incrémentons le tampon plutôt que de fermer immédiatement le moteur. Si valeurCapteur remonte en haut de seuilCapteur, signifiant que nous sommes en présence d'un son continu suffisamment fort, nous remettons tampon à zéro. Toutefois, si pour plusieurs lectures consécutives du capteur, nous obtenons une valeur inférieure à seuilCapteur, cela sera interprété comme un arrêt du son continu et nous arrêterons ainsi le moteur. Le nombre de lectures consécutives est spécifié par seuilTampon et la condition mentionnée précédemment est vérifiée par if( tampon >= seuilTampon ).

La dernière fonction à décrire que nous utilisons dans le code est map(). Cette fonction nous permet de reporter les valeurs de lecture analogique (0 à 1023) sur des valeurs sélectionnées par le programmeur pour le bon fonctionnement du moteur (100 à 255). map() est explicitée plus en détail dans le projet Premier Contact.