BAC PRO CIEL

1. Structure générale d'un programme Arduino

Un programme Arduino comporte obligatoirement deux fonctions principales :

void setup()
{
    // Initialisation du système
}

void loop()
{
    // Fonctionnement répété du système
}

La fonction setup()

La fonction setup() est exécutée une seule fois :

• après la mise sous tension ;
• après un appui sur le bouton Reset ;
• après le téléversement d'un programme.

Elle permet notamment de :

• configurer les broches ;
• initialiser la communication série ;
• placer les sorties dans leur état initial.

void setup()
{
    pinMode(8, OUTPUT);
    Serial.begin(9600);
}

La fonction loop()

Après l'exécution de setup(), la carte exécute continuellement la fonction loop().

void loop()
{
    // Lecture des entrées
    // Traitement des informations
    // Commande des sorties
}

2. Configurer une broche avec pinMode()

Avant d'utiliser une broche numérique, il faut généralement préciser son rôle.

pinMode(broche, mode);

Configurer une sortie

const byte LED_VERTE = 8;

void setup()
{
    pinMode(LED_VERTE, OUTPUT);
}

La broche 8 pourra ensuite commander une LED, un relais ou l'entrée d'un autre circuit.

Configurer une entrée

const byte BP_MARCHE = 2;

void setup()
{
    pinMode(BP_MARCHE, INPUT);
}

Utiliser la résistance interne de rappel

pinMode(BP_MARCHE, INPUT_PULLUP);

Avec INPUT_PULLUP, le bouton est généralement connecté entre la broche et la masse (GND).

3. Commander une sortie avec digitalWrite()

La fonction digitalWrite() place une broche numérique dans l'un des deux états logiques possibles.

digitalWrite(broche, etat);

Allumer une LED

const byte LED_VERTE = 8;

void setup()
{
    pinMode(LED_VERTE, OUTPUT);
}

void loop()
{
    digitalWrite(LED_VERTE, HIGH);
}

Si la LED est câblée entre la broche et la masse, HIGH provoque son allumage.

Éteindre la LED

digitalWrite(LED_VERTE, LOW);

Exemple avec deux LED

digitalWrite(LED_VERTE, HIGH);
digitalWrite(LED_ROUGE, LOW);

4. Lire une entrée avec digitalRead()

La fonction digitalRead() lit l'état logique d'une broche numérique.

digitalRead(broche);

La fonction renvoie soit HIGH, soit LOW.

Enregistrer l'état d'un bouton

bool etatBouton;

etatBouton = digitalRead(BP_MARCHE);

La valeur retournée est enregistrée dans la variable etatBouton.

Utilisation directe dans une condition

if (digitalRead(BP_MARCHE) == LOW)
{
    digitalWrite(LED_VERTE, HIGH);
}
else
{
    digitalWrite(LED_VERTE, LOW);
}

Avec un bouton configuré en INPUT_PULLUP, la condition est vraie lorsque le bouton est appuyé.

Programme complet

const byte BP_MARCHE = 2;
const byte LED_VERTE = 8;

void setup()
{
    pinMode(BP_MARCHE, INPUT_PULLUP);
    pinMode(LED_VERTE, OUTPUT);
}

void loop()
{
    if (digitalRead(BP_MARCHE) == LOW)
    {
        digitalWrite(LED_VERTE, HIGH);
    }
    else
    {
        digitalWrite(LED_VERTE, LOW);
    }
}

5. Lire une entrée analogique avec analogRead()

Une entrée numérique ne reconnaît que deux états : HIGH ou LOW.

Une entrée analogique permet de mesurer une tension variable, par exemple celle produite par :

• un potentiomètre ;
• une photorésistance ;
• une thermistance ;
• un capteur analogique.

analogRead(broche);

Exemple

int mesure;

mesure = analogRead(A0);

Sur une Arduino Uno R3, la conversion analogique fournit une valeur entière comprise entre 0 et 1023.

Programme simple

const byte CAPTEUR = A0;

int mesure = 0;

void setup()
{
}

void loop()
{
    mesure = analogRead(CAPTEUR);
}

6. Produire un signal PWM avec analogWrite()

La fonction analogWrite() permet notamment de faire varier :

• l'intensité lumineuse d'une LED ;
• la vitesse d'un moteur à courant continu ;
• la puissance moyenne fournie à une charge.

analogWrite(broche, valeur);

Sur une Arduino Uno R3, la valeur est comprise entre 0 et 255.

Faire varier la luminosité d'une LED

const byte LED = 9;

void setup()
{
    pinMode(LED, OUTPUT);
}

void loop()
{
    analogWrite(LED, 50);
}

Quelques valeurs

analogWrite(LED, 0);     // LED éteinte
analogWrite(LED, 64);    // Faible luminosité
analogWrite(LED, 128);   // Luminosité moyenne
analogWrite(LED, 255);   // Luminosité maximale

7. Créer une temporisation avec delay()

La fonction delay() suspend l'exécution du programme pendant une durée exprimée en millisecondes.

delay(duree);

Faire clignoter une LED

void loop()
{
    digitalWrite(LED_VERTE, HIGH);
    delay(1000);

    digitalWrite(LED_VERTE, LOW);
    delay(1000);
}

Limite de delay()

Pendant l'exécution de delay(), le programme reste bloqué sur cette instruction.

delay(5000);

8. Mesurer le temps avec millis()

La fonction millis() renvoie le nombre de millisecondes écoulées depuis le démarrage du programme.

millis();

La valeur est généralement enregistrée dans une variable de type unsigned long.

Exemple

unsigned long tempsActuel;

tempsActuel = millis();

Réaliser une action sans bloquer le programme

const byte LED_VERTE = 8;

bool etatLed = false;

unsigned long ancienTemps = 0;
const unsigned long PERIODE = 1000;

void setup()
{
    pinMode(LED_VERTE, OUTPUT);
}

void loop()
{
    unsigned long tempsActuel = millis();

    if (tempsActuel - ancienTemps >= PERIODE)
    {
        ancienTemps = tempsActuel;
        etatLed = !etatLed;
        digitalWrite(LED_VERTE, etatLed);
    }
}

9. Communiquer avec l'ordinateur ou un autre module électronique en UART

La communication série permet d'échanger des informations entre la carte Arduino et l'ordinateur ou tout autre module possédant un bus UART : module Bluetooth, module GSM, module GPS, etc.

Elle est notamment utile pour :

• observer la valeur d'un capteur ;
• suivre l'évolution d'une variable ;
• vérifier une condition ;
• rechercher une erreur dans un programme.

Initialiser la communication

void setup()
{
    Serial.begin(9600);
}

Serial.print("Temperature : ");

Serial.println("Systeme actif");

Afficher une variable

int mesure = analogRead(A0);

Serial.print("Mesure : ");
Serial.println(mesure);

Programme complet

const byte CAPTEUR = A0;

void setup()
{
    Serial.begin(9600);
}

void loop()
{
    int mesure = analogRead(CAPTEUR);

    Serial.print("Valeur analogique : ");
    Serial.println(mesure);

    delay(500);
}

10. Erreurs fréquentes

Oublier de configurer une broche

digitalWrite(LED_VERTE, HIGH);

Il manque généralement :

pinMode(LED_VERTE, OUTPUT);

Oublier la logique inversée de INPUT_PULLUP

Incorrect :

if (digitalRead(BP_MARCHE) == HIGH)
{
    // Le bouton est appuyé
}

Avec un bouton relié à la masse, la bonne condition est :

if (digitalRead(BP_MARCHE) == LOW)
{
    // Le bouton est appuyé
}

Utiliser analogWrite() sur une broche non PWM

analogWrite(8, 128);

Confondre entrée analogique et sortie PWM

analogRead(A0);

analogWrite(9, 128);