PARTIE 1 — INTRODUCTION : Pourquoi ce projet est magique ?

Objectif : Découvrir l’architecture globale (Arduino + MQTT + Web) et son utilité.

Ce que tu vas apprendre

Tu vas découvrir comment faire discuter ton Arduino avec une page web, comme si tu envoyais des SMS à tes LEDs ! On va utiliser RabbitMQ (un "standardiste" qui transmet les messages) pour que ton téléphone puisse :

• Allumer une LED à distance.
• Lire la valeur d’un potentiomètre en temps réel.

Pourquoi c’est utile (et amusant)

Imagine :

• Allumer la lumière de ta chambre depuis ton canapé, juste avec ton téléphone.
• Voir en direct le niveau d’humidité de tes plantes sur ton écran.
• Piloter un robot ou une station météo depuis l’autre bout de la maison.

Avec ce projet, tu poses les bases de la domotique sans te prendre la tête. Et le meilleur ? Tu peux tout adapter à tes idées !

Le plan du projet

Voici comment on va s’y prendre, étape par étape :

1⃣ Prépare ton matériel : LEDs, potentiomètre, et ton Arduino R4 WiFi (ton "chef d’orchestre").

2⃣ Installe RabbitMQ (le "standardiste") dans Docker, comme une appli sur ton ordi.

3⃣ Configure MAMP (un serveur web tout simple) pour afficher une jolie page de contrôle sur ton téléphone.

4⃣ Code l’Arduino pour qu’il écoute les ordres (ex : "Allume la LED 13 !") et renvoie des infos (ex : "Le potentiomètre est à 36%").

5⃣ Teste tout : tu cliques sur ton téléphone, et pouf ! La LED s’allume. Magique, non ?

À la fin, tu auras une interface web qui ressemble à un tableau de bord de vaisseau spatial… mais en version Arduino !

PARTIE 2 — PRÉPARE TON MATÉRIEL COMME UN PRO

Objectif : Vérifier et organiser les composants avant de commencer.

Liste de courses

Avant de commencer, vérifie :

• Tu as tous les composants : Sors-les de leur emballage et pose-les devant toi comme un chef étoilé prépare ses ingrédients.
• Ton Arduino est reconnu par ton PC :
  • Branche-le en USB et ouvre l’IDE Arduino.
  • Va dans Outils > Port et sélectionne le port COM correspondant (ex: COM3 ou /dev/ttyACM0).
  • Pas de port ? Suis ce tutoriel d’installation.
• Tu as 30 minutes devant toi sans interruption : Éteins les notifications, c’est l’heure de coder !

Astuces de pro

• Range tes composants dans des boîtes à compartiments (comme celles pour les vis) pour ne plus jamais perdre une résistance.
• Prends une photo de ton montage avant de débrancher : ça sauve des vies quand tu veux le refaire plus tard !

PARTIE 3 — LE SCHÉMA DE CÂBLAGE : TON PLAN DE BATAILLE

Objectif : Brancher correctement LEDs et potentiomètre sur l’Arduino.

Vue d'ensemble

On va brancher 2 LEDs et un potentiomètre à ton Arduino R4 WiFi, comme si tu connectais des enceintes à une chaîne hi-fi. L’ordre est important :

1. D’abord les LEDs (pour vérifier que le courant passe).
2. Puis le potentiomètre (pour lire des valeurs analogiques).

Tableau des connexions

Note :

• Les résistances (220Ω) sont obligatoires pour les LEDs : sans elles, le courant serait trop fort et grillerait la LED (comme un tuyau d’arrosage sous trop de pression).
• Le potentiomètre se branche comme un robinet : la broche du milieu est la sortie (comme le bec du robinet), et les deux autres sont l’entrée (5V) et la sortie (GND).

Les 3 erreurs à ne JAMAIS faire

1. Inverser les pattes de la LED → Risque : La LED ne s’allumera pas (comme une pile branchée à l’envers dans une lampe).
   • Astuce : La patte longue (+) va toujours vers la broche Arduino, la courte (-) vers la résistance et la masse.
2. Oublier la résistance pour les LEDs → Risque : La LED va griller en quelques secondes (comme une ampoule sans variateur de lumière).
   • Astuce : Une résistance de 220Ω est idéale pour les LEDs classiques (rouge, verte, jaune).
3. Brancher le potentiomètre à l’envers → Risque : La valeur lue sera toujours à 0 ou 1023 (comme un robinet qui ne laisse passer que de l’eau froide ou chaude).
   • Astuce : La broche du milieu (A0) doit toujours être connectée à la sortie du potentiomètre.

PARTIE 4 — MQTT & WEBSOCKET : LES SUPER-POUVOIRS DE LA COMMUNICATION

Objectif : Comprendre comment Arduino parle au web (broker, topics, messages).

L'analogie pour tout comprendre

Imagine ton Arduino comme un chef d’orchestre qui dirige une petite troupe de musiciens :

• Les LEDs sont des percussionnistes : elles ne savent faire que deux choses, jouer (allumées) ou se taire (éteintes).
• Le potentiomètre est un violoniste : il peut jouer toutes les notes entre 0 et 100% (comme un volume de musique).
• RabbitMQ est le chef d’orchestre adjoint : il transmet les ordres du public (ton téléphone) aux musiciens (Arduino) et vice versa.

Quand tu cliques sur un bouton dans ton navigateur :

1. Ton téléphone envoie un message "Allume la LED 13 !" à RabbitMQ.
2. RabbitMQ le transmet à l’Arduino.
3. L’Arduino exécute l’ordre et répond "C’est fait !".
4. RabbitMQ renvoie la confirmation à ton téléphone.

Comment ça marche techniquement

Étape 1 : Connexion au broker

• L’Arduino se connecte à RabbitMQ (le "standardiste") via WiFi, comme tu te connectes à ta box internet.

Étape 2 : Abonnement aux topics

• L’Arduino s’abonne à des "topics" (comme des chaînes de discussion) :
  • arduino/led13 pour recevoir les ordres de la LED 13.
  • arduino/pot pour envoyer la valeur du potentiomètre.

Étape 3 : Envoi/réception des messages

• Quand tu cliques sur un bouton dans ton navigateur, un message est envoyé au topic arduino/led13.
• L’Arduino reçoit le message, allume la LED, et envoie une confirmation au topic arduino/feedback.

À retenir

"MQTT, c’est comme des SMS pour objets connectés : léger, rapide, et sans fil."

Exemple concret : Une station météo qui envoie la température toutes les 5 minutes à ton téléphone.

PARTIE 5 — CODE PARTIE 1 : CONFIGURATION DE L'ARDUINO

Objectif : Configurer les broches, le WiFi et MQTT.

Ce que fait cette partie du code

Ici, on configure l’Arduino comme un chef d’orchestre qui se présente à son public :

• On déclare les broches (où brancher les LEDs et le potentiomètre).
• On initialise les variables (comme des post-it pour se souvenir de l’état des LEDs).
• On prépare la connexion WiFi et MQTT (pour que l’Arduino puisse discuter avec ton téléphone).

Code commenté ligne par ligne

// ---- Inclusion des bibliothèques ----
#include <WiFiS3.h>     // Pour gérer le WiFi de l'Arduino R4
#include <MQTT.h>       // Pour communiquer en MQTT (comme des SMS)
#include "secrets.h"    // Fichier externe qui contient tes identifiants WiFi (SSID + mot de passe)

// ---- Configuration IP fixe ----
// Comme une adresse postale pour ton Arduino sur le réseau
IPAddress localIP(192, 168, 1, 165);  // Adresse IP de l'Arduino (modifiable si conflit)
IPAddress gateway(192, 168, 1, 1);    // Adresse de ta box (généralement 192.168.1.1)
IPAddress subnet(255, 255, 255, 0);   // Masque de sous-réseau (ne change pas)
IPAddress dns(8, 8, 8, 8);            // DNS de Google (pour résoudre les noms de domaine)

// ---- Initialisation des clients ----
WiFiClient net;          // Client WiFi (comme un câble réseau virtuel)
MQTTClient client;       // Client MQTT (pour envoyer/recevoir des messages)

// ---- Déclaration des broches ----
const int ledPin13 = 13; // Broche pour la LED 13 (celle intégrée à l'Arduino R4)
const int ledPin12 = 12; // Broche pour la LED 12 (externe)
const int potPin = A0;   // Broche analogique pour le potentiomètre (A0 = entrée analogique)

// ---- Variables d'état ----
bool ledState13 = false; // État de la LED 13 (false = éteinte, true = allumée)
bool ledState12 = false; // État de la LED 12
unsigned long lastPublishTime = 0; // Dernier moment où on a envoyé des données
const long publishInterval = 1000; // Délai entre chaque envoi (1000 ms = 1 seconde)

// ---- Fonction pour se connecter au WiFi ----
void connectWiFi() {
  Serial.print("Connexion au WiFi..."); // Message dans le moniteur série

  // On configure l'IP fixe (comme une adresse postale fixe)
  WiFi.config(localIP, dns, gateway, subnet);

  // On se connecte avec les identifiants du fichier "secrets.h"
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);

  // Tant qu'on n'est pas connecté, on attend et on affiche des points
  while (WiFi.status() != WL_CONNECTED) {
    Serial.print(".");
    delay(1000); // On attend 1 seconde avant de réessayer
  }

  Serial.println("\nConnecté au WiFi !"); // Message de confirmation
  Serial.print("Adresse IP : ");
  Serial.println(WiFi.localIP()); // Affiche l'IP de l'Arduino
}

// ---- Fonction pour se connecter à MQTT ----
void connectMQTT() {
  Serial.print("Connexion à MQTT...");

  // On se connecte au broker MQTT (RabbitMQ)
  client.begin("192.168.1.XX", net); // Remplace XX par l'IP de ton ordinateur
  client.onMessage(messageReceived); // Fonction appelée quand un message arrive

  // Tant qu'on n'est pas connecté, on attend
  while (!client.connect("arduinoClient", "user", "password")) { // Remplace user/password
    Serial.print(".");
    delay(1000);
  }

  Serial.println("\nConnecté au MQTT !");

  // On s'abonne aux topics pour recevoir les ordres
  client.subscribe("arduino/led13");
  client.subscribe("arduino/led12");
}

// ---- Fonction appelée quand un message MQTT arrive ----
void messageReceived(String &topic, String &payload) {
  Serial.print("Message reçu sur topic : ");
  Serial.println(topic);
  Serial.print("Contenu : ");
  Serial.println(payload);

  // Si le message est pour la LED 13
  if (topic == "arduino/led13") {
    if (payload == "on") {
      digitalWrite(ledPin13, HIGH); // Allume la LED
      ledState13 = true;
    } else if (payload == "off") {
      digitalWrite(ledPin13, LOW); // Éteint la LED
      ledState13 = false;
    }
  }

  // Si le message est pour la LED 12
  if (topic == "arduino/led12") {
    if (payload == "on") {
      digitalWrite(ledPin12, HIGH);
      ledState12 = true;
    } else if (payload == "off") {
      digitalWrite(ledPin12, LOW);
      ledState12 = false;
    }
  }
}

// ---- Configuration initiale (setup) ----
void setup() {
  Serial.begin(115200); // Initialise la communication série
  pinMode(ledPin13, OUTPUT); // Configure la broche 13 en sortie
  pinMode(ledPin12, OUTPUT); // Configure la broche 12 en sortie

  connectWiFi(); // Se connecte au WiFi
  connectMQTT(); // Se connecte à MQTT
}

// ---- Boucle principale (loop) ----
void loop() {
  client.loop(); // Garde la connexion MQTT active

  // Envoie les données toutes les X secondes
  if (millis() - lastPublishTime > publishInterval) {
    lastPublishTime = millis();

    // Lit la valeur du potentiomètre (0-1023)
    int potValue = analogRead(potPin);
    // Convertit en pourcentage (0-100%)
    int potPercentage = map(potValue, 0, 1023, 0, 100);

    // Envoie la valeur du potentiomètre au topic "arduino/pot"
    client.publish("arduino/pot", String(potPercentage));

    // Envoie l'état des LEDs
    client.publish("arduino/led13/state", ledState13 ? "on" : "off");
    client.publish("arduino/led12/state", ledState12 ? "on" : "off");
  }
}

Exercice rapide

Mission : Modifie la variable publishInterval à la ligne 25 et passe de 1000 à 5000.

• Valeur initiale : 1000 ms (1 seconde).
• Valeur modifiée : 5000 ms (5 secondes).

Résultat attendu :

• Les données du potentiomètre seront envoyées toutes les 5 secondes au lieu de 1 seconde.
• Pourquoi ? Pour réduire la fréquence d’envoi et économiser de la bande passante.

PARTIE 6 — CODE PARTIE 2 : INTERFACE WEB EN HTML/JS

Objectif : Créer une page web pour contrôler l’Arduino.

Ce que fait cette partie du code

Ici, on crée une interface web qui envoie des ordres à l’Arduino via MQTT :

• Des boutons pour allumer/éteindre les LEDs.
• Une jauge pour afficher la valeur du potentiomètre en temps réel.
• Une connexion MQTT pour communiquer avec l’Arduino.

Code commenté ligne par ligne

<!DOCTYPE html>
<html lang="fr">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Contrôle Arduino depuis ton téléphone</title>
    <style>
        /* ---- Styles CSS ---- */
        body {
            font-family: Arial, sans-serif;
            text-align: center;
            margin: 20px;
            background-color: #f0f0f0;
        }
        h1 {
            color: #333;
        }
        .button {
            background-color: #4CAF50;
            border: none;
            color: white;
            padding: 15px 32px;
            text-align: center;
            text-decoration: none;
            display: inline-block;
            font-size: 16px;
            margin: 10px;
            cursor: pointer;
            border-radius: 8px;
        }
        .button.off {
            background-color: #f44336;
        }
        #potValue {
            font-size: 24px;
            margin: 20px;
        }
        #connectionStatus {
            padding: 10px;
            border-radius: 5px;
            margin: 10px;
        }
        .connected {
            background-color: #4CAF50;
            color: white;
        }
        .disconnected {
            background-color: #f44336;
            color: white;
        }
    </style>
</head>
<body>
    <h1>Contrôle ton Arduino depuis ton téléphone</h1>

    <!-- Boutons pour les LEDs -->
    <button id="toggleButton13" class="button">Allumer LED 13</button>
    <button id="toggleButton12" class="button">Allumer LED 12</button>

    <!-- Jauge pour le potentiomètre -->
    <div id="potValue">Potentiomètre : 0%</div>
    <progress id="potProgress" value="0" max="100" style="width: 80%; height: 30px;"></progress>

    <!-- Statut de la connexion -->
    <div id="connectionStatus" class="disconnected">Déconnecté</div>

    <!-- Bibliothèque MQTT -->
    <script src="https://unpkg.com/mqtt/dist/mqtt.min.js"></script>
    <script>
        // ---- Configuration MQTT ----
        const mqttConfig = {
            host: '192.168.1.XX', // Remplace XX par l'IP de ton ordinateur
            port: 1983, // Port WebSocket de RabbitMQ
            username: 'user', // Remplace par ton username MQTT
            password: 'password' // Remplace par ton password MQTT
        };

        // ---- Connexion au broker MQTT ----
        const client = mqtt.connect(`ws://${mqttConfig.host}:${mqttConfig.port}`, {
            username: mqttConfig.username,
            password: mqttConfig.password
        });

        // ---- Éléments du DOM ----
        const toggleButton13 = document.getElementById('toggleButton13');
        const toggleButton12 = document.getElementById('toggleButton12');
        const potValue = document.getElementById('potValue');
        const potProgress = document.getElementById('potProgress');
        const connectionStatus = document.getElementById('connectionStatus');

        // ---- Mise à jour du statut de connexion ----
        function updateConnectionStatus(status, message) {
            connectionStatus.textContent = message;
            connectionStatus.className = status;
        }

        // ---- Connexion MQTT ----
        client.on('connect', () => {
            updateConnectionStatus('connected', 'Connecté au broker MQTT !');
            console.log('Connecté au broker MQTT');

            // On s'abonne aux topics pour recevoir les mises à jour
            client.subscribe('arduino/pot');
            client.subscribe('arduino/led13/state');
            client.subscribe('arduino/led12/state');
        });

        // ---- Réception des messages MQTT ----
        client.on('message', (topic, message) => {
            console.log(`Message reçu sur ${topic}: ${message}`);

            // Met à jour la jauge du potentiomètre
            if (topic === 'arduino/pot') {
                const value = parseInt(message.toString());
                potValue.textContent = `Potentiomètre : ${value}%`;
                potProgress.value = value;
            }

            // Met à jour l'état des LEDs
            if (topic === 'arduino/led13/state') {
                toggleButton13.textContent = message.toString() === 'on' ? 'Éteindre LED 13' : 'Allumer LED 13';
                toggleButton13.className = message.toString() === 'on' ? 'button off' : 'button';
            }

            if (topic === 'arduino/led12/state') {
                toggleButton12.textContent = message.toString() === 'on' ? 'Éteindre LED 12' : 'Allumer LED 12';
                toggleButton12.className = message.toString() === 'on' ? 'button off' : 'button';
            }
        });

        // ---- Envoi d'une commande MQTT ----
        function toggleLed(ledNumber) {
            if (client.connected) {
                const topic = `arduino/led${ledNumber}`;
                const currentState = document.getElementById(`toggleButton${ledNumber}`).textContent;
                const newState = currentState.includes('Allumer') ? 'on' : 'off';

                client.publish(topic, newState);
                console.log(`Commande envoyée : ${topic} ${newState}`);
            } else {
                updateConnectionStatus('disconnected', 'Impossible d\'envoyer la commande: non connecté');
            }
        }

        // ---- Événements des boutons ----
        toggleButton13.addEventListener('click', () => toggleLed(13));
        toggleButton12.addEventListener('click', () => toggleLed(12));
    </script>
</body>
</html>

Exercice rapide

Mission : Change le délai de rafraîchissement de la jauge en modifiant la fréquence d’envoi des données dans le code Arduino (Partie 5).

• Valeur initiale : 1000 ms (1 seconde).
• Valeur modifiée : 200 ms (0,2 seconde).

Résultat attendu :

• La jauge du potentiomètre se mettra à jour 5 fois plus vite.
• Pourquoi ça marche ? Parce que l’Arduino envoie les données plus fréquemment, donc l’interface web les reçoit plus souvent.

PARTIE 7 — TEST : VÉRIFIE QUE TOUT FONCTIONNE

Objectif : Tester le projet et valider son fonctionnement.

Mise sous tension

1. Branche ton Arduino au port USB de ton ordinateur.
   • Vérifie : La LED orange "ON" doit s’allumer sur l’Arduino.
2. Ouvre l’IDE Arduino et sélectionne le bon port COM.
3. Téléverse le code (Partie 5) sur l’Arduino.
   • Vérifie : La LED intégrée (broche 13) doit clignoter rapidement pendant le téléversement, puis s’éteindre.
4. Ouvre le moniteur série (Outils > Moniteur série, vitesse 115200 bauds).
   • Vérifie : Tu dois voir les messages "Connecté au WiFi !" et "Connecté au MQTT !".
5. Ouvre le fichier HTML (Partie 6) dans ton navigateur.
   • Vérifie : La page doit afficher "Connecté au broker MQTT !".

Comportement attendu

Ce que tu dois voir :

1. Sur l’interface web :
   • Les boutons "Allumer LED 13" et "Allumer LED 12" doivent être actifs.
   • La jauge du potentiomètre doit bouger quand tu tournes le bouton.
2. Sur l’Arduino :
   • La LED 13 doit s’allumer quand tu cliques sur le bouton correspondant.
   • La LED 12 doit réagir de la même façon.
3. Dans le moniteur série :
   • Des messages comme "Led13 on", "Led12 off", et "pot XX" doivent défiler toutes les secondes.

Timing :

• Les messages MQTT doivent s’afficher toutes les secondes (ou selon ton publishInterval).
• Les LEDs doivent s’allumer/éteindre instantanément quand tu cliques sur les boutons.

Ça marche ?

Bravo ! Tu viens de :

• Faire communiquer ton Arduino avec une page web comme un pro.
• Créer une interface de contrôle à distance pour tes LEDs et ton potentiomètre.
• Poser les bases de la domotique (tu peux maintenant contrôler n’importe quel composant depuis ton téléphone !).

Partage ta victoire ! :

• Prends une photo de ton montage et poste-la sur notre groupe Facebook avec le hashtag #PlaisirArduino.
• Enregistre une courte vidéo de l’interface web en action et envoie-la à un ami pour lui montrer ta création !

Ça ne marche pas ?

Pas de panique, c’est normal ! Direction la Partie 8 — Dépannage pour trouver la solution.

PARTIE 8 — DÉPANNAGE : LES SOLUTIONS À TES PROBLÈMES

Objectif : Résoudre les problèmes courants.

Problème 1 : Les LEDs ne s’allument pas

Symptôme : Les LEDs restent éteintes même quand tu cliques sur les boutons.

Cause probable :

• Câblage incorrect (inversion des pattes de la LED ou oubli de la résistance).
• Broches mal déclarées dans le code Arduino.

Solution :

1. Vérifie que la patte longue de la LED est branchée sur la broche Arduino (13 ou 12) et la patte courte sur la masse (GND) via une résistance.
2. Vérifie que les broches sont bien déclarées dans le code :const int ledPin13 = 13; const int ledPin12 = 12;
3. Teste les LEDs manuellement en branchant directement la patte longue sur le 5V (avec résistance).

Comment vérifier :

• Ouvre le moniteur série et cherche les messages "Led13 on" ou "Led12 on". Si tu les vois mais que les LEDs ne s’allument pas, c’est un problème de câblage.

Problème 2 : La jauge du potentiomètre ne bouge pas

Symptôme : La jauge reste à 0% même quand tu tournes le potentiomètre.

Cause probable :

• Câblage incorrect du potentiomètre (broche du milieu non connectée à A0).
• Code Arduino mal configuré pour lire la valeur analogique.

Solution :

1. Vérifie que la broche du milieu du potentiomètre est branchée sur A0.
2. Vérifie que les autres broches sont branchées sur 5V et GND.
3. Dans le code Arduino, vérifie que la broche est bien déclarée :const int potPin = A0;
4. Teste le potentiomètre manuellement en affichant sa valeur dans le moniteur série :Serial.println(analogRead(A0));

Comment vérifier :

• Tourne le potentiomètre et observe le moniteur série. Si la valeur change, c’est un problème avec l’interface web (vérifie la connexion MQTT).

Problème 3 : L’interface web affiche "Déconnecté"

Symptôme : La page web affiche "Déconnecté" et les boutons ne fonctionnent pas.

Cause probable :

• RabbitMQ n’est pas lancé ou l’IP est incorrecte.
• Le port WebSocket (1883) est bloqué par un pare-feu.

Solution :

1. Vérifie que RabbitMQ est lancé dans Docker :
   • Ouvre Docker Desktop et vérifie que le conteneur rabbitmq est en cours d’exécution.
   • Si ce n’est pas le cas, lance-le avec : docker run --name rabbitmqWeb -p 5672:5672 -p 15672:15672 -p 15675:15675 -p 1883:1883 rabbitmq:3.13-management
2. Vérifie que l’IP du broker MQTT est correcte dans le code HTML :host: '192.168.1.XX', // Remplace XX par l'IP de ton ordinateur
3. Vérifie que le port 1883 est ouvert :
   • Sur Windows : Ouvre le pare-feu et autorise le port 1883.
   • Sur Mac/Linux : Vérifie avec netstat -tuln | grep 1883.

Comment vérifier :

• Ouvre MQTT Explorer et essaie de te connecter au broker avec les mêmes identifiants que dans le code HTML. Si ça ne marche pas, c’est un problème de broker.

Toujours bloqué ?

Pas de panique ! Voici ce que tu peux faire :

1. Relis les étapes : Vérifie que tu n’as pas sauté une étape du câblage ou du code.
2. Cherche des indices : Les messages dans le moniteur série sont tes meilleurs amis.
3. Demande de l’aide :
   • Poste une photo de ton montage et une capture d’écran du moniteur série dans notre groupe Facebook.
   • Décris précisément ce qui ne marche pas (ex : "La LED 13 s’allume mais ne s’éteint pas quand je clique").
   • On est là pour t’aider !

PARTIE 9 — RÉSUMÉ : CE QU’ON A FAIT ENSEMBLE

Objectif : Faire le bilan des compétences acquises.

Ce qu’on a accompli

On a construit un système malin où ton Arduino discute avec ton téléphone comme deux potes qui s’envoient des messages. Voici ce qu’on a fait :

1⃣ On a branché les composants : deux LEDs et un potentiomètre sur l’Arduino, comme des musiciens prêts à jouer.

2⃣ On a installé RabbitMQ (le "standardiste") dans Docker pour qu’il transmette les ordres entre ton téléphone et l’Arduino.

3⃣ On a configuré MAMP pour afficher une page web sur ton téléphone, avec des boutons pour contrôler les LEDs et une jauge pour le potentiomètre.

4⃣ On a codé l’Arduino pour qu’il :

• Se connecte au WiFi (comme quand tu te connectes à ta box).
• Écoute les messages MQTT (les "SMS" du projet).
• Allume/éteint les LEDs ou renvoie la valeur du potentiomètre. 5⃣ On a testé et débogué : on a vérifié que tout fonctionnait et corrigé les erreurs.

Ce que tu peux faire maintenant

Avec ce projet, tu as toutes les clés pour créer tes propres systèmes connectés :

• Une station météo : Ajoute un capteur de température et affiche les données sur ton téléphone.
• Un système d’arrosage automatique : Utilise un relais pour contrôler une pompe à eau.
• Un robot télécommandé : Ajoute des moteurs et contrôle-les depuis ton navigateur.

Le plus beau ? Tu peux tout adapter à tes idées !

PARTIE 10 — ALLER PLUS LOIN : ET MAINTENANT ?

Objectif : Donner des idées pour aller plus loin.

3 projets pour continuer

1. Station météo connectée
   • Ajoute un capteur DHT11 pour mesurer la température et l’humidité.
   • Affiche les données sur ton interface web avec des graphiques.
   • Matériel : DHT11 (5€), câbles.
2. Système d’arrosage automatique
   • Utilise un relais pour contrôler une pompe à eau.
   • Programme l’arrosage en fonction de l’humidité du sol (capteur FC-28).
   • Matériel : Relais (3€), pompe à eau (10€), capteur FC-28 (5€).
3. Robot télécommandé
   • Ajoute des moteurs et un module L298N pour les contrôler.
   • Contrôle le robot depuis ton téléphone avec des boutons directionnels.
   • Matériel : 2 moteurs DC (10€), module L298N (5€), châssis (15€).

Ressources pour aller plus loin

• Tutoriels :
  • Créer une station météo avec Arduino
  • Contrôler un robot avec MQTT
• Communauté :
  • Rejoins notre groupe Facebook pour poser tes questions.
  • Participe à nos live YouTube pour des projets en direct.
• Outils :
  • MQTT Explorer : Pour visualiser les messages MQTT.
  • PlatformIO : Un IDE plus puissant que l’IDE Arduino.

Ton prochain défi

Mission : Ajoute une troisième LED à ton projet et contrôle-la depuis ton interface web.

• Indice : Il suffit de dupliquer le code pour la LED 13 ou 12 et de modifier les broches.

Partage ton résultat avec le hashtag #PlaisirArduino – on a hâte de voir tes créations !

5. VOCABULAIRE CLÉS

6. POINTS D'ATTENTION PÉDAGOGIQUE

• Pour les débutants :
  • Insiste sur l’importance de vérifier le câblage avant de coder.
  • Explique que les résistances sont obligatoires pour les LEDs (risque de griller le composant).
  • Montre comment utiliser le moniteur série pour déboguer.
• Pour les intermédiaires :
  • Encourage à modifier le code pour comprendre comment ça marche.
  • Propose des exercices rapides (ex : changer la fréquence d’envoi des données).
  • Montre comment adapter le projet (ajouter des capteurs, des moteurs, etc.).
• Pour tous :
  • Rassure : Les erreurs sont normales, même les pros en font !
  • Encourage : Partage tes résultats et pose des questions.
  • Inspire : Montre des exemples de projets réalisés par la communauté.

Félicitations ! Tu as maintenant toutes les clés pour créer des projets Arduino connectés. À toi de jouer !

Cet article Cours Complet : Arduino + MQTT + Web – Contrôle tes LEDs depuis ton téléphone 🚀 est apparu en premier sur PlaisirArduino.

1. Objectif pédagogique

À la fin de ce cours, vous saurez :

• Comprendre le rôle et les limites de l’EEPROM interne d’un Arduino.
• Lire et écrire des données persistantes avec EEPROM.read() et EEPROM.write().
• Optimiser les écritures avec EEPROM.update().
• Sauvegarder et relire des variables complètes avec EEPROM.put() et EEPROM.get().
• Créer un projet simple qui conserve ses paramètres après extinction.

Précaution à prendre

En quelque minutes les cellules EEPROM peuvent se détérioré et altéré votre carte.

2. Présentation de L'EEPROM

Qu’est‑ce que l’EEPROM ?
L’EEPROM (Electrically Erasable Programmable Read-Only Memory) est une mémoire non volatile : elle garde les données même sans alimentation.

Caractéristiques :

• Capacité limitée : ex. 1024 octets sur un Arduino Uno.
• Accès octet par octet ou via des variables complètes.
• Durée de vie ~100 000 écritures par cellule (éviter les écritures inutiles).

Applications : sauvegarde de paramètres, compteurs, scores, restauration d’état après redémarrage.

3. Matériel nécessaire

• Arduino Uno (ou Nano, Mega…)
• Câble USB
• (Optionnel) Bouton poussoir + résistance 10 kΩ
• (Optionnel) LED + résistance 220 Ω

Schéma minimaliste : pour les premiers exemples, aucun câblage n’est requis.

4. Explication du fonctionnement

L’EEPROM est organisée en cases numérotées (adresses). Chaque case stocke un octet (0–255). Imaginez un meuble avec 1024 tiroirs : chaque tiroir peut contenir un petit papier avec un nombre. Quand vous éteignez l’Arduino, les papiers restent en place.

5. Premier code minimaliste

Exemple simple : écrire puis lire un octet à l’adresse 0.

#include <EEPROM.h>

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

  // Écrire 42 à l'adresse 0
  EEPROM.write(0, 42);

  // Lire la valeur stockée à l'adresse 0
  byte valeur = EEPROM.read(0);

  Serial.print("Valeur lue : ");
  Serial.println(valeur);
}

void loop() {
  // Vide
}

Ce que fait ce code : écrit le nombre 42 à l'adresse 0, puis le relit et l'affiche sur le moniteur série.

6. Décryptage du code

• #include <EEPROM.h> : active la bibliothèque EEPROM.
• EEPROM.write(adresse, valeur) : écrit un octet.
• EEPROM.read(adresse) : lit un octet.
• Les adresses vont de 0 à EEPROM.length()-1.
• Erreur fréquente : écrire trop souvent (surtout dans loop()) use la mémoire.

7. Expérimentation guidée

Propositions faciles :

• Changer la valeur écrite (ex. EEPROM.write(0, 100)).
• Utiliser une autre adresse (ex. adresse 10).
• Écrire plusieurs valeurs et les relire.

8. Fonctions avancées

En complément de read() et write(), Arduino fournit :

EEPROM.update(adresse, valeur)

Écrit seulement si la valeur est différente de celle déjà stockée — utile pour économiser les cycles d'écriture.

#include <EEPROM.h>

void setup() {
  Serial.begin(9600);
  EEPROM.update(0, 42); // Écrit seulement si nécessaire
  Serial.println("Valeur mise à jour !");
}

void loop() {}

EEPROM.put(adresse, variable)

Permet d'enregistrer une variable complète (int, float, struct...) en une seule instruction.

#include <EEPROM.h>

struct Donnees {
  int compteur;
  float temperature;
};

Donnees info;

void setup() {
  Serial.begin(9600);
  info.compteur = 123;
  info.temperature = 24.5;
  EEPROM.put(0, info);
  Serial.println("Données sauvegardées !");
}

void loop() {}

EEPROM.get(adresse, variable)

Lit directement une variable complète depuis l'EEPROM (complément de put).

#include <EEPROM.h>

struct Donnees {
  int compteur;
  float temperature;
};

Donnees info;

void setup() {
  Serial.begin(9600);
  EEPROM.get(0, info);
  Serial.print("Compteur : ");
  Serial.println(info.compteur);
  Serial.print("Température : ");
  Serial.println(info.temperature);
}

void loop() {}

Astuce : put() et get() gèrent automatiquement la taille en octets — attention à la place restante dans l'EEPROM.

9. Vérification avant écriture dans l’EEPROM

Avant d’enregistrer une donnée en mémoire EEPROM, il est essentiel de vérifier que sa valeur a réellement changé. En effet, si la donnée est identique à celle déjà stockée, une réécriture inutile détériorera prématurément la cellule mémoire, qui ne supporte qu’un nombre limité de cycles d’écriture. Pour protéger la durée de vie de l’EEPROM, il faut donc ajouter systématiquement une étape de vérification avant d’écrire.

Voici un exemple fiable et simple, utilisable pour tout type de donnée basique (comme un octet) :

#include <EEPROM.h>

int adresse = 0;         // Adresse mémoire EEPROM
byte nouvelleValeur = 42; // Valeur à écrire

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

  // Lire la valeur actuelle dans l’EEPROM
  byte ancienneValeur = EEPROM.read(adresse);

  // Vérifier si la valeur a changé avant d’écrire
  if (ancienneValeur != nouvelleValeur) {
    EEPROM.write(adresse, nouvelleValeur);
    Serial.println("Valeur mise à jour dans l’EEPROM.");
  } else {
    Serial.println("Valeur identique, écriture évitée pour préserver l’EEPROM.");
  }
}

void loop() {
  // Rien ici
}

Cette méthode simple protège efficacement l’EEPROM contre les écritures redondantes et prolonge sa durée de vie.

Exemple fiable de vérification avant écriture avec EEPROM.get() et EEPROM.put()

Pour éviter d’écrire inutilement dans l’EEPROM une structure Donnees, on peut comparer la donnée à écrire avec celle déjà stockée, puis n’écrire que si elles diffèrent.

#include <EEPROM.h>

struct Donnees {
  int compteur;
  float temperature;
};

Donnees infoNew;  // Nouvelle donnée à sauvegarder
Donnees infoOld;  // Donnée lue depuis EEPROM

void setup() {
  Serial.begin(9600);
  delay(1000); // Attente pour le moniteur série

  // Initialisation des nouvelles données
  infoNew.compteur = 123;
  infoNew.temperature = 24.5;

  // Lire la donnée existante dans EEPROM à l'adresse 0
  EEPROM.get(0, infoOld);

  // Comparer byte à byte pour vérifier si les données ont changé
  if (memcmp(&infoNew, &infoOld, sizeof(Donnees)) != 0) {
    EEPROM.put(0, infoNew);
    Serial.println("Données mises à jour dans l’EEPROM.");
  } else {
    Serial.println("Données identiques, écriture évitée.");
  }
}

void loop() {
  // Rien ici
}

10. Résumé

• Lecture/écriture d'octets : read() / write().
• Éviter les écritures inutiles : update().
• Stocker/charger des variables complètes : put() / get().
• Penser à la taille disponible et à l'usure des cellules.

Ressources complémentaires

• Documentation officielle : arduino.cc — EEPROM
• Bibliothèque EEPROM.h incluse par défaut
• Conseil pratique : limiter les écritures inutiles pour préserver la mémoire

Cet article La persistance des données EEPROM est apparu en premier sur PlaisirArduino.

Caractéristiques du ruban à LED adressage

Type: WS2812B

Alimentation: 18 mA/LED 5V ne supporte pas les surtensions, une alimentation stable est recommandée.

La bibliothèque de gestion des LEDs que j'ai utilisée est "Adafruit_NeoPixel.h".

Le projet est relativement simple à mettre en oeuvre sur un petit nombre de LEDs. J'ai pris comme point de départ l'exemple "simple" que j'ai retravaillé.

La bibliothèque Adafruit NeoPixel pour Arduino est conçue pour faciliter la gestion des LED RGB individuelles ou des bandes de LED RGB, telles que les populaires LED WS2812 ou WS2812B. Voici quelques-unes des fonctions natives de cette bibliothèque :

1. Adafruit_NeoPixel pixels(nombre de pixels, branche de sortie, neoPixelType type)

• Initialise la bibliothèque en spécifiant le nombre total de pixels, le numéro de broche à laquelle les pixels sont connectés et le type de pixels (par exemple, NEO_GRB ou NEO_RGB).

1. begin()

• Initialise la communication avec les pixels. Cette fonction doit être appelée une fois dans le programme, généralement dans la fonction setup().

1. show()

• Envoie les données de couleur aux pixels. Vous devez appeler cette fonction après avoir modifié les couleurs des pixels pour les rendre effectives.

1. setPixelColor(numéro de la LED adressable, couleur rouge de 0 à 255, couleur vert de 0 à 255, <strong><code>couleur bleu de 0 à 255)

• Définit la couleur d'un pixel spécifique en spécifiant les valeurs des composants rouge, vert et bleu (RVB). Les valeurs des composants RVB vont de 0 à 255.

1. setPixelColor(uint16_t n, uint32_t color)

• Version alternative de setPixelColor où vous spécifiez directement la couleur sous forme d'un entier 32 bits, où les 8 premiers bits représentent le rouge, les 8 suivants le vert et les 8 derniers le bleu.

1. setBrightness(intensité de 0 à 255)

• Ajuste la luminosité de tous les pixels. La valeur de luminosité varie de 0 (éteint) à 255 (pleine luminosité).

1. Color(uint8_t red, uint8_t green, uint8_t blue)

• Fonction utilitaire qui renvoie une couleur sous forme d'entier 32 bits à partir des composants RVB spécifiés.

1. ColorHSV(uint16_t hue, uint8_t saturation, uint8_t value)

• Fonction utilitaire qui renvoie une couleur sous forme d'entier 32 bits à partir des composants HSV (teinte, saturation, valeur) spécifiés.

1. getPixelColor(uint16_t n)

• Récupère la couleur d'un pixel spécifique sous forme d'entier 32 bits.

1. clear()
   • Éteint tous les pixels en les mettant à la couleur noire (0, 0, 0).

Ces fonctions de base devraient vous aider à démarrer avec la gestion des LEDs à l'aide de la bibliothèque Adafruit NeoPixel dans vos projets Arduino. N'oubliez pas de consulter la documentation officielle pour des détails plus approfondis sur chaque fonction : https://learn.adafruit.com/adafruit-neopixel-uberguide/arduino-library.

Merci pour votre intérêt, vous pouvez revoir toutes les vidéos sur la chaine Youtube plaisirarduino

Cet article Ruban à l’LED adressable est apparu en premier sur PlaisirArduino.

Le broker qu’est-ce que c’est ?

Pour faire interagir la platine arduino et le web nous utilisons un broker. Son rôle est de distribuer les messages aux ensembles des objets IOT connectés. 

Lorsque l’objet IOT a souscrit à un topic, il va recevoir tous les messages de celui - ci. Quand il publie un message tous les objets abonnés à son topic le reçoivent.

Exemple:  

Pour interagir avec les différents objets, le broker utilise le protocole MQTT. Vous n’avez pas besoin de rentrer dans la technique pour utiliser celui-ci. 

Il existe plusieurs brokers, en principe nous pouvons avoir besoin d’un broker local ou accessible par internet. 

J’ai testé le broker Mosquitto en local sur une platine rasberryPi qui remplie efficacement son rôle.

Pour ne pas vous faire acheter du matériel supplémentaire, j’ai choisi le brocker shiftr.io sur internet car il est facile à installer et la documentation remplie les exigences du projet que je souhaite réaliser. 

Etape 1: Mise en place du Broker

• Créer un compte sur shiftr.io 
• Créer le broker 
• Modifier le token avec pour paramètre l’identifiant et le mot de passe.

Ces démarches sont rapides, pour ceux qui auraient des difficultés, je vous renvoie sur la vidéo Web et arduino ci-dessus.

Etape 2: Test avec la platine Arduino

Dans un premier temps, je vous invite à installer la librairie MQTT de Joel Gaehwiller

Ensuite lancer l’exemple 

- Fichier/EXEMPLE / MQTT / ArduinoEthernetShield

- Modifier les paramètres de connexion au broker dans la fonction Connect ligne 23 avec votre identifiant et votre mot de passe du token

- Téléverser le programme et vérifier que le broker reçoit l’information

« World »  sous le topic « Hello ».

A partir de là, la platine arduino et le broker sont opérationnels.

Etape 3: Le Web 

Dans la documentation de shiftr.io vous y touverez le code source de base pour interagir avec le broker et le navigateur. 

•  Créer un dossier dans lequel vous allez y mettre trois fichiers: index.html, script.js et style.css
• Prenez le code de la documentation sous exemple browser et faites un copier/coller dans les différents fichiers.
• Tester l’envoi du message lorsque vous appuyez sur le bouton

ARDUINO ET WEB

Présentation 

Il s'agit d’allumer des diodes aux travers du navigateur, recevoir le retour d’un potentiomètre et d’agir avec un bouton poussoir sur la platine arduino.

Le broker étant opérationnel, nous n’agirons plus sur celui-ci.

Index.html

L’objectif est d’afficher deux boutons pour commander des diodes et un retour potentiomètre.

Style.css

Le fichier style.css permet de donner des paramètres d’affichage de la page index.html

Script.js

Script permet de modifier et d'actualiser la page index.html, son langage est le javascript.  

Le javascript a la particularité de modifier la page Web, même après son téléchargement celui-ci est interprété par le navigateur.  

Le premier élément, c’est la connexion au broker ligne 4, il faut renseigner ses identifiants de token

Le second élément: lignes 10 et 11 permettent de souscrire aux différents Topic. 

Le troisième élément: lignes 15 à 69 modifient le contenu des balises ou leurs styles en fonction des  messages reçus .

Exemple 

document.getElementById('led7').innerHTML = ‘ON';

Modifie le contenue de la balise qui porte l’identifiant « led7 » dans la page index.html par « ON ».

 document.getElementById("led7").style.backgroundColor="green";

Modifie le style backgroundColor de la balise qui porte l’identifiant « led7 » dans la page index.html.

Le dernier élément: ligne 71 à ligne 76 permettent de publier des messages au broker au click de bouton. 

Lorsque le bouton est appuyé le message est traité par la fonction de traitement des messages : lignes 15 à 69.

Code source arduino

Le programme est fourni gratuitement en téléchargement https://plaisirarduino.fr/telechargement  

Déclaration des variables pour les entrées / sorties de la commande des diodes et des différentes temporisations.

• Connexion avec les identifiants et mot de passe du token
• Souscription aux Topic

La fonction messageReceived traite toutes les interactions des messages reçus par le broker, elle a pour rôle de commander l’état des différentes diodes.

Dans cet exemple, lorsque la platine reçoit le message 9$Led7, elle met la diode 7 à HIGH

Le setup initialise les entrées / sorties et les différents paramètres nécessaires

La première partie de la fonction Loop renvoie toutes les 5 secondes les paramètres des diodes et ceux du potentiomètre en publiant leurs valeurs.

La seconde partie de loop renvoie les valeurs du potentiomètre, seulement quand celui-ci change de valeur.

Et enfin le traitement du bouton poussoir publie la commande de la diode 7 lorsque celui-ci est appuyé. 

Cet article WEB ET ARDUINO est apparu en premier sur PlaisirArduino.

Principe de fonctionnement

Ce cours a pour objectif d'appréhender le module RFID. Le téléchargement du code source vous permettra de mettre en application la modification de chaque block.

Le module RFID détecte des badges ou des cartes magnétiques à moins de 10 cm. Le passage d’un composant magnétique permet de lire l’identifiant de l'UID de la carte, ainsi que les données enregistrées.

Par principe, chaque carte RFID dispose de son propre UID.

De plus, les cartes ou tags répondent à une fréquence. Les tags, les plus répandus, sont à une fréquence de 13,56Mhz.

Le contenu est divisé en plusieurs secteurs, subdivisé en block et encore en données.

Certaines cartes disposent du block 0 verrouillé, c’est-à-dire non modifiable. Celui-ci contient essentiellement l’identifiant unique "UID". 

Sur le marché, vous pouvez avoir des cartes dont le cluster UID est modifiable. Dans le cadre de ce tutoriel, j’utilise des cartes dont l’UID est modifiable à 13,56Mhz et d’une capacité mémoire de 1 Ko.

Schéma du module RFID RC522

Le montage du module RFID se compose de 7 fils :

• RST/Reset   RST       —>   Pin 9 Arduino
• SPI SS      SDA(SS)  —>    Pin 10 Arduino
• SPI MOSI    MOSI      —>  Pin 11 Arduino
• SPI MISO    MISO     —>    Pin 12 Arduino
• SPI SCK     SCK      —>    Pin 13 Arduino
• GND 
• VCC 3,3V !Attention pas 5V

Lire le contenu d’un module RFID

Maintenant que nous avons vu à quoi ressemble le contenu d’un tag RFID,  passons à la pratique.

Premièrement, ajoutons la librairie MFRC522 

A ce stade, les exemples de la librairie MFRC52  permettent de lire et d’écrire (attention !!! le fait d’approcher votre carte du module en écriture modifie les informations contenues dans le tag et la rend inutilisable) . 

Voyons le résultat de l’exemple « dump info » qui est sans danger.

Exemple dump info:

Cet exemple nous donne toutes les informations de notre carte RFID . On y trouve la capacité mémoire, l’UID, les secteurs, les adresses et les données.

Vous constaterez que les données sont sous formes hexadécimales, c’est un langage  machine qui nous est incompréhensible au premier abord.

Ecrire du contenu dans le module RFID

Pour écrire une information dans le tag, il est nécessaire de définir trois choses : le secteur , l’adresse , et les données.  La modification des données se font par ligne de 16 octets.  

Nous pourrions mettre n’importe quelles données hexadécimales. En ce qui me concerne, j’ai fait le choix de faire correspondre les données, au traditionnel tableau ascii. En effet , ce langage se montre  particulièrement utile pour l’exploitation des informations par la suite.

Lançons l’exemple ReadAndWrite (Attention!! Modification du tag).

L’exécution de ce sketch a pour effet de modifier le secteur 1, le block 4 et les 16 octets hexadécimales. 

En relisant le contenu, les données à cet emplacement, vous avez 0x01, 0x02, 0x03, 0x04,0x05, 0x06, 0x07, 0x08, 0x08, 0x09, 0xff, 0x0b,0x0c, 0x0d, 0x0e, 0x0f

Retour d'expérience

Suite aux deux "programmes exemples" que je vous ai présenté, vous êtes capable de lire et d'écrire sur une carte RFID.

Dans mon expérience de l'utilisation de la carte RFID, j'ai rendu inutilisable une paire de cartes en voulant tester les différents exemples de la librairie.

Ce que j'ai constaté:

• Ne pas modifier le dernier block d'un secteur. Exemple: secteur 1 block 7, secteur 2 block 11 etc...
• Ne pas tester n'importe quel code sans le comprendre .

Cet article RFID avec Arduino est apparu en premier sur PlaisirArduino.

L'objectif de ce cours va être de présenter la commande de diode rouge, verte et bleu grâce à un navigateur Internet.

Présentation du shield ethernet.

Le Shield Ethernet utilise la broche 4 pour faire appel à la carte SD et les broches 10/11/12/13 pour l’usage du shield.

La Carte SD

La carte SD contient la page HTML que nous avons nommé "pagehtml.txt".  Vous avez le code complet en téléchargement.

Partie 1

Le programme se compose de deux parties, la phase d'initialisation qui comprend les librairies, les variables, l’instanciation ethernet et le setup.

Partie 2

La deuxième partie comprend la fonction loop qui englobe les quatre fonctions suivantes: MonURL, traitementurl,  ecritureSD et MonHTML.

MonURL

Le rôle de "monURL", est de créer une chaîne de caractères avec la variable "Mydata".  Afin qu'à chaque connexion d'un client, nous captions ses informations URL.

TraitementURL

Maintenant  que avons l'url de l'utilisateur, nous vérifions que celle-ci contient B2=1, B3=1 etc... . Dans la mesure où il y a une correspondance, on agit sur la broche en question.

EcritureSD

La fonction ecritureSD, voit son utilité dans le fait de mémoriser l’état des valeurs pour les boutons radio.

A chaque fois où un utilisateur renvoie l’information d'allumer des diodes, cette information doit être mémorisée au niveau de la page html. Le but est donc de définir si la LED rouge est égale à 1, on inscrit  la valeur checked. Car comme vous le savez, les deux boutons radio ne peuvent être actifs en même temps.

MonHTML

Restitue le contenu du fichier "pagehtml.txt".

Cet article Shield ethernet est apparu en premier sur PlaisirArduino.

Communiquer avec le port série

Pour permettre l'interaction entre processing et arduino, il est nécessaire de connaître le port de communication.

Pour l'arduino, il faut brancher la platine et repérer le port actif pour le téléversement.

Pour processing, il faut afficher la liste des ports actifs sur l'ordinateur et affecter celui qui correspond à l'arduino.

Dans ce cas, c'est le port "COM 6" qui prend pour valeur 0.

Envoyer une donnée par l'arduino 

Deux instructions sont indispensables:

Avec cette base le programme arduino est opérationnel, toutefois la donnée envoyée est toujours la même.

Envoyer une donnée par Processing

Voilà, la donnée 1 est envoyée par le port série à condition de bien mettre une valeur adaptée pour soi dans l'instruction "Serial.list[ ]". Dans mon cas,  c'est "Serial.list[0]".

Traiter la donnée avec Arduino

Les données séries sont stockées dans la variable "val". Il suffit de réceptionner la donnée val et de la traiter.

Traiter la donnée avec Processing

La variable "sb" contient la chaîne de caractère à exploiter dans le programme. Dans ce cas précis, j'ai choisi de l'afficher dans un fond blanc.

FIN

Si vous n'avez pas encore vu la vidéo de processing, je vous invite à la visionner. De plus, le code complet se trouve en téléchargement avec d'autres exemples .

Cet article Processing et port série est apparu en premier sur PlaisirArduino.

Le MAX 7219 est un circuit intégré permettant le contrôle d'afficheur sept segments jusqu'à huit digits et de matrices à leds.

L’aspect le plus important du MAX 7219 est de pouvoir être contrôlé par un bus compatible SPI, QSPI et MICROWIRE. N'utilisant que trois fils pour la communication, il permet ainsi de libérer des sorties de la carte Arduino pour d'autres usages.

Tout d’abord, je commencerai par détailler le fonctionnement  du MAX 7219  à l’aide du "datasheet". Ensuite, je vous proposerai la librairie « SPI .h » et « LedControl.h »  pour l'exploiter dans vos programmes.

Exploiter le DATASHEET.

Le "datasheet" est un document (pdf) fourni par le fabriquant du composant dans lequel nous y trouverons toutes les explications nous permettant son exploitation. Nous nous appuierons donc sur ce document et les tableaux qui y sont représentés. Vous verrez par conséquent, comment lire un "datasheet".

Le format de transmission des données série du MAX 7219

En premier lieu le MAX 7219 utilise un format de transmission sur 16Bits  de D0 à D15 représenté par le tableau ci-dessous.

• Les huit premiers bit de D0 à D7 pour des données (data). D0 étant le bit, dit de poids faible (LSB) et D7 le bit de poids fort (MSB).
• Les quatre prochains bits de D8 à D11 sont utilisés pour les adresses (registre).
• Les quatre bits de D12 à D15 restent par contre inexploités.

Ainsi, le MAX 7219 utilise 14 registres de 0xX0 à 0xXF représentés dans le tableau (N°) ci- dessous. Le registre OxXD n’étant pas exploité.

Tableau des adresses de registre

Commençons par examiner les registres « «DIGIT0 » à « DIGIT7 » représentés en hexadécimale de 0xX1 à 0xX8. En fait, ces huit registres permettent d’affecter une donnée à chaque Digit. Vous observerez qu'il y a aussi des fonctions spécifiques.

Les fonctions du MAX 7219.

1) La fonction "decode mode" - "0xx9".

Commençons par  le registre "decode Mode" "0xX9", il permet d'activer le code "B font". Le code B s'active sur les digits de votre choix en y inscrivant un bit à 1. Le tableau 4 ci-dessous, nous donne quelques exemples d'activation du  "decode mode". 

Il suffit de prendre pour exemple la deuxième ligne du tableau pour comprendre comment activer le code B. L'activation à 1 du digit 0 de l'afficheur par la donnée 0x01(héxa.) implique que seul le digit 0 sera en code B. Les sept autres digits à 0 de l'affichage ne seront pas gérés par le code B.

Par exemple, si l'on souhaite activer le code B seulement au digit quatre (4), cela nous donnera en binaire et respectivement au tableau ceci: 0001 0000 soit en hexadécimale 0x10. Nous avons donc la donnée utile à renseigner au registre "decode mode" "0xX9" pour activer le code B au digit 4 "D4". Bien-sûr, vous remarquerez que cette donnée est la suivante après 0x0f.

Qu'est-ce que le "code B" ?

Pour comprendre le code B, il faut tout d’abord savoir que c'est une fonction interne au MAX 7219 qui décode les données d'affichage selon un tableau prédéfini et représenté ci-dessous.

Plus précisément ce tableau nous montre comment, en fonction du registre appelé correspondant à un caractère , le MAX 7219 va activer les segments pour afficher les chiffres et caractères inscrits dans le tableau du code B .

Ainsi, chaque donnée d'affichage d'un caractère présent dans ce tableau sera systématiquement décodé, si le mode code B est activé au digit piloté pour l'affichage de la donnée qu'il reçoit .

Prenons le cas de l'envoi de la  donnée du chiffre quatre (4) "0x04" à afficher au digit 0 et activé en "decode Mode", tous les segments correspondant au registre du chiffre 4 seront activés pour afficher 4. Soit les segments B,C,F et G sur l'afficheur sept segments. Comme indiqué par le tableau 5.

A l'inverse, si "décode mode" n'est pas activé, seul le segment E de l'afficheur va s'allumer. Pourquoi ? Car la valeur "0x04" vaut en binaire 0000 0100 et que dans ce cas le MAX 7219 décode l'affichage suivant un mode binaire. On trouve ici un exemple important, à savoir que sans "decode mode" chaque segment est piloté individuellement en fonction du bit à 1. Le tableau 6 ci dessous représente la correspondance des huit segments via les huit bits.

En fait "decode mode" nous simplifie la tâche de façon à ne pas traiter en binaire l'affichage d'un chiffre. Ce qui impliquerait l'envoi de huit données de huit bits les unes après les autres pour piloter chaque segment. Il faut reconnaître que cela serait fastidieux.

En conclusion,  il est possible d'afficher des symboles ou caractères comme le moins "- "ou un "C" en désactivant "decode mode" au digit de notre choix.

2) LA FONCTION "intensity" - "0xXA"

Abordons à présent le registre "intensity" "0xXA". Il permet de définir l'intensité lumineuse de l'afficheur. En fonction du tableau  7, ci-dessous, il peut avoir seize (16) données, sur quatre (4) bits, possible de "0xX0" à "0xXF" (hexa.) allant du plus faible éclairage au plus fort.

LA FONCTION "scan limit" - "OxXB"

Passons ensuite au registre "scan limit" "OxXB" Il a pour rôle de définir le nombre de digits que l'on souhaite exploiter de digit0 à digit8. En fonction du tableau 8 ci-dessous, il peut prendre huit (8) données sur trois (3) bits allant de 0xX0 à 0xX7 sélectionnant ainsi les digits de droite à gauche.

Il faut souligner que le digit 0 sera toujours le minimum configurable et à juste titre, car il ne serait pas logique d'utiliser cette fonction pour une extinction générale alors qu'une fonction de ce type existe.

3) LA FONCTION "shutdown" - "OxXC".

Le registre "shutdown" "OxXC".  Il permet d'allumer ou d’éteindre l'afficheur. Suivant le tableau trois (3) ci-dessous? il ne prend que deux (2) données sur un (1) bit soit "0xX0" ou "0xX1". A zéro (0) "0xX0" l'afficheur est éteint.

4) LA FONCTION "Display test" - "0xXF"

Et enfin, le registre "Display test" "0xXF", il permet de tester l'afficheur en activant toutes les leds de l'afficheur. En fonction du tableau dix (10)  comme "shutdown", il ne prend que deux (2) données sur un (1) bit soit "0xX0" ou "0xX1". A un (1) le mode test de l'afficheur est activé.

Cependant, il est à noter que le mode test reste activé tant qu'une donnée de désactivation "0xX0" n'est pas renvoyé au registre "0xXF".

Concrètement, nous venons de passer en revue les fonctions de registre ainsi que leurs données d'exploitation.

Mais nous ne savons toujours pas comment les transmettre au MAX.

L'ENVOI DES DONNÉES.

Avant propos: Les données transmises.

Dans nos programmes, il va falloir remplacer le "X" majuscule, dans les données des tableaux, par le chiffre ou la lettre correspondant à la bonne donnée hexadécimale.

Prenons le cas de la donnée "0xX6". En premier lieu, regardons les deux premiers "caractères" "0x", ils indiquent que la donnée et de type HEXADÉCIMALE. Voyons ensuite les deux prochain caractères "X6". Ces derniers sont la transcription hexadécimale d'une donnée en bits. Hors le format Hexadécimale n'accepte pas le terme "X" il va donc falloir le remplacer. Mais par quoi ?

Pour le savoir, il suffit d'utiliser la calculette du "PC" en mode programmeur sur "hexa" et "octet" et de reprendre les bits du tableau, en l’occurrence le sept (7), en cliquant sur les bits affichés en calculette. Avec 0000 0110 on trouve 6, ce qui nous fait "06" car ce format s'écrit sur deux caractères et le premier a par défaut 0, si il n'est pas affiché.

A partir de là "0xX6" devient "0x06".

Toutefois, il sera possible de l'écrire simplement par zéro "0 ou un "1" lorsque la donnée n'est que sur un (1) bit.

Le format d'envoi.

Avant tout chose, elles doivent respecter ce que l'on appelle un format d'envoi. Et c'est donc dans vos programmes que ce format devra être respecté.

Nous venons de voir précédemment qu'il fallait renseigner une adresse et sa donnée pour activer la fonction d'un registre. Il nous faudra donc les envoyer toutes les deux.

Considérons une fonction de transfert de données constituée des deux paramètres utiles "adresse" et "data". (data = données en anglais).

• void transfert(adresse, data);

Pour une compréhension aisée, prenons par exemple, la fonction "Display test" qui a pour adresse "0xXF",  si l'on souhaite l'activer, il faut donc  inscrire "0xX1" comme donnée.

En conclusion, cela nous donne en paramètre de fonction.

• void transfert(0x0F, 0x01); //Transfert des données.

La fonction transférera de notre carte Arduino vers le MAX7219,  les données selon le protocole choisi via le port série. Dans notre cas, c'est le SPI que nous utiliserons.

LA COMMUNICATION

LE S.P.I.

Le Max 7219 peut fonctionner avec plusieurs protocoles de communication bus. Mais dans ce tutoriel, nous utiliserons et ne parlerons que du protocole de bus SPI qui transmet les données de la platine Arduino vers le MAX 7219.

Qu'est ce que le SPI "Serial Peripheral Interface" ? C'est une communication sur le principe du maître-esclave. Ce qui veut dire que la transmission des données ne se fait que dans un seul sens du maître vers l'esclave, donc la platine Arduino représente le maître et le MAX 7219 l'esclave. Plusieurs esclaves peuvent être reliés à ce bus série et seront sélectionnés pour réception de données via une ligne prévue à cet effet.

LA LIAISON SPI

Ci-dessous,nous avons le schéma de câblage de la liaison série entre la platine Arduino et le MAX 7219.

On observe trois liaisons:

1. 1. MOSI qui signifie "Master Output Slave INput" est une broche de sortie vers DIN qui est l'entrée de traitement des données série.
   2. I/O est une sortie vers LOAD (CS) qui est l'entrée d'activation de chargement de données.

1. SCK est une sortie vers CLK qui est l'entrée d' horloge série.

Le choix des différentes broches pour la liaison SPI ne s'est pas fait au hasard. Elles ont été définies par la configuration matérielle de la carte Arduino en fonction du mode SPI. Pour le savoir, il faut consulter la documentation de la carte Arduino pour le mode SPI.

Il existe d'autres broches, de type mâle, facilement reconnaissable pour installé cette liaison.

Premièrement la broche onze (11) MOSI configurée en mode sortie va envoyer les données sous forme de suite de bit zéro(0)-un(1).

Deuxièmement la broche dix (10) I/O configurée en mode sortie, activera le chargement des données dans le MAX.

Et troisièmement la broche treize (13) SCK configurée également en mode sortie, elle synchronisera et cadencera la transmission des données.

Voici la représentation schématique de la transmission au niveau du MAX7219..

C'est ainsi que se passe la transmission en fonction de l'état de chaque entrée du MAX. Vous constaterez qu'il y a aussi DOUT qui est une entrée utilisée pour connecter en série plusieurs MAX7219 ou MAX7221 mais nous ne l'utiliserons pas.

En résumé, la condition de fonctionnement de ce circuit dépend de l'état bas LOAD (CS), de l'envoi des données par MOSI et de leur synchronisation par SCK. Ce schéma illustre bien la transmission des données du  bit de poids fort D15 vers le bit de poids faible D0.

L'exploitation du bus SPI

Tout d’abord pour exploiter le MAX, il va nous falloir configurer notre port série SPI à l'aide de paramètres. Tout comme nous le faisons pour exploiter le port série du moniteur avec la fonction Serial.begin();.

Sauf qu'à la différence du port série moniteur, cela va se faire au travers d'une librairie incluse dans l'IDE de Arduino. Cette librairie s'appelle <SPI.h>

Dans le programme, interviennent plusieurs instructions qu'il va être nécessaire de comprendre.

Les instructions à connaître

Cette instruction indique que nous incluons la librairie SPI.

SPISettings est utilisée pour configurer le port SPI, il prend successivement trois paramètres:

• • La vitesse de transmission des données.

• • L'ordre d'envoi des données.

• Le mode d'envoi.

Initialise le bus SPI en utilisant les données  de SPISettings dans notre cas TransferMax7219 .

Transfert des données sous un format  de un (1) octet soit huit (8) bit.

La fonction de transfert de données

Cette tâche étant répétitive, nous avons du créer une fonction de transfert pour dialoguer aisément avec le MAX 7219 dont on fait abondamment usage dans le programme.

La fonction prend deux paramètres en considération: le registre auquel on souhaite s'adresser et  la valeur de la donnée.

Exemple:

Prenons le cas de l'exemple illustré ci-dessus. On fait appel à la fonction Trsf7219 pour transmettre au registre 0x0A « intensity » la donnée 0x06, soit la valeur 13/32. Ce qui a pour effet de modifier la luminosité de l’afficheur.

Vous savez à présent exploiter l'utilisation des données et leur transmission vers le MAX via la communication SPI. Néanmoins, il existe un moyen plus simple de transférer des données vers le MAX. Ce moyen est une librairie que l'on appelle <LedControl.h>

Utilisation de LedControl

LedControl  est une librairie simple qui offre des fonctions simplifiées de transfert de données vers le MAX7219 rendant ainsi la programmation d'un afficheur sept segments ou d'une matrice plus souple et conviviale. Elle utilise des fonctions sous forme de  texte bien documenté et qui  permettent de réaliser de nombreuses choses.

Les fonctions de bases

Après avoir téléchargé la librairie <ledcontrol.h>, il est nécessaire de l'inclure au programme.

Ci-dessous LedControl est déclaré par une instance d'un objet et appelé "septSegMax" dans notre programme. Cette fonction prend trois (3) paramètres, définis par le câblage de la platine Arduino et un (1), la dernière valeur correspond  au nombre de contrôleur présent sur le bus.

L'objet "septSegMax" servira donc à faire appel aux fonctions fournies par <LedControl.h>.

• Le premier paramètre définit la broche 10 de l'Arduino comme étant LOAD CS
• Le deuxième paramètre définit la broche 13 de l'Arduino comme étant CLK
• Le troisième paramètre définit la broche 11 de l'Arduino comme étant le MOSI
• Le dernier paramètre correspond au nombre de MAX7219 utilisé. Ici un (1).

Voyons enfin les fonctions de <LedControl.h>

La fonction shutdown();

Cette fonction permet d'allumer ou d’éteindre le MAX 7219. Si la valeur est false, le circuit fonctionne normalement et à l'inverse, true le circuit est éteint. Vous constatez de toute évidence que les registres précédemment utilisés ont été remplacés par des fonctions de sorte que leurs noms soient évocateurs à rôle. Dans notre cas, shutdown(paramètre1, paramètre2 ); il faut reconnaître que cela est bien plus simple.

La fonction setIntensity();

Vous l'aurez deviné cette fonction permet de définir l'intensité lumineuse de l'afficheur en 16 valeurs différentes; 15 étant notamment  le maximum représentant le nombre de données possible que l'on a vu dans le tableau sept (7).

La fonction clearDisplay();

Cette fonction éteint l'afficheur et supprime toutes les données précédentes.

Schéma de montage

Schéma Afficheur Sept Segments

Maintenant pour utiliser le Max 7219, nous allons faire un montage type avec deux afficheurs 4 digits,  dont il est possible de câbler qu'un seul afficheur.

Vous trouverez un sketch pour 8 et 4 digits en téléchargement. .

Schéma Matrice 1588BS

Constater que les digits de la matrice correspondent à la cathode commune et que les segments à l'anode commune, ceci inverse l'utilisation de la librairie LedControle où les colonnes correspondent aux segments et les digits aux lignes.  Après avoir tester plusieurs montages celui-ci a été le plus fonctionnel.

Cet article MAX 7219 est apparu en premier sur PlaisirArduino.

SCHEMA

Cet article Matrice à LED est apparu en premier sur PlaisirArduino.

Comment utiliser les fonctions loop et setup lorsqu' on est débutant ? Voici une vidéo qui vous guidera dans vos premiers pas dans l'univers de la programmation Arduino sur une base du langage C++.

Résumé

Je vous présente six sketchs pour vous parler des fonctions loop et setup .

Je présente dans les premiers sketchs le moniteur série, cela va permettre d’avoir un visuel du fonctionnement de loop et setup .

Le premier sketch est composé de deux lignes Serial.begin(); et Serial.print();.
Serial.begin(); a pour utilité d’initialiser la vitesse de transmission des données série pour communiquer avec le moniteur série, il sera toujours déclaré dans la fonction setup.

Serial.print("SALUT"); est déclaré dans la fonction setup, regardons son comportement avec le moniteur série.

Celui-ci affiche simplement "SALUT" parce que setup n'a pour l’instant que deux instructions: utiliser le moniteur serie et afficher "SALUT".

Passons à l’instruction Serial.print(); "SALUT" dans la fonction loop et observons son comportement.

Celui-ci affiche "SALUT"  à répétition parce que la fonction loop n'a que cette instruction à exécuter. La fonction loop se répète continuellement et chaque affichage correspond à un cycle de lecture programme.

—————————————————————————————————

Le prochain sketch consiste à vous montrer deux choses. le comportement de la fonction loop et celui du moniteur série.

J’ ai intégré une variable "i" qui s’incrémente dans la boucle, on constate que cette variable progresse d'une unité à chaque fois.

Maintenant, le fait de relancer le moniteur série, la variable revient à sa valeur de départ.

Ce que  je veux vous montrer, c’est que le moniteur série effectue un re-set de la carte Arduino lorsque qu’il est lancé.

——————————————————————————————————

Dans le prochain sketch,

J’ai fait le montage d’une diode avec une résistance série de 220 ohm
connectée sur la broche 12 pour observer le comportement de celle-ci.

Dans la fonction setup, j’ai mis une temporisation de 5 secondes avant de pouvoir voir la diode s’allumer une fois et ensuite s’éteindre.

C’est ce que fait ce programme .

Maintenant pour revoir cet événement se produire, je relance le moniteur série; et 5 secondes après la diode s’allume à nouveau, ce qui confirme que le moniteur effectue un re-set de la carte.

—————————————————————————————-

Dans le sketch 5,

Je reprends seulement les instructions digitalWrite(); pour les mettre dans la fonction loop, je téléverse et observe le comportement de la diode.

Celle-ci clignote à intervalle d’une seconde de manière permanente, tant qu’il n’y a pas une intervention de notre part.

Avant de passer au dernier sketch, je souhaite vous montrer le comportement de la diode si on retire le délai de 1 seconde à la fin de la boucle.

Voilà ce qui se passe: la diode ne s’éteint plus, en fait en réalité elle s’éteint mais en recommençant la boucle: la diode à l’instruction de se rallumer instantanément, ce qui est imperceptible à l’œil nu.

———————————————————————————————————-

Le but du dernier skectch, est de réaliser des instructions d’initialisation par la fonction setup et ensuite de passer à la fonction loop qui va exécuter en boucle les instructions demandées:  digitalWrite(12,HIGH); broche 12 à l’état haut, ensuite attendre 1 seconde, puis digitalWrite(12,LOW); broche 12 à l’état bas , attendre 1 seconde et cela en boucle jusqu'à ce que l’on intervienne par le bouton re-set, qu'on lance le moniteur série ou qu’on débranche la carte.

On a fait le tour de comment fonctionne les fonctions setup et loop.

FIN.

A travers l'Arduino vous touchez du bout des doigts à l'univers passionnant de l’électronique et de sa programmation. Découvrez et apprenez en explorant nos tutoriels et en téléchargeant les codes sources en exemple.

MERCI.

Cet article Les fonctions loop et setup Arduino est apparu en premier sur PlaisirArduino.