Mis à jour le mercredi 30 novembre 2016
  • 15 heures
  • Moyenne

Ce cours est visible gratuitement en ligne.

Vous pouvez obtenir un certificat de réussite à l'issue de ce cours.

J'ai tout compris !

Le moteur à courant continu (partie 2) : le pont en H et les circuits intégrés

Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

Dans le chapitre précédent, vous avez appris à connecter un moteur en protégeant à la fois l'Arduino et les transistors de commande. Vous avez aussi vu comment gérer la vitesse du moteur grâce aux pins PMW.

En revanche votre moteur, pour le moment, ne peut tourner que dans un sens.

Et bien l'objet de ce chapitre est de vous montrer comment on peut faire tourner un moteur dans les deux sens (en continuant bien sûr de gérer sa vitesse) grâce au pont en H.

Puis vous verrez comment réaliser la même chose plus facilement grâce aux circuits intégrés qu’ont développé des électroniciens et qui sont maintenant disponibles en commerce.

Enfin, nous construirons un programme qui permet de faire réagir les moteurs de deux ventilateurs en fonction de l'environnement (l'un piloté par bouton poussoir, l'autre piloté par potentiomètre).

Le pont en H

Vous avez remarqué que votre moteur peut maintenant tourner plus ou moins vite grâce aux montages précédents. En revanche, il ne tourne que dans un sens.

Forcément, si vous le connectez à l'envers, il tournera dans l'autre sens. Mais ce n'est quand même pas pratique de refaire les branchements à chaque fois !

Il existe, en réfléchissant un peu, une méthode qui peut résoudre notre problème : elle consisterait à faire changer l’électricité de sens à volonté !

Mais comment !? 

Ha ! Toujours cette soif d'apprendre qui nous fait avancer dans le blizzard de l'ignorance, l'oeil humide et le nez gelé, délaissant famille et patrie pour de nouveaux horizons aux paysages fabuleux et dont... ? Oui, Lukas, vous avez raison je m'égare ! 

Voici donc un petit schéma qui vous donne un début de réponse :

Le pont en H
Le pont en H

Voici ce qu'on appelle le pont en H. Il tient son nom de la forme en H du circuit autour du moteur.

Ce circuit (ici réalisé avec des interrupteurs) permet de résoudre notre problème. Il faut tout de même être attentif à certaines erreurs possibles.

Le principe

Les interrupteurs fonctionnent deux par deux. Le A est associé au D et le B est associé au C. Dans le schéma ci-dessus, rien ne se passe car tous les interrupteurs sont ouverts (ils ne laissent pas passer le courant). Le moteur est arrêté.

Voyons maintenant ce qui arrive lorsqu'on actionne en même temps les interrupteurs A et D (schéma de gauche), ou les interrrupteurs B et C (schéma de droite) :

Sens du courant en fonction de l’état des interrupteurs
Sens du courant en fonction de l’état des interrupteurs

Vous voyez donc  :

  • Sur le schéma de gauche : les interrupteurs A et D sont fermés. Le courant entre par la patte gauche du moteur et sort par sa droite. Le moteur tourne.

  • Sur le schéma de droite : les interrupteurs B et C sont fermés. Le courant entre par la patte droite du moteur et sort par sa gauche. Le moteur tourne donc dans le sens inverse !

On peut aussi associer le A au C et le B au D. Dans le chapitre précédent, nous avons vu que lorsqu’un moteur est en roue libre (c’est-à-dire qu’il tourne à cause de sa force d’inertie mais pas à cause du courant), il génère un courant. Ce courant peut être utilisé dans le pont en H comme frein électro-magnétique. Le moteur s'envoie son propre courant à l'envers ! Ça permet de contrôler l'arrêt du moteur plutôt que de le laisser en roue libre.

Frein électro-magnétique créé par l'inertie du moteur
Frein électro-magnétique créé par l'inertie du moteur

Alors pour une fois, je suis d'accord avec vous Lukas, c'est un peu fastidieux (oui, ce n'est pas le mot que vous avez employé, je sais, mais j'édulcore) de commander un moteur, et par extension, un robot, avec des interrupteurs !

Heureusement, vous avez suivi le chapitre précédent et vous savez maintenant que l'Arduino peut piloter des transistors qui servent d'interrupteurs pour le circuit de puissance !

Mais comme nous l'avons vu précédemment,  il faut les protéger des retours de tensions ! Voici donc un schéma, avec les diodes placées au bon endroit  :

Pont en H avec transitors NPN, diodes et entrées Arduino
Pont en H avec transitors NPN, diodes et entrées Arduino

Vous remarquerez que seuls deux pins sont en PWM. Ce n'est pas obligatoire, mais ça en libère pour d'autres besoins éventuels. Il faut aussi penser aux résistances entre l'Arduino et les transistors (pas mises sur le schéma). Je ne vous livre pas le circuit avec des MOSFETs (c'est le même principe) et je ne vous livre pas non plus le code de commande des transistors.

Mais pourquoi est-il si méchant  ?!

Tout simplement parce que la suite va nous faciliter la vie, et ce n'est rien de le dire !

Les circuits double ponts en H

Sachez que vous n'êtes pas les premiers à vous dire que ça fait quand même beaucoup de connexions pour commander un seul moteur CC au final. Or vous allez voir que les moteurs CC sont tout de même très utilisés en micro-robotique, en particulier pour les déplacements. Du coup, pour nous faciliter la vie, une nouvelle puce a vu le jour dans le merveilleux monde de l’électronique.

Alors pour lever les doutes éventuels, une puce électronique est un circuit intégré (et vice-versa), c'est-à-dire une sorte de petite boîte qui contient des composants miniaturisés et connectés entre eux afin de répondre à une fonction particulière. Vous l'avez peut-être remarqué, mais les transistors se ressemblent et pourtant ce ne sont pas tous les mêmes. Et bien une puce peut très bien ressembler à une autre, mais seule sa référence et sa datasheet vont pouvoir vous dire quel est son rôle et comment elle se connecte !

Dans notre cas, il existe des puces qui servent de pont en H. C'est leur fonction. Nous allons même en découvrir une qui permet de répondre à notre attente : la L293D.

Alors le nom des circuits intégrés n'est pas toujours clair : souvent des lettres et des chiffres. Parfois se tromper d'une lettre vous donne un autre composant. C'est le cas de cette puce. Il existe la L293 et la L293D. Le D signifie diodes. Ce sont les diodes diodes roues libre qui protègent les transistors. La différence entre la L293 et la L293D est donc simple : la L293 ne contient pas de diodes roues libres.

Nous utiliserons la L293D car cela nous évite de régler nous-mêmes le problème des diodes.

Voici donc la datasheet de ce circuit intégré. Il est bon d'y jeter un oeil. Ha oui, c'est en anglais  mais au bout d'un moment, on arrive à s'y repérer.

Le document s'appelle "quadruple half-H driver" qu'on peut traduire par "pilote de quadruple demi-pont en H". Donc double pont en H. Alors pourquoi ce nom de quadruple ? Tout simplement parce qu’avec ce circuit, vous pouvez piloter un moteur dans un sens à l’aide d’un demi-pont, soit 4 moteurs en sens unique, ou 2 moteurs dans les deux sens.

Voici une photo de la bébête :

Circuit intégré L293D (solarbotics.com)
Circuit intégré L293D (solarbotics.com)

Et le schéma pour les connexions :

Schéma L293D (datasheet)
Schéma L293D (datasheet)

Vous remarquerez qu'un circuit comporte toujours une marque pour son orientation. Les pins de connexion étant numérotés, c'est toujours bon de savoir par où commencer.

Vous allez voir que c'est finalement assez simple car chaque partie est regroupée. 

La partie gauche commande le premier pont (demi-pont 1 et demi-pont 2) :

  • pin 1 : active la partie gauche si l'on y envoie un état haut (+5V dans notre cas)  et la désactive à l'état bas. On peut donc l'utiliser pour envoyer un signal PWM.

  • pin 2 : c'est le pin de commande du demi-pont 1 (là où on envoie le courant au transistor pour qu'il laisse ou non passer le courant).

  • pin 3 : on branche une patte du moteur ici.

  • pin 4 : c'est le gnd (et le radiateur, ou dissipateur de chaleur). on y branche l'autre patte d'un moteur si on l'utilise que dans un sens. Il faut le relier au gnd de l'Arduino.

  • pin 5 : gnd pour le demi-pont 2 (il est d'ailleurs conseillé de relier tous les gnd utilisés ensemble).

  • pin 6 : on connecte l'autre patte du moteur (si utilisation dans les deux sens).

  • pin 7 : commande du demi-pont 2.

  • pin 8 : c'est ici que l'on connecte la source d'alimentation des moteurs (circuit de puissance).

La partie droite commande le second pont (demi-pont 3 et 4) :

  • pin 16 : c'est ici qu'on connecte le +5V de référence (circuit de commande).

  • pin 15 : commande du demi-pont 4.

  • pin 14 : connexion d'une patte du second moteur.

  • pin 13 e t 12 : gnd.

  • pin 11 : connexion de l'autre patte.

  • pin 10 : commande du demi-pont 3.

  • pin 9 : active la partie droite (donc demi-pont 3 et 4). Possible en PWM.

Bon voici un autre schéma en couleurs qui permet de mieux visualiser :

Visualisation des pins de connection du L293D
Visualisation des pins de connexion du L293D

Vous noterez, sur le diagramme de la datasheet qui suit, qu’il est possible de connecter soit un moteur dans les deux sens, soit deux moteurs en sens unique.

Diagramme de branchement de la puce L293D
Diagramme de branchement de la puce L293D

Les diodes placées autour des moteurs ne sont pas indispensables.

Voici enfin un exemple de connexion sur une breadboard avec une pile 9V et une carte Arduino :

Connexion Arduino, L293D, 2 moteurs CC, une alimentation 9V
Connexion Arduino, L293D, 2 moteurs CC, une alimentation 9V

Ce montage est assez compliqué. Repérez bien les différents câbles, c’est important.

Les commandes du moteur du haut se font avec les pins 12 et 8. La commande PWM est sur le pin 11.

Les commandes du moteur du bas se font avec les pins 2 et 4. La commande PWM est sur le pin 5.

Bien, voyons maintenant la programmation avec cette petite puce de rêve...

Programmez deux moteurs CC avec un circuit intégré L293D

Maintenant que vous avez réussi à connecter vos fils, vos moteurs, votre L293D, votre pile et votre Arduino (oui vous pouvez prendre une pause Lukas, vous avez l'air épuisé) nous allons voir comment piloter le tout.

Si l'on suit l'image précédente, vous allez pouvoir piloter en avant et/ou en arrière deux moteurs, à des vitesses variables. En robotique, ce n'est pas rien !

Je vous ai dit plus haut que les moteurs se pilotent par moitié de L293D. Il faut donc repérer le mieux possible quel pin commande quoi et dans quel moteur ! Le plus simple est de donner un nom de variable significatif aux pins attachés. Par exemple :

int pin1Moteur1=12; //cmd 1 du moteur 1
int pin2Moteur1=8; // cmd 2 du moteur 1
int pinPMoteur1=11;// PMM du moteur 1
int pin1Moteur2=2;//  cmd 1 du moteur 2
int pin2Moteur2=4;//  cmd 2 du moteur 2
int pinPMoteur2=5;//  PWM du moteur 2

L'avantage des variables c'est que si vous décidez d'attacher un autre pin à la variable, ça ne change pas le programme.

Voyons maintenant un tableau qui montre le comportement d'un moteur CC (Moteur1 ou Moteur2) en fonction de l'état de ses pins  :

pin1Moteur

pin2Moteur

Comportement du moteur

HIGH

LOW

Le moteur tourne dans un sens

LOW

HIGH

Le moteur tourne dans l'autre sens

LOW

LOW

Frein électromagnétique

HIGH

HIGH

Frein électromagnétique

Ce tableau est donc valable pour chaque moteur. Il suffit que les pins soient en mode OUTPUT et qu'on les active avec la commande :

digitalWrite(pin,etat);

avec  etat qui prend la valeur 1 (HIGH) ou 0 (LOW).

En ce qui concerne la gestion du PWM, je vous rappelle qu'on utilise la commande :

analogWrite(pin,valeur);

avec  valeur compris entre 0 (stop)  et 255 (à fond).

Enfin, je vous conseille d'utiliser des fonctions afin de mieux organiser votre programme. En effet, en fonction de ce que vous voulez obtenir, la succession de commandes risque de devenir lourde dans la  loop() .

Vous ne voyez pas comment faire ? Regardons ça ensemble dans la section suivante !

Silence… Moteurs CC… Ça tourne !

Voici un programme qui va gérer chaque moteur grâce à une fonction que l’on va appeller actionMoteur. Cette fonction va prendre  3 arguments :

  • Le moteur concerné : moteur 1 ou 2.

  • Le sens de rotation : 1 ou -1 (sens contraire). Tout autre nombre entier stoppera le moteur.

  • Le pourcentage de puissance : entre 0% et 100%.

Cette fonction actionMoteur va ensuite analyser ces arguments pour envoyer les bonnes informations aux pins rattachés au L293D.

La communication avec le moniteur série n'est pas obligatoire, mais elle permet de bien vérifier le fonctionnement du programme. Et voici ce programme de gestion des moteurs à partir de la fonction actionMoteur :

int pin1Moteur1=12; //pin de commande moteur 1
int pin2Moteur1=8; // pin de commande moteur 1
int pinPMoteur1=11;// pin PWM moteur 1
int pin1Moteur2=2; // pin de commande moteur 2
int pin2Moteur2=4; // pin de commande moteur 2
int pinPMoteur2=5; // pin PWM moteur 2

void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600); //initialise la communication série
  pinMode(pin1Moteur1,OUTPUT);
  pinMode(pin2Moteur1,OUTPUT);
  pinMode(pinPMoteur1,OUTPUT);
  pinMode(pin1Moteur2,OUTPUT);
  pinMode(pin2Moteur2,OUTPUT);
  pinMode(pinPMoteur2,OUTPUT);
}

void loop() {
  actionMoteur(1,1,100); //moteur 1 100% puissance sens 1
  actionMoteur(2,1,100); //moteur 2 100% puissance sens 1
  delay(5000); //attente de 5 secondes
  actionMoteur(1,1,50); //moteur 1 50% puissance sens 1
  actionMoteur(2,-1,50); //moteur 2 50% puissance sens -1
  delay(2000);
  actionMoteur(1,0,0); //arrêt moteur 1
  actionMoteur(2,0,0); //arrêt moteur 2
  delay(1000);
}

void actionMoteur(int moteur,int sens,int pourcentage){
  int pin1,etat1,pin2,etat2,pinP,puissance; //variable de la fonction
  //test numéro du moteur
  if (moteur==1){
    pin1=pin1Moteur1;
    pin2=pin2Moteur1;
    pinP=pinPMoteur1;
  }
  else {
    pin1=pin1Moteur2;
    pin2=pin2Moteur2;
    pinP=pinPMoteur2;
  }
  //test sens du moteur 1,-1 (sens contrainre) ou tout autre valeur (stoppe le moteur)
  if (sens==1){
    etat1=1;
    etat2=0;
  }
  else if (sens==-1){
    etat1=0;
    etat2=1;
  }
  else {
    etat1=0;
    etat2=0;
  }
  puissance=map(pourcentage,0,100,0,255);
  analogWrite(pinP,puissance);
  digitalWrite(pin1,etat1);
  digitalWrite(pin2,etat2);
  //affichage sur le moniteur série (facultatif)
  Serial.print("Moteur : ");
  Serial.print(moteur);
  if (sens==-1 || sens==1){
    Serial.print(" sens : ");
    Serial.print(sens);
  }
  else {
    Serial.print(" ! stop ! ");
  }
  Serial.print(" puissance : ");
  Serial.println(pourcentage);
}

La ligne if(sens==-1 || sens==1)  signifie : si ("sens" est égal à -1 ou bien si "sens est égal à 1"). Le signe  ||  en programmation est un opérateur booléen.

Vous pouvez donc tester plusieurs conditions d'un coup grâce à ces opérateurs booléens :

  • ||  : veut dire "ou" (or en anglais). On obtient le|  sur PC en tapant Alt Gr + 6 et sur Mac en tapant + alt +L .

  • !  : veut dire "non/pas" (not en anglais).

  • &&  : veut dire "et" (and en anglais).

Je vous conseille de bien chercher à comprendre ce programme. Il n'est pas difficile en soi, mais l'utilisation de la fonction doit être comprise car vous vous en servirez souvent (pas forcément cette fonction ;)) si vous devez piloter des robots interactifs. C'est d'ailleurs l'objet du programme suivant.

Moteurs et interaction

Nous le verrons dans le chapitre sur le robot autonome, mais il est souvent utile de commander des moteurs en fonctions de tests réalisés par des capteurs d'environnement. Pour le moment, en terme de capteurs, vous connaissez le bouton poussoir (qui est soit baissé, soit levé) et le potentiomètre (dont on peut récupérer la position de rotation avec une valeur entre 0 et 1 024).

Que pouvons-nous imaginer avec ce matériel ?

Et bien tout simplement un ventilateur. En fait non, deux ventilateurs. L'un dont la vitesse sera commandée par un bouton poussoir, l'autre dont la vitesse sera commandée par le potentiomètre.

En terme de connexions, nous gardons celles du L293D vues au-dessus :

  • Moteur 1 piloté par les pins 12, 8 et 11 pour le PWM ;

  • Moteur 2 piloté par les pins 2, 4 et 5 pour le PWM.

Le potentiomètre sera relié au pin analogique A0.

Le bouton poussoir sera relié au pin 7 de l'Arduino en mode INPUT_PULLUP

L'objectif du programme reprend des programmes réalisés précédemment, avec quelques subtilités.

  • Le premier moteur doit être commandé avec le bouton poussoir :

    • début à l'arrêt,

    • un appui = 25% de la vitesse,

    • un autre appui = 50% de la vitesse,

    • un autre appui = 75% de la vitesse,

    • un autre appui=100% de la vitesse,

    • un autre appui = arrêt du ventilateur.

  • Le second moteur doit être commandé avec le potentiomètre :

    • potentiomètre au centre = moteur arrêté,

    • potentiomètre vers la droite = moteur accélère proportionnellement dans un sens,

    • potentiomètre vers la gauche = moteur accélère proportionnellement dans l'autre sens.

Vous pouvez créer de nouvelles fonctions pour répondre à vos besoins et réussir cet exercice. Comme d'habitude, il n'y a pas qu'une façon de procéder.

La difficulté va se situer sur la lecture de la position du potentiomètre et sa transformation en sens et vitesse.

Un affichage sur le moniteur série peut vous aider à vérifier votre programme.

Un exemple de fabrication du ventilateur...

Si vous n'êtes pas encore à l'aise avec la fabrication de robots ou d'objets, vous pouvez commencer simplement. Dans le cas des ventilateurs, vous pouvez créer les pâles avec des rectangles découpés dans du carton à chaussure.

Vous prenez ensuite un bouchon de liège (type bouteille de vin) que vous entaillez au cutter de la largeur de la pâle (et en biais). Vous y glissez les pâles en carton (3 suffisent).

Vous piquez ensuite ce montage sur l'axe du moteur (avec un point de colle forte) et ça suffira pour le moment. 

Surélevez votre moteur en le mettant au bord d'une table (ou en haut d'une pile de livres) et fixez-le (avec du scotch).

Évidemment, cette fabrication est très précaire et n'aura pas une durée de vie très longue. Mais c'est un bon début si vous n'avez pas d'idées pour fabriquer votre ventilateur ! 

Retenez qu'il n'y a pas UNE bonne façon de faire, c'est ce qui fait toute la richesse de la communauté des utilisateurs de l'Arduino : leur créativité ! Chacun trouvera, en fonction de ses projets, des idées pour concevoir ses maquettes ou ses plateformes. Et on y arrive rarement du premier coup !

J'aborde dans le cours de perfectionnement les différents matériaux utilisables.

Voilà, je crois que j'ai tout dit. À vos marques, prêts, pratiquez ! 

Un exemple de programme final...

Voici le code que je propose. Le vôtre sera sûrement différent, car il existe bien des façons de répondre au cahier des charges !

/*
 * Nanomaître 2015
 * Programme de pilotage de deux moteurs, en direction et puissance
 * moteur 1 piloté par un bouton poussoir
 * sens unique, valeurs : 0, 25, 50, 75, 100 % de la puissance
 * moteur 2 piloté par un potentiomètre
 * double sens.
 * potentiomètre au centre : arrêt
 * potentiomètre à gauche sens -1
 * potentiomètre à droite sens 1
 * puissance en fonction de la position du potentiomètre
 * par rapport à sa valeur centrale
 * Affichage sur moniteur série pour contrôle.
 */
int pin1Moteur1=12; //pin de commande moteur 1
int pin2Moteur1=8; // pin de commande moteur 1
int pinPMoteur1=11;// pin PWM moteur 1
int pin1Moteur2=2; // pin de commande moteur 2
int pin2Moteur2=4; // pin de commande moteur 2
int pinPMoteur2=5; // pin PWM moteur 2
int pinBouton=7; //pin du bouton poussoir en mode INPUT_PULLUP
int pinPot=A0; //pin du potentiomètre
int vitesseM1=0; //variable de pourcentage de vitesse pour moteur 1
int sensM1=1; //variable de sens pour moteur 1
int vitesseM2=0; //variable de pourcentage de vitesse pour moteur 2
int sensM2=1; //variable de sens pour moteur 2

void setup() {
  Serial.begin(9600); //initialise la communication série
  pinMode(pin1Moteur1,OUTPUT);
  pinMode(pin2Moteur1,OUTPUT);
  pinMode(pinPMoteur1,OUTPUT);
  pinMode(pin1Moteur2,OUTPUT);
  pinMode(pin2Moteur2,OUTPUT);
  pinMode(pinPMoteur2,OUTPUT);
  pinMode(pinBouton,INPUT_PULLUP); //pinBouton en mode INPUT_PULLUP
}

void loop() {
  //gestion du moteur 1 avec le bouton
  if (!digitalRead(pinBouton)){// test d'appui du bouton (mode inversé car INPUT_PULLUP)
    vitesseM1+=25; // on ajoute 25 à la vitesse
    if (vitesseM1>100) // si on dépasse 100
      vitesseM1=0;//on revient à 0
    delay(200); //délai pour éviter les répétitions d'appui
  }
  //gestion du moteur 2 avec le potentiomètre
  int valeur=map(analogRead(pinPot),0,1023,-100,100); // on mappe la valeur lue entre -100 et 100
  if (valeur>=-2 && valeur<=2){//on teste si le potentiomètre est au centre
    vitesseM2=0; // on met la vitesse à 0
    sensM2=0; // on actionne la commande d'arrêt
  }
  else if (valeur<-2){// on teste si la valeur est négative
    vitesseM2=-valeur; //on met à jour la vitesse (en positif)
    sensM2=-1; //on indique le sens
  }
  else if (valeur>2){// on teste si la valeur est positive
    vitesseM2=valeur; //on met à jour la vitesse
    sensM2=1; // on indique le sens
  }
  //appel des commandes de moteurs
  actionMoteur(1,sensM1,vitesseM1); //commande pour moteur 1
  actionMoteur(2,sensM2,vitesseM2); //commande pour moteur 2
  Serial.println(); //saut de ligne
}

//fonction de gestion d'un moteur
void actionMoteur(int moteur,int sens,int pourcentage){
  int pin1,etat1,pin2,etat2,pinP,puissance; //variable de la fonction
  //test numéro du moteur
  if (moteur==1){
    pin1=pin1Moteur1;
    pin2=pin2Moteur1;
    pinP=pinPMoteur1;
  }
  else {
    pin1=pin1Moteur2;
    pin2=pin2Moteur2;
    pinP=pinPMoteur2;
  }
  //test sens du moteur 1,-1 (sens contrainre) ou tout autre valeur (stoppe le moteur)
  if (sens==1){
    etat1=1;
    etat2=0;
  }
  else if (sens==-1){
    etat1=0;
    etat2=1;
  }
  else {
    etat1=0;
    etat2=0;
  }
  puissance=map(pourcentage,0,100,0,255);
  analogWrite(pinP,puissance);
  digitalWrite(pin1,etat1);
  digitalWrite(pin2,etat2);
  //affichage sur le moniteur série (facultatif)
  Serial.print("Moteur : ");
  Serial.print(moteur);
  if (sens==-1 || sens==1){
    Serial.print(" sens : ");
    Serial.print(sens);
  }
  else {
    Serial.print(" ! stop ! ");
  }
  Serial.print(" puissance : ");
  Serial.print(pourcentage);
  Serial.print("%\t");
}

Bien, je pense que c'est suffisant pour les moteurs... et pour ce cours !   

Ce n’est qu’un au revoir

Voici donc la fin de ce cours d'initiation sur la programmation avec la carte Arduino.

Vous savez maintenant créer toutes sortes de montages électroniques et les piloter à l’aide d’une carte Arduino. Je refais le tour des beaux souvenirs de vos accomplissements de ce cours :

  • Les montages que vous avez appris à faire : avec des LED, des boutons poussoirs, des potentiomètres, des moteurs et servo-moteurs. Que ce soit pour faire clignoter des LED, programmer un dé numérique, mettre en mouvement un moteur... 

  • Les programmes que vous avez créés pour piloter ces montages : 

    • avec des boucles, des conditions, des fonctions, des tests, les constantes et variables qui vont bien, sans oublier des commentaires de code clairs ;

    • avec les fonctions typiques de l’Arduino, leurs constantes et quelques bibliothèques ;

    • avec le moniteur série de l’IDE d’Arduino pour afficher des informations du montage en direct. 

Il reste évidemment bien des choses à apprendre encore, c'est la raison pour laquelle un cours plus avancé va sortir prochainement pour ceux qui cherchent à se perfectionner. En attendant, je vous fournis en annexe de ce cours un complément très utile pour l'utilisation de divers capteurs compatibles avec l'Arduino !

Voici quelques compléments utiles pour vous donner l'eau à la bouche et l'info à la tête :

  • La liste des instructions de base du langage de l'IDE. Vous la trouvez aussi en allant dans le menu Aide -> Références de l'IDE. Vous en reconnaîtrez plusieurs que vous maîtrisez déjà.

  • Quelques sites pour commander votre matériel électronique : McHobby, AdaFruit, robotshop, gotronic, et bien sûr votre vendeur de proximité (qui vous dépannera bien souvent et bien plus humainement ;) ).

  • Découvrez de nombreuses applications réalisées avec Arduino dans cette vidéo de présentation de l'un de ses co-fondateurs, Massimo Banzi. Et si vous êtes encore curieux de plus de projets, tapez "projets Arduino" dans un moteur de recherche et laissez-vous embarquer par tous les liens offerts...

Je vous le rappelle, la communauté est suffisamment grande pour que vous trouviez réponses à vos questions (techniques, matérielles, électriques...) en visitant le forum d'électronique d'OpenClassrooms bien sûr, mais aussi les blogs proposés par les dizaines de passionnés !

J'espère en tous cas que vous avez appris suffisamment pour avoir contracté le virus Arduino ! C'est tout le mal que je vous souhaite !

Je tiens enfin à m'expliquer sur ce pauvre Lukas : je l'ai sorti du nom du créateur de STARWARS™ qui a réussi à faire croire à toute une génération à l'existence du sabre laser .

Exemple de certificat de réussite
Exemple de certificat de réussite