Débuter avec Arduino

• De vérifier en temps réél le signal sortant d'un capteur analogique ou numérique (c'est l'exemple ci-dessus, on vérifie en permanence le signal sortant du potentiomètre - capteur analogique).
  On peut vérifier ce signal pour, entre autre :
  • Débugger un programme en vérifiant que le capteur fonctionne, qu'il est correctement branché et programmé.
  • Acquérir des données pour ensuite les analyser (voir les tutoriels Arduino sur ce site : spectrophotomètre, mesure de la vitesse du son et calcul de l'accélération de la pesanteur "g" par exemple).
• Commander Arduino à distance (en envoyant des commandes avec son clavier).
• Faire communiquer Arduino avec des logiciels présents sur votre ordinateur (exemple : produire des effets visuels en fonction de l'environnement à la manière de ce qu'on peut voir sur le pont Jacques Cartier à Montréal).

int valeur = 0;
int potentiometre = A0;

void setup()
{
  pinMode(potentiometre, INPUT);
  Serial.begin (9600);
}

void loop()
{
  valeur = analogRead (potentiometre);
  Serial.println (valeur);
}

int valeur = 0;
int potentiometre = A0;

• int valeur = 0; : cette variable permettra de stocker la valeur du potentiomètre lue par Arduino et que nous voudrons afficher dans le moniteur série.
• int potentiometre = A0; : cette variable permet de dire à Arduino que le mot "potentiometre" est égal à "A0". Le potentiomètre est branché sur la prise A0.

void setup()
{
  pinMode(potentiometre, INPUT);
  Serial.begin (9600);
}

• pinMode(potentiometre, INPUT); : nous indiquons à Arduino que le potentiomètre est une "entrée". Étant donné que nous avons préalablement déclaré que potentiometre = A0, cette ligne équivaut à dire pinMode (A0, INPUT);.
• Serial.begin (9600); : voici une nouveauté. Cette ligne sert à démarrer la communication série. La fonction Serial.begin() prend un argument entre ses parenthèses : la vitesse de communication. Cette vitesse s'exprime en "bauds", une unité largement utilisée dans le domaine des communications électroniques (téléphonie, réseaux etc). La définition théorique est un peu complexe mais disons que 9600 bauds correspondent à peu près à 9600 bits/seconde. Nous utilisons cette valeur car c'est la valeur par défaut lorsqu'on ouvre le moniteur série. Ce n'est pas la plus rapide mais elle suffira largement à nos besoins.

void loop()
{
  valeur = analogRead (potentiometre);
  Serial.println (valeur); 
}

• valeur = analogRead(potentiometre); : cette commande nous permet de lire la valeur analogique du potentiomètre et de stocker cette valeur dans la vriable "valeur".
• Serial.println (valeur); : cette ligne permet d'imprimer à l'écran, dans le moniteur série, la variable "valeur".

• Le numéro de la prise sur laquelle écrire le signal (ici prise #3, également identifée sous le nom "del").
• La valeur que doit prendre la prise. Cette valeur est comprise entre 0 et 255 :
  • 0 : la prise est éteinte.
  • 255 : la prise est allumée à 100%.
  • 128 : la prise est allumée à 50%.

• Sur chaque prise PWM, Arduino émet des pulsations électriques, dont la férquence est 490 Hertz sur les prises 3, 9, 10 et 11 (soit 490 pulsations par secondes) et 980 Hertz sur les prises 5 et 6 (980 pulsations par secondes).
• Prenons le cas des pin 5 et 6 qui ont une fréquence de 980 Hz. Arrondissons à 1000 pour simplifier les calculs. Si la prise "vibre" 1000 fois par seconde, la période est de 1 seconde / 1000 = 1 milliseconde. Dans le scéma ci dessus, le terme "période" correspondrait donc à 1 ms.
• Cas A : vous avez écrit analogWrite (0). La pulsation électrique émise par Arduino dure 0% de 1 ms : le signal moyen est de 0 Volts.
• Cas B : vous avez écrit analogWrite (67). La valeur "67" correspond à 25% du signal maximum (signal max = 255, 25% de 255 = 67). La pulsation électrique émise par Arduino dure 25% de 1 ms : le signal moyen est de 1,25 Volts (25% de 5 Volts).
• Cas C : vous avez écrit analogWrite (255). La valeur "255" correspond à 100% du signal maximum (signal max = 255, 100% de 255 = 255). La pulsation électrique émise par Arduino dure 100% de 1 ms : le signal moyen est de 5 Volts (100% de 5 Volts).

• De façon mathématique toute simple : pour passer de l'intervalle mathématique [0 1023] à [0 255], il suffit de diviser par 4. Nous pourrions alors modifier le "void loop()" comme ceci :
  
  

  void loop()
  {
    valeur = analogRead (potentiometre);
    Serial.println (valeur);
    analogWrite (del, valeur/4);
  }
  

  
  Essayez pour voir !!
• Arduino à une fonction toute prête pour convertir des valeurs ! C'est la fonction map(variable, x départ, y départ, x arrivée, y arrivée). Constatez que la fonction map() prend 5 arguments :
  • le nom de la variable à modifier (dans notre cas, "valeur").
  • x départ et y départ : les valeurs minimales et maximales de la variable au départ (dans notre cas, 0 et 1023).
  • x arrivée et y arrivée : les valeurs minimales et maximales de la variable que l'on veut obtenir (dans notre cas, 0 et 255).
  Nous écririons dans notre exemple :
  map (valeur, 0, 1023, 0, 255)
  Ce qui nous donnerai le bout de code suivant dans le "void loop()":
  
  

  void loop()
  {
    valeur = analogRead (potentiometre);
    Serial.println (valeur);
    valeur = map (valeur, 0, 1023, 0, 255);
    analogWrite (del, valeur);
  }
  

  
  Essayez pour voir !
  
  Notez que dans cet exemple nous réassignons à la variable "valeur" sa nouvelle valeur. C'est comme si j'enlevai les chaussettes vertes de ma valise pour en mettre des rouges. La variable est toujours là, elle s'appelle toujours "valeur" mais elle est recalculée.

• La fonction analogRead() permet de lire un signal analogique.
• Un signal analogique ne peut être lu que sur les prises A0 à A5 (ANALOG IN).
• Un signal analogique lu est converti par Arduino en un nombre entier compris entre 0 et 255.
• La fonction analogWrite() permet de produire un signal analogique.
• Un signal analogique ne peut être produit que par les prises PWM indiquée par le symbole ~ : prises 3, 5, 6, 9, 10 et 11.
• Un signal analogique écrit est converti par Arduino en un nombre entier compris entre 0 et 1023.
• La fonction Serial.begin() permet de démarrer une communication série. Elle se place dans le "setup".
• La fonction Serial.println() permet d'afficher , dans le moniteur série, la variable indiquée en argument.
• La fonction map() permet de convertir automatiquement une variable d'un intervalle de départ vers un intervalle d'arrivée.