Introduction à Arduino

Ils sont utilisés dans des systèmes électroniques et informatiques de taille limitée et spécialisée dans une tâche, ce sont les systèmes embarqués, où ils tiennent le rôle de “cerveau”, en traitant l'information et en permettant l'automatisation du système grâce à un programme implémenté.

Un microcontrôleur n'est pas aussi puissant qu'un micro-ordinateur (un ordinateur personnel). Il est destiné à réaliser une tâche unique/répétitive plutôt simple. Sa faible puissance de calcul permet une faible consommation d'énergie, sa taille réduite permet une incorporation dans de nombreux systèmes.

Un microcontrôleur est composé (principalement) de:

• Horloge : Elle permet d'accéder à la notion de temps.
• Mémoire volatile : (RAM) Elle stock les données temporaires comme les variables de calculs.
• Mémoire morte : (ROM) Elle stock les données qui ne sont pas amenées à changer, comme le programme de mise sous tension de la carte ou encore le programme implémenté dans la carte.
• Bornes entrées/sorties : Réception ou Envois des données.

Les microcontrôleurs sont implémentés sur une carte électronique qui est reliée à des périphériques. Ces périphériques peuvent être des périphériques de capture ou chargé d’exécuter une action.

Par exemple un thermomètre capture l'information liée à la température, un moteur peut être chargé de l'action “tourner” afin d'actionner les palles d'un ventilateur.

Le microcontrôleur est chargé de faire le lien entre informations entrantes et informations sortantes en fonction du programme qui lui a été donné d’exécuter.

Par exemple: en fonction de la température détectée par le thermomètre, le microcontrôleur est chargé de commander au moteur de s'allumer ou de s’éteindre.

La notion de transport de l'information est importante, elle est réalisée par le BUS.

Un microcontrôleur est programmable. C'est-à-dire qu'un programme ou algorithme peut être implémenté. L'algorithme écrit dans le langage de programmation utilisé est d'abord transcrit dans un langage que comprend le microcontrôleur puis enregistré dans la ROM. L'algorithme est ensuite exécuté.

Pour programmer une carte Arduino il est nécessaire d'écrire un algorithme dans un langage particulier. Ce langage est le C++ avec des bibliothèques de fonctions et de classes déjà importées et destinées à faciliter la programmation.

Une fois écrit via l'IDE Arduino, l'algorithme est compilé et transféré à la ROM de la carte (tout ceci de manière automatique via l'IDE).

Les langages Python et Matlab ne sont pas compilables (sauf manipulation spéciale), ils nécessitent un système plus complexe fonctionnant “derrière eux” : un interpréteur (ce sont des langages interprétés), hormis les avantages de cette technique, l'interprétation impacte de manière négative les performances. Les langages C, C++, Fortran sont des langages dont le code une fois compilé est un fichier qui peut être directement exécuté par le processeur, hormis les inconvénients, la compilation permet de bonne performances.

Ainsi les microcontrôleurs ne possèdent pas de systèmes d'exploitations, ce qui leur permet une efficacité relative dans l’exécution des algorithmes, bien que leurs ressources soient limitées.

L’exécution de l'algorithme est réalisée séquentiellement, c'est-à-dire que les instructions sont réalisées l'une après l'autre. Chaque instruction attendant que la précédente soit achevée pour être exécutée (sauf indications spéciales dans le code).

L’exécution d'une instruction est réalisée en plusieurs étapes, qui sont en général :

• Lire en mémoire l'instruction à exécuter
• Analyser l'instruction pour déterminer quelles opérations réaliser
• Exécuter l'instruction
• Écrire en mémoire les résultats de l'instruction

Les parties lire en mémoire et écrire en mémoire nécessite un adressage des données, une sorte de carte où les coordonnées dans la mémoire de chaque donnée est écrite.

L'Instruction par cycle d'horloge est une grandeur qui indique la performance du processeur, elle compte le nombre d'instructions exécutées pendant un cycle d'horloge.

On se sert d’une breadboard pour faire des circuits sans avoir besoin de souder les composants, ce qui est pratique pour l'apprentissage le prototypage.

Dans cet exemple, la résistance est reliée à l’alimentation grâce aux fils rouge et vert (lien horizontale) alors que la résistance et la LED sont liées grâce à un lien vertical (encadré orange).

Un IDE (Integrated Developpement Environment) est un logiciel qui fournit des outils facilitant le développement, la programmation de programme ou d'application.

L’IDE d’Arduino est l’un des moyen les plus simples et le plus pratiques pour développer un programme puis le téléverser (l’enregistrer sur la carte). Il automatise de nombreuses tâches et facilite la communication avec la carte.

Il est disponible gratuitement sur ce lien: Software Arduino

Le moniteur série permet d'afficher des données, des résultats, mais aussi d'envoyer des données à l'Arduino.

Le langage utilisé avec Arduino est le langage C++, avec des bibliothèques importées par défaut. Ceux ayant déjà codé en C++ ou C ne seront donc pas dépaysés.

Ces langages induisent des principes que ceux n’ayant utilisé que python peuvent ne pas connaître, nous en détaillons quelques-uns.

• Déclaration des variables : Chaque variable doit être déclarée avant d’être utilisée. Ceci revient à dire quelles données type elles contiendrons et quelle taille de mémoire leur sera allouée. Deux types utilisés sont int pour un entier ou double pour un nombre à virgule.

  int a;          //déclaration de la variable a de type int
  a = 10;         //attribution de la valeur 10 à la variable a
  double b;       //déclaration de la variable b de type double
  b = 10.05;      //attribution de la valeur 10.05 à b
  int c = 5;      //forme contracté de déclaration & attribution

• Chaque instruction doit se terminer par un

  ;

• L’indentation n’est pas obligatoire (on peut tout écrire sur une seule ligne).
• Ligne de commentaire

  // exemple

• Bloc de commentaire

  /* exemple */

• Les fonctions de bases sont les suivantes:
  • pour k allant de 0 à n (exclu)

    for(int k = 0; k < n; k++){
        //bloc de code
    }

  • si condition est vraie

    if(condition == true){
      //bloc de code
    }

  • tant que condition est vraie

    while(condition == true){
      //bloc de code
    }

Nous détaillons ici les fonctions de bases d'Arduino.

• pinMode() : Définir comme entrée INPUT ou comme sortie OUTPUT le pin (branchement) :

  pinMode(5, INPUT);
  pinMode(1, OUTPUT);
   
  //ou en encore :
  int nom_pin = 2;
  pinMode(nom_pin, INPUT);

• digitalRead() : Lire la valeur binaire (soit HIGH soit LOW) du pin spécifié.

  int valeur;
  valeur = digitalRead(5);

• digitalWrite() : Envoyer la valeur binaire (soit HIGH soit LOW) au pin spécifié.

  int nom_pin = 5;
  int valeur = LOW;
  digitalWrite(nom_pin, valeur);

• analogRead() : Lire la valeur analogique (de 0 à 1023 (dépendant des cartes) codée sur un type int) du pin spécifié.

  int valeur;
  valeur = analogRead(A5);

• analogWrite() : Envoyer la valeur analogique (de 0 à 1023 codée sur un type int) au pin spécifié.

  int valeur;
  valeur = 500;
  int nom_pin;
  analogWrite(nom_pin, valeur);

• delay() : Mettre en “pause” l’exécution du programme durant la durée en ms spécifiée.

  delay(3000); //pause de 3s

Le site d'Arduino fourni une liste des fonctions disponibles et des détails les concernant : Arduino Reference

Le baud concerne la commande énigmatique Serial.begin(9600);. Cette commande précise la vitesse de communication entre la carte et l’ordinateur. Il est nécessaire de la préciser si plus tard dans votre projet vous souhaitez utiliser le moniteur série (voir partie IDE) qui permet par exemple d’afficher en temps réel les données des capteurs de la carte.

• une LED
• une résistance de 10 k𝞨
• une breadboard
• des cables

Allumer une LED avec une carte Arduino.

Faire clignoter une LED avec une carte Arduino.

• une LED
• un bouton poussoir
• deux résistances de 10 k𝞨
• une breadboard
• des cables

Allumer la LED si le bouton poussoir est activé.

Allumer ou éteindre la LED lorsqu'on appuie sur le bouton poussoir.

• une LED
• une photorésistance
• deux résistances de 10 k𝞨
• une breadboard
• des cables

Si la valeur de la photorésistance est supérieure à 500, allumez la LED. Sinon éteignez-la.