Réaliser des projets IoT simples avec Arduino UNO, ESP-01, ThingSpeak et MIT App Inventor

Composants et fournitures

Arduino UNO	×	1
ESP8266 ESP-01 (Espressif)	×	1
Capteur température/humidité DHT22	×	1
Capteur température sol DS18B20 (1-Wire)	×	1
LDR (Photorésistance)	×	1
Module relais 2 canaux 5V CC	×	1

Applications et services en ligne

Arduino IDE - Environnement de développement
ThingSpeak API - Plateforme IoT cloud
MIT App Inventor - Création d'applications Android sans code

À propos de ce projet

Objectif : collecter des données d'une unité locale et les envoyer sur Internet. Un utilisateur n'importe où peut consulter ces données et envoyer des commandes aux actionneurs de l'unité locale. Tout capteur ou actionneur peut être utilisé.

Réaliser des projets IoT simples avec Arduino UNO, ESP-01, ThingSpeak et MIT App Inventor

La majorité de mes travaux IoT utilisaient NodeMCU puis ESP32. Mais il est important de ne pas oublier mes débuts avec Arduino UNO et l'ESP8266-01. Je reviens ici sur ces dispositifs avec plus d'expérience, les connectant au cloud via ThingSpeak.com. Nous contrôlerons aussi à distance via une application Android développée avec MIT App Inventor.

ThingSpeak.com est le centre du projet. L'unité locale (UNO/ESP-01) capture les données capteurs et l'état des actionneurs, les envoie vers Internet ("écriture" sur un Canal Statut ThingSpeak). Elle reçoit aussi des données ("lecture" depuis des Canaux Actionneurs ThingSpeak).

Une application Android lit les données du Canal Statut pour l'utilisateur. Celui-ci, basé sur ces infos, envoie des commandes aux actionneurs en écrivant sur les Canaux Actionneurs (voir diagramme de blocs).

Étape 1 : Introduction

Avec des capteurs courants, nous collectons plusieurs données envoyées au cloud. ThingSpeak.com, plateforme IoT ouverte, permet de collecter, analyser et agir sur ces données.

Données capteurs :

Température air et humidité relative
Température et humidité sol
Luminosité

Actionneurs :

Pompe électrique
Lampe électrique

L'état des actionneurs (MARCHE/ARRÊT) est aussi envoyé au cloud.

Logique de décision utilisateur :

Activer la pompe si humidité sol trop basse
Activer la lampe si température sol trop basse

Commande à distance via application Android.

Étape 2 : Nomenclature (BoM)

Arduino UNO - 10,00 $
ESP8266-01 - 3,50 $
DHT22 - 9,00 $
DS18B20 (sonde sol) - 6,00 $
YL-69 + LM393 (humidité sol) - 2,00 $
LDR - 0,20 $
2 LEDs (Rouge, Verte)
Module relais 2 canaux 5V CC avec optocoupleur (déclenchement niveau bas) - 7,00 $
Pompe 5V CC - 3,00 $
Lampe 220V
Résistances : 2×330Ω (LEDs), 2×10kΩ (DHT22, LDR), 1×4,7kΩ (DS18B20)
Platine d'essai, fils de liaison, alimentation 5V CC externe pour relais

Étape 3 : Matériel

Assemblez et testez par étapes :

Installer et tester tous les capteurs localement
Configurer l'ESP-01 (BareMinimum)
Repasser l'ESP-01 en configuration finale et tester
Configurer le canal Statut ThingSpeak
Installer le code ThingSpeak sur Arduino et vérifier les capteurs sur le cloud
Développer la v1 de l'appli Android (affichage statut/messages)
Installer les actionneurs (LEDs, relais)
Configurer les canaux Actionneurs ThingSpeak
Installer et tester le code Arduino avec actionneurs
Finaliser l'appli Android

Étape 4 : Connexion des capteurs

Bibliothèques nécessaires et configuration initiale :

// DS18B20
#include <OneWire.h>
#include <DallasTemperature.h>
#define ONE_WIRE_BUS 5
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature DS18B20(&oneWire);
int soilTemp = 0;

// DHT
#include "DHT.h"
#include <stdlib.h>
int pinoDHT = 11;
int tipoDHT = DHT22;
DHT dht(pinoDHT, tipoDHT);
int airTemp = 0, airHum = 0;

// LDR
#define ldrPIN 1
int light = 0;

// Humidité sol
#define soilHumPIN 0
int soilHum = 0;

Dans setup() et loop() :

void setup() {
  Serial.begin(9600);
  DS18B20.begin();
  dht.begin();
}
void loop() {
  readSensors();
  displaySensors();
  delay(10000);
}

Fonctions de lecture et d'affichage :

/********* Lecture capteurs *************/
void readSensors(void) {
  airTemp = dht.readTemperature();
  airHum = dht.readHumidity();
  DS18B20.requestTemperatures();
  soilTemp = DS18B20.getTempCByIndex(0);
  soilHum = map(analogRead(soilHumPIN), 1023, 0, 0, 100);
  light = map(analogRead(ldrPIN), 1023, 0, 0, 100); // LDR: 0=sombre -> 100%
}

/********* Affichage série *************/
void displaySensors(void) {
  Serial.print("airTemp (oC): "); Serial.println(airTemp);
  Serial.print("airHum (%): "); Serial.println(airHum);
  Serial.print("soilTemp (oC): "); Serial.println(soilTemp);
  Serial.print("soilHum (%): "); Serial.println(soilHum);
  Serial.print("light (%): "); Serial.println(light);
  Serial.println("");
}

Code complet : Sensors_Test.ino sur GitHub

Étape 5 : Configuration initiale ESP8266-01

L'ESP-01 sert de pont série (commandes AT). Vérifiez le baud rate : généralement 115200 en usine, à changer en 9600.

Connectez l'ESP-01 comme indiqué.
Téléversez BareMinimum (Fichier > Exemples > 01.Basics) sur l'Arduino avant de connecter l'ESP-01 (évite conflit série).
Ouvrez le moniteur série à 115200 bauds. Envoyez "AT" → doit répondre "OK".
Changez le baud rate : AT+UART_DEF=9600,8,1,0,0 (définitif).
Passez le moniteur à 9600 bauds. Testez "AT" → "OK".
Mode Station (Client) : AT+CWMODE=1
Connexion WiFi : AT+CWJAP="nom_réseau","mot_de_passe" (guillemets obligatoires).
Si "WIFI CONNECTED" et "WIFI GOT IP" → OK.
Récupérez l'IP : AT+CIFSR

Étape 6 : Test de l'ESP-01

Câblage final :

ESP-01 RX (Jaune) → UNO Pin D7
ESP-01 TX (Orange) → UNO Pin D6
ESP-01 CH_PD (Brun) → VCC 3.3V
ESP-01 RST (Bleu) → UNO Pin D8
ESP-01 VCC (Rouge) → 3.3V
ESP-01 GND (Noir) → UNO GND

Code test simple (pont série) :

#include <SoftwareSerial.h>
SoftwareSerial esp8266(6,7); // Rx=D6, Tx=D7
#define speed8266 9600
void setup() {
  esp8266.begin(speed8266);
  Serial.begin(speed8266);
  Serial.println("Test ESP8266 - commandes AT");
}
void loop() {
  while(esp8266.available()) Serial.write(esp8266.read());
  while(Serial.available()) esp8266.write(Serial.read());
}

Commandes de test :

* AT           → OK
* AT+RST       → Redémarrage + OK
* AT+GMR       → Version AT, SDK, ID, OK
* AT+CWMODE?   → Type de mode
* AT+CWLAP     → Points d'accès proches
* AT+CIFSR     → IP attribuée

Code : ESP_AT_Config.ino

Pour reconnexion auto au démarrage, ajoutez connectWiFi() dans setup() :

void connectWiFi(void) {
  sendData("AT+RST\r\n", 2000, 0);
  sendData("AT+CWJAP=\"USER\",\"PASS\"\r\n", 2000, 0);
  delay(3000);
  sendData("AT+CWMODE=1\r\n", 1000, 0);
  sendData("AT+CIFSR\r\n", 1000, 0);
  Serial.println("8266 Connecté");
}

String sendData(String command, const int timeout, boolean debug) {
  String response = "";
  EspSerial.print(command);
  long int time = millis();
  while ((time + timeout) > millis()) {
    while (EspSerial.available()) {
      char c = EspSerial.read();
      response += c;
    }
  }
  if (debug) Serial.print(response);
  return response;
}

Étape 7 : Capteurs et ESP-01 ensemble

Tous les capteurs testés + ESP-01 fonctionnel = prêt pour envoi cloud.

Étape 8 : ThingSpeak

Créez un compte sur ThingSpeak.com. Nouveau canal avec 8 champs :

Champ 1 : Actionneur 1 (Pompe)
Champ 2 : Actionneur 2 (Lampe)
Champ 3 : Temp. air (°C)
Champ 4 : Hum. air (%)
Champ 5 : Temp. sol (°C)
Champ 6 : Hum. sol (%)
Champ 7 : Luminosité (%)
Champ 8 : Réserve (compteur erreurs)

Notez les clés (Write API Key, Read API Key, Channel ID).

Étape 9 : Envoi statut vers le cloud

Écriture sur ThingSpeak via requête GET en 3 parties :

AT+CIPSTART="TCP","184.106.153.149",80 (IP api.thingspeak.com)
AT+CIPSEND=116 (longueur commande)
Chaîne GET : GET /update?api_key=VOTRE_CLE&field1=pompe&field2=lampe&field3=airTemp&field4=airHum&field5=soilTemp&field6=soilHum&field7=light&field8=reserve

Code complet d'envoi : SendingStatusTS_EXT.ino

Étape 10 : Appli Android - Partie 1 : Surveillance statut

Création interface utilisateur + blocs logiques (MIT App Inventor).

Toutes les 2s (Horloge1), appelle procédure readArduino
Lit le Canal Statut ThingSpeak via composant Web
Traite le JSON reçu, stocke dans variables globales
Convertit 0/1 actionneurs en "ARRÊT"/"MARCHE"
Affiche sur labels correspondants
Procédure Alarm : alerte si temp sol < 10°C ou hum. sol < 60% (texte clignotant via Horloge2 1s)

Code : ArduFarmBot_Status_App_EXT.aia

Étape 11 : Installation actionneurs (LEDs et relais)

Module relais optocoupleur déclenchement niveau bas, alimenté en 5V séparé. GND du relais NON connecté au GND Arduino (évite bruit). Capteurs omis sur schéma pour clarté.

Étape 12 : Configuration canaux Actionneurs ThingSpeak

2 nouveaux canaux (un par actionneur), écriture seul sur Champ 1 :

Canal 375598 → LED Rouge (Pompe) : 0=ARRÊT, 1=MARCHE
Canal 375599 → LED Verte (Lampe) : 0=ARRÊT, 1=MARCHE

Étape 13 : Code Arduino avec actionneurs (lecture commandes)

Lecture depuis ThingSpeak (GET sur /channels/ID/fields/1/last) toutes les 10s. Fonction clé : readThingSpeak(String channelID).

Code complet : ReadingCommandTS_EXT.ino

Étape 14 : Envoi commandes actionneurs (test navigateur)

URLs de test direct :

ALLUMER Pompe : https://api.thingspeak.com/update?api_key=CLE_ECRITURE_ACT1&field1=1
ETEINDRE Pompe : https://api.thingspeak.com/update?api_key=CLE_ECRITURE_ACT1&field1=0
ALLUMER Lampe : https://api.thingspeak.com/update?api_key=CLE_ECRITURE_ACT2&field1=1
ETEINDRE Lampe : https://api.thingspeak.com/update?api_key=CLE_ECRITURE_ACT2&field1=0