Arduino

La cigarette ne tue pas les machines

Fumer tue ! Mais pas l'Arduino. Avec ce projet, vous pourrez laisser l'Arduino fumer à votre place ! Ce projet vous permettra d'utiliser l'information provenant d'un capteur de souffle et de l'utiliser pour contrôler un moteur lié à une petite pompe pneumatique. Vous verrez également comment éviter le bruit ou les fluctuations dans un signal de capteur en utilisant une mémoire « tampon » (buffer).

Éléments nécessaires pour réaliser le projet

un moteur DC simple et une source appropriée (batterie ou transformateur 9 V si moteur 9 V) ;
un mécanisme de mini pompe pneumatique ;
un capteur de souffle ou un circuit avec micro électret ;
un platine d'essai et des fils ;
une diode « de roue libre » quelconque ;
un transistor NPN 2N3904 (ou un transistor semblable NPN) ;
une résistance 2.2 kOhms ;
une cigarette.

Remarque : vous pouvez réaliser ce projet sans cigarette en n'utilisant pas de mini pompe pneumatique et en remplaçant le capteur de souffle ou micro électret par un potentiomètre. L'idée du projet est d'apprendre à contrôler la puissance d'un moteur simple DC avec un capteur analogique.

Première étape

Nous allons tout d'abord réaliser le circuit suivant afin de pouvoir utiliser le moteur DC.

Montage électronique

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'utilsation » 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érement 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). Ceci 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'é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 pin Gnd de la carte Arduino à la branche principale négatif de la platine d'essai.

Programmation

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'information 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++)

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;
le second élément précise la condition à remplir pour arrêter la boucle : i <= 255; ceci signifie que tant que i sera plus petite ou égale à 255, les instructions comprises entre les accolades seront répétées.
le dernier élément précise l'opération à exécuter après chaque boucle : i++;. Donc, une fois 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, 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().

Deuxième étape

Dans cette deuxième étape, notre Arduino se dévouera pour fumer à votre place. Nous connecterons donc le capteur de souffle et modifierons le code pour que lorsque vous soufflez ou aspirez près du micro électret, l'arduino active sa micro pompe.

Montage électronique

À 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 5V de la carte Arduino. Finalement, le fil du signal doit être connecté à la pin 0 de l'Arduino.

Programmation

// 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'arret 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ébugger
    Serial.println(valeurCapteur);

    // si la valeur du capteur est supérieur 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érique 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.

Traîner au parc avec son Arduino fumeur

Si l'envie vous prend d'emmener votre petit fumeur prendre l'air frais, rien n'est plus simple. Vous n'avez qu'à déconnecter le câble USB de la carte Arduino. Puis, connectez l'extrémité d'un fil à la broche VIN de l'Arduino et l'autre extrémité à la branche principale positive de la platine d'essai. Voilà! Votre carte Arduino devrait fonctionner seule.

En fait, la broche VIN de l'arduino permet d'utiliser une source de courant alternative à celui fourni par le câble USB. Cette source de courant peut généralement varier entre 6 et 12 V selon les types de cartes.

* Il est important de noter que pour les types de cartes beaucoup plus anciens comme la Diecimela, il faut également modifier le sélecteur de tension sur la carte (un jumper, en anglais) pour que la carte accepte le courant extérieur (ext sur la carte) plutôt que celui du USB (usb sur la carte).