ESP8266 NodeMCU : envoyer des notifications pushover (Arduino IDE)

ESP8266 NodeMCU : envoyer des notifications pushover (Arduino IDE)

Dans ce guide, vous apprendrez à envoyer des notifications ESP8266 à Pushover. Pushover est un service de notification qui s’intègre à de nombreuses applications. Vous pouvez envoyer des notifications push à tous vos appareils et à plusieurs utilisateurs. Vous pouvez gérer vos notifications avec des niveaux de priorité, définir des heures de silence et définir différents sons en fonction de la notification.

ESP8266 NodeMCU Envoyer des notifications Pushover IDE Arduino

Table des matières

Nouveau sur l’ESP8266 ? Commencez ici : Premiers pas avec la carte de développement ESP8266 NodeMCU.

Présentation de Pushover

logo pushover

Pushover est une application mobile et de bureau compatible avec Android et iOS et Windows, MacOS et Linux. Il vous permet de recevoir des notifications de différentes sources et services et s’intègre à de nombreuses applications.

Vous pouvez recevoir des notifications sur tous vos appareils simultanément ou les envoyer à des groupes avec plusieurs utilisateurs. De plus, vous pouvez personnaliser des éléments tels que les niveaux de priorité, définir des heures de silence et même des sons différents en fonction du type de notification.

Tarification pushover

Vous disposez d’une période d’essai gratuite de 30 jours à partir du moment où vous vous inscrivez afin que vous puissiez expérimenter l’application. Après cela, si vous souhaitez continuer à utiliser l’application, il ne s’agit que d’un achat unique de 5 USD. Chaque utilisateur peut envoyer jusqu’à 10 000 messages par mois gratuitement. En savoir plus sur Tarification pushover.

Installation de l’application Pushover

Vous pouvez installer l’application Pushover sur votre ordinateur, votre tablette et votre smartphone. Il est compatible avec Windows, MacOS et Linux, ainsi qu’avec Android et iOS.

Téléchargez l’application sur votre smartphone et créez un compte pour commencer.

Créer une application pushover de compte

Après avoir créé votre compte, vous bénéficierez d’une période d’essai gratuite de 30 jours.

Bienvenue sur Pushover Créer un compte

Après cela, vous devrez accéder à votre adresse e-mail pour vérifier votre compte.

Obtenir la clé API pushover et la clé utilisateur

Pour envoyer des notifications à Pushover avec l’ESP8266, nous devons obtenir une clé API et la clé utilisateur (récepteur).

Pour cette étape, nous vous recommandons de vous connecter à votre compte pushover sur le navigateur de votre ordinateur. Connectez-vous ici: https://pushover.net/login.

Vous aurez accès à votre tableau de bord Pushover.

Clé utilisateur du tableau de bord pushover

Dans le coin supérieur droit, il y a la clé utilisateur. Enregistrez-le car vous en aurez besoin plus tard.

Vous pouvez également voir tous vos appareils et ajouter d’autres appareils si vous le souhaitez. Vous pouvez essayer de pousser une notification dans le coin supérieur gauche pour vérifier si les notifications fonctionnent avec votre appareil.

Faites défiler la page pour créer un jeton d’application/API.

pushover créer un jeton d'application

Donnez un nom et une description (facultatif) au jeton API. Vous pouvez également ajouter une icône à cela. Nous avons ajouté une icône d’une carte ESP8266. Ainsi, lorsque nous recevrons une notification, elle sera accompagnée de l’icône ESP8266. Enfin, créez l’application.

pushover créer une application esp8266

Maintenant, l’application apparaîtra sur votre tableau de bord sous la section Vos applications.

Application créée sur l'application pushover

Cliquez sur le nom de l’application pour obtenir son jeton API. Dans ce menu, vous pouvez également vérifier le nombre de notifications que vous avez envoyées avec ce jeton d’API.

Enregistrez le jeton d’API, car vous en aurez besoin plus tard.

Transfert de jeton d'application ESP8266

Maintenant que vous avez la clé utilisateur et le jeton API, vous pouvez commencer à envoyer des notifications ESP8266 avec Pushover.

Notifications pushover avec l’ESP8266 – Exemple de croquis

L’envoi de notifications Pushover avec l’ESP8266 est très simple grâce à son API. Vous pouvez lire la documentation de l’API de Pushover. Il vous suffit de POSTER une requête HTTPS avec l’ESP8266 avec les bons paramètres au point de terminaison API : https://api.pushover.net/1/messages.json.

Vous devez passer les paramètres suivants :

  • token : le jeton API de votre application
  • user : votre clé d’utilisateur ou clé de groupe d’utilisateurs
  • message : le contenu de la notification

Vous pouvez également passer d’autres paramètres facultatifs :

  • pièce jointe : une image en pièce jointe à envoyer avec le message.
  • appareil : le nom de l’appareil dont vous souhaitez recevoir la notification.
  • html : défini sur 1 pour activer l’analyse HTML.
  • priorité : définissez le niveau de priorité des notifications : une valeur de -2, -1, 0 (par défaut), 1 ou 2.
  • sound : le nom d’un son pris en charge pour remplacer votre choix de son par défaut—les valeurs peuvent être pushover, bike, bugle, cashregister, classic, cosmic, etc (vérifier toutes les options sonores disponibles). Vous pouvez même télécharger vos propres sons sur votre tableau de bord Pushover.
  • timestamp : un horodatage Unix d’une heure à afficher au lieu du moment où notre API a reçu la demande.
  • title : le titre de votre message, sinon le nom de votre application est utilisé.
  • url : une URL supplémentaire à afficher avec votre message (documentation).
  • url_title : un titre pour l’URL spécifiée comme paramètre url, sinon seule l’URL est affichée.

Pour plus d’informations sur tous les paramètres, veuillez consultez la documentation de l’API de Pushover.

Le code ci-dessous montre comment envoyer des notifications Pushover avec l’ESP8266 à l’aide d’une requête HTTPS POST.

Avant de télécharger le code sur votre carte, vous devez insérer votre SSID et votre mot de passe, la clé utilisateur et le jeton d’API Pushover App.

/*
  Rui Santos
  Complete project details at https://Raspberryme.com/esp8266-nodemcu-pushover-arduino/
  
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files.
  
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
*/

#include <ESP8266WiFi.h>
#include <ESP8266HTTPClient.h>
#include <WiFiClientSecure.h>
#include <ArduinoJson.h>

const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";

const char* apiToken = "API_TOKEN";
const char* userToken = "USER_TOKEN";

//Pushover API endpoint
const char* pushoverApiEndpoint = "https://api.pushover.net/1/messages.json";

//Pushover root certificate (valid from 11/10/2006 to 11/10/2031)
const char *PUSHOVER_ROOT_CA = "-----BEGIN CERTIFICATE-----\n"
                 "MIIDrzCCApegAwIBAgIQCDvgVpBCRrGhdWrJWZHHSjANBgkqhkiG9w0BAQUFADBh\n"
                 "MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3\n"
                 "d3cuZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBD\n"
                 "QTAeFw0wNjExMTAwMDAwMDBaFw0zMTExMTAwMDAwMDBaMGExCzAJBgNVBAYTAlVT\n"
                 "MRUwEwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5j\n"
                 "b20xIDAeBgNVBAMTF0RpZ2lDZXJ0IEdsb2JhbCBSb290IENBMIIBIjANBgkqhkiG\n"
                 "9w0BAQEFAAOCAQ8AMIIBCgKCAQEA4jvhEXLeqKTTo1eqUKKPC3eQyaKl7hLOllsB\n"
                 "CSDMAZOnTjC3U/dDxGkAV53ijSLdhwZAAIEJzs4bg7/fzTtxRuLWZscFs3YnFo97\n"
                 "nh6Vfe63SKMI2tavegw5BmV/Sl0fvBf4q77uKNd0f3p4mVmFaG5cIzJLv07A6Fpt\n"
                 "43C/dxC//AH2hdmoRBBYMql1GNXRor5H4idq9Joz+EkIYIvUX7Q6hL+hqkpMfT7P\n"
                 "T19sdl6gSzeRntwi5m3OFBqOasv+zbMUZBfHWymeMr/y7vrTC0LUq7dBMtoM1O/4\n"
                 "gdW7jVg/tRvoSSiicNoxBN33shbyTApOB6jtSj1etX+jkMOvJwIDAQABo2MwYTAO\n"
                 "BgNVHQ8BAf8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA95QNVbR\n"
                 "TLtm8KPiGxvDl7I90VUwHwYDVR0jBBgwFoAUA95QNVbRTLtm8KPiGxvDl7I90VUw\n"
                 "DQYJKoZIhvcNAQEFBQADggEBAMucN6pIExIK+t1EnE9SsPTfrgT1eXkIoyQY/Esr\n"
                 "hMAtudXH/vTBH1jLuG2cenTnmCmrEbXjcKChzUyImZOMkXDiqw8cvpOp/2PV5Adg\n"
                 "06O/nVsJ8dWO41P0jmP6P6fbtGbfYmbW0W5BjfIttep3Sp+dWOIrWcBAI+0tKIJF\n"
                 "PnlUkiaY4IBIqDfv8NZ5YBberOgOzW6sRBc4L0na4UU+Krk2U886UAb3LujEV0ls\n"
                 "YSEY1QSteDwsOoBrp+uvFRTp2InBuThs4pFsiv9kuXclVzDAGySj4dzp30d8tbQk\n"
                 "CAUw7C29C79Fv1C5qfPrmAESrciIxpg0X40KPMbp1ZWVbd4=\n"
                 "-----END CERTIFICATE-----\n";

// Create a list of certificates with the server certificate
X509List cert(PUSHOVER_ROOT_CA);

void setup() {
  Serial.begin(115200);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.println("Connecting to WiFi...");
  }
  Serial.println("Connected to WiFi");

  // Set time via NTP, as required for x.509 validation
  configTime(3 * 3600, 0, "pool.ntp.org", "time.nist.gov");
  Serial.print("Waiting for NTP time sync: ");
  time_t now = time(nullptr);
  while (now < 8 * 3600 * 2) {
    delay(500);
    Serial.print(".");
    now = time(nullptr);
  }
  Serial.println("");
  struct tm timeinfo;
  gmtime_r(&now, &timeinfo);
  Serial.print("Current time: ");
  Serial.print(asctime(&timeinfo));


  //Make HTTPS POST request to send notification
  if (WiFi.status() == WL_CONNECTED) {
    // Create a JSON object with notification details
    // Check the API parameters: https://pushover.net/api
    StaticJsonDocument<512> notification;
    notification["token"] = apiToken;
    notification["user"] = userToken;
    notification["message"] = "Hello from ESP8266";
    notification["title"] = "ESP8266 Notification";
    notification["url"] = "";
    notification["url_title"] = "";
    notification["html"] = "";
    notification["priority"] = "";
    notification["sound"] = "cosmic";
    notification["timestamp"] = "";

    // Serialize the JSON object to a string
    String jsonStringNotification;
    serializeJson(notification, jsonStringNotification);

    // Create a WiFiClientSecure object
    WiFiClientSecure client;
    // Set the certificate
    client.setTrustAnchors(&cert);

    // Create an HTTPClient object
    HTTPClient http;

    // Specify the target URL
    http.begin(client, pushoverApiEndpoint);

    // Add headers
    http.addHeader("Content-Type", "application/json");

    // Send the POST request with the JSON data
    int httpResponseCode = http.POST(jsonStringNotification);

    // Check the response
    if (httpResponseCode > 0) {
      Serial.printf("HTTP response code: %d\n", httpResponseCode);
      String response = http.getString();
      Serial.println("Response:");
      Serial.println(response);
    } else {
      Serial.printf("HTTP response code: %d\n", httpResponseCode);
    }

    // Close the connection
    http.end();
  }
}

void loop() {
  
}

Afficher le code brut

Comment fonctionne le code

Continuez à lire le fonctionnement du code ou passez à la section de démonstration.

Inclure les bibliothèques

Vous commencez par inclure les bibliothèques requises. La bibliothèque ESP8266WiFi pour connecter l’ESP8266 à votre réseau, afin qu’il puisse se connecter à internet. Les bibliothèques ESP8266HTTPClient et WiFiClientSecure seront utilisées pour effectuer des requêtes HTTP POST sécurisées, et nous utiliserons la bibliothèque ArduinoJSON pour créer une chaîne JSON afin d’envoyer tous les paramètres requis sur le corps de la requête HTTP POST.

#include <ESP8266WiFi.h>
#include <ESP8266HTTPClient.h>
#include <WiFiClientSecure.h>
#include <ArduinoJson.h>

Informations d’identification réseau

Insérez vos informations d’identification réseau dans les variables suivantes.

const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";

Jeton API et jeton utilisateur

Insérez le jeton d’API et le jeton d’utilisateur sur les variables suivantes :

const char* apiToken = "API_TOKEN";
const char* userToken = "USER_TOKEN";

Point de terminaison de l’API

Ensuite, nous définissons l’URL du point de terminaison de l’API où nous ferons les demandes. D’après la documentation, c’est comme suit :

const char* pushoverApiEndpoint = "https://api.pushover.net/1/messages.json";

Certificat SSL

Pour effectuer des requêtes HTTPS sécurisées, nous avons besoin du certificat TLS du site Web du pushover. Nous utilisons le certificat root. Il est valable jusqu’en 2031. Pour savoir comment obtenir le certificat TLS d’un site Web, vous pouvez lire ceci : Obtenir un certificat de serveur à l’aide de Google Chrome.

const char *PUSHOVER_ROOT_CA = "-----BEGIN CERTIFICATE-----\n"
                 "MIIDrzCCApegAwIBAgIQCDvgVpBCRrGhdWrJWZHHSjANBgkqhkiG9w0BAQUFADBh\n"
                 "MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3\n"
                 "d3cuZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBD\n"
                 "QTAeFw0wNjExMTAwMDAwMDBaFw0zMTExMTAwMDAwMDBaMGExCzAJBgNVBAYTAlVT\n"
                 "MRUwEwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5j\n"
                 "b20xIDAeBgNVBAMTF0RpZ2lDZXJ0IEdsb2JhbCBSb290IENBMIIBIjANBgkqhkiG\n"
                 "9w0BAQEFAAOCAQ8AMIIBCgKCAQEA4jvhEXLeqKTTo1eqUKKPC3eQyaKl7hLOllsB\n"
                 "CSDMAZOnTjC3U/dDxGkAV53ijSLdhwZAAIEJzs4bg7/fzTtxRuLWZscFs3YnFo97\n"
                 "nh6Vfe63SKMI2tavegw5BmV/Sl0fvBf4q77uKNd0f3p4mVmFaG5cIzJLv07A6Fpt\n"
                 "43C/dxC//AH2hdmoRBBYMql1GNXRor5H4idq9Joz+EkIYIvUX7Q6hL+hqkpMfT7P\n"
                 "T19sdl6gSzeRntwi5m3OFBqOasv+zbMUZBfHWymeMr/y7vrTC0LUq7dBMtoM1O/4\n"
                 "gdW7jVg/tRvoSSiicNoxBN33shbyTApOB6jtSj1etX+jkMOvJwIDAQABo2MwYTAO\n"
                 "BgNVHQ8BAf8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA95QNVbR\n"
                 "TLtm8KPiGxvDl7I90VUwHwYDVR0jBBgwFoAUA95QNVbRTLtm8KPiGxvDl7I90VUw\n"
                 "DQYJKoZIhvcNAQEFBQADggEBAMucN6pIExIK+t1EnE9SsPTfrgT1eXkIoyQY/Esr\n"
                 "hMAtudXH/vTBH1jLuG2cenTnmCmrEbXjcKChzUyImZOMkXDiqw8cvpOp/2PV5Adg\n"
                 "06O/nVsJ8dWO41P0jmP6P6fbtGbfYmbW0W5BjfIttep3Sp+dWOIrWcBAI+0tKIJF\n"
                 "PnlUkiaY4IBIqDfv8NZ5YBberOgOzW6sRBc4L0na4UU+Krk2U886UAb3LujEV0ls\n"
                 "YSEY1QSteDwsOoBrp+uvFRTp2InBuThs4pFsiv9kuXclVzDAGySj4dzp30d8tbQk\n"
                 "CAUw7C29C79Fv1C5qfPrmAESrciIxpg0X40KPMbp1ZWVbd4=\n"
                 "-----END CERTIFICATE-----\n";

Ensuite, vous devez créer une liste de certificats cert (même si vous n’avez qu’un seul certificat) avec le certificat serveur que vous souhaitez utiliser :

// Create a list of certificates with the server certificate
X509List cert(PUSHOVER_ROOT_CA);

Connectez-vous au Wi-Fi

Dans le setup(), commencez par connecter l’ESP8266 à votre réseau :

Serial.begin(115200);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
  delay(1000);
  Serial.println("Connecting to WiFi...");
}
Serial.println("Connected to WiFi");

Réglage de l’heure

Vous devez configurer l’heure sur l’ESP8266, ce qui est nécessaire pour valider le certificat.

// Set time via NTP, as required for x.509 validation
configTime(3 * 3600, 0, "pool.ntp.org", "time.nist.gov");
Serial.print("Waiting for NTP time sync: ");
time_t now = time(nullptr);
while (now < 8 * 3600 * 2) {
  delay(500);
  Serial.print(".");
  now = time(nullptr);
}
Serial.println("");
struct tm timeinfo;
gmtime_r(&now, &timeinfo);
Serial.print("Current time: ");
Serial.print(asctime(&timeinfo));

Définition des paramètres de notification

Après nous être assurés que nous sommes connectés au Wi-Fi, nous créons un objet JSON appelé notification avec les paramètres requis et certains des paramètres facultatifs. Les paramètres requis sont le jeton API, le jeton utilisateur et le message.

StaticJsonDocument<512> notification; 
notification["token"] = apiToken; //required
notification["user"] = userToken; //required
notification["message"] = "Hello from ESP32"; //required
notification["title"] = "ESP32 Notification"; //optional
notification["url"] = ""; //optional
notification["url_title"] = ""; //optional
notification["html"] = ""; //optional
notification["priority"] = ""; //optional
notification["sound"] = "cosmic"; //optional
notification["timestamp"] = ""; //optional

Comme vous pouvez le voir, le message est défini sur la ligne suivante :

notification["message"] = "Hello from ESP8266"; //required

Vous pouvez modifier le message en tout ce qui est utile pour votre application.

Nous définissons également le titre du message sur la ligne suivante :

notification["title"] = "ESP8266 Notification"; //optional

Après avoir obtenu tous les paramètres d’un objet JSON, nous le convertissons en une chaîne afin de pouvoir l’envoyer dans le corps de la requête HTTP POST.

String jsonStringNotification;
serializeJson(notification, jsonStringNotification);

Requête HTTPS POST

Maintenant, nous pouvons enfin faire la requête HTTPS POST.

En savoir plus sur les requêtes HTTPS sécurisées avec l’ESP8266 : ESP8266 NodeMCU HTTPS Requests (Arduino IDE).

En savoir plus sur les requêtes HTTP POST avec l’ESP8266 : ESP8266 NodeMCU HTTP POST avec Arduino IDE.

Créez un objet WiFiClientSecure appelé client.

WiFiClientSecure client;

Ensuite, vous devez indiquer à quels certificats le client peut faire confiance en utilisant la méthode setTrustAnchors() et en passant en argument le certificat de liste de certificats (dans ce cas, nous n’avons ajouté qu’un seul certificat).

 client.setTrustAnchors(&cert);

Ensuite, créez une instance HTTPClient appelée https.

HTTPClient https;

Initialisez le client https sur l’hôte spécifié à l’aide de la méthode begin(). Dans ce cas, nous faisons une demande sur le point de terminaison de l’API.

https.begin(client, pushoverApiEndpoint);

Ensuite, ajoutez les en-têtes HTTP POST – nous devons spécifier que nous allons envoyer les données sous forme de chaîne JSON dans le corps de la requête.

// Add headers
https.addHeader("Content-Type", "application/json");

Enfin, nous pouvons envoyer la requête POST avec les données JSON.

// Send the POST request with the JSON data
int httpResponseCode = https.POST(jsonStringNotification);

Après avoir fait la demande, nous pouvons vérifier la réponse du serveur. Ceci est utile pour savoir si la requête a réussi ou s’il y a eu des problèmes pendant la requête ou avec le corps de la requête. Pour obtenir la réponse du serveur, nous devons simplement utiliser la méthode getString() sur l’objet https.

if (httpResponseCode > 0) {
    Serial.printf("HTTP response code: %d\n", httpResponseCode);
    String response = https.getString();
    Serial.println("Response:");
    Serial.println(response);
} else {
    Serial.printf("HTTP response code: %d\n", httpResponseCode);
}

Enfin, fermez la connexion HTTPS à l’aide de la méthode end() :

https.end();

Cet exemple envoie une notification dans setup() lors de la première exécution de l’ESP8266. Donc, la boucle () est vide. L’idée est que vous utilisiez cet exemple dans votre propre application. Par exemple, pour envoyer une notification lorsqu’un mouvement est détecté, lorsqu’une lecture de capteur est supérieure ou inférieure à un certain seuil, pour envoyer régulièrement des lectures de capteur ou des états GPIO, et bien d’autres possibilités dans les domaines de la domotique et de l’IoT.

Manifestation

Après avoir inséré le SSID, le mot de passe, la clé utilisateur et la clé API, vous pouvez télécharger le code sur votre carte.

Après le téléchargement, ouvrez le moniteur série à un débit en bauds de 115200. Appuyez sur le bouton ES8266 RST pour qu’il commence à exécuter le code.

Vous devriez recevoir un message de réussite (code de réponse : 200) sur votre Serial Monitor.

ESP8266 Envoyer des notifications Pushover Serial Monitor

Et vous devriez recevoir la notification sur votre smartphone.

Nouvelle notification ESP8266 reçue sur l'application Pushover

Vous pouvez cliquer sur le message pour l’ouvrir.

Application pushover de notification ESP8266

Paramètres de transfert

Sur votre appareil, vous pouvez régler les paramètres de vos notifications. Cliquez sur l’icône (…) dans le coin supérieur droit.

Vous obtiendrez une page comme indiqué ci-dessous. Vous pouvez définir des heures silencieuses et d’autres paramètres tels que le volume et le son pour les alertes critiques, ajouter des sons personnalisés, etc.

paramètres de notifications pushover

Conclusion

Pushover est un service de notification que vous pouvez utiliser pour recevoir des notifications de différentes applications et services au même endroit. Vous pouvez gérer vos notifications en termes de priorité, définir des heures de silence et même définir des sons différents en fonction de la notification reçue.

Dans ce didacticiel, vous avez appris à envoyer des notifications ESP8266 à Pushover à l’aide de l’API de Pushover. L’utilisation de l’application Pushover n’est pas gratuite, mais vous disposez d’un essai gratuit de 30 jours. Si vous décidez qu’il est utile pour vos projets, vous pouvez avoir accès à l’application avec un paiement unique de seulement 5 $.

Si vous utilisez une carte ESP32, nous avons un tutoriel similaire :

Nous espérons que vous avez trouvé ce tutoriel utile.

Nous avons d’autres articles et projets montrant comment envoyer d’autres méthodes de notification comme les e-mails, WhatsApp et les messages Telegram :

Nous espérons que vous trouverez ce tutoriel utile.

En savoir plus sur l’ESP8266 avec nos ressources :

Merci d’avoir lu.

Apprenez l’histoire de Raspberry Pi à travers cette vidéo :

YouTube video

  • AZDelivery D1 Mini NodeMCU Lua avec ESP8266-12F Module WLAN CH340G Compatible avec Arduino incluant Un E-Book!
    ✅ La carte AZ-Delivery D1 mini est une carte WiFi Mini-NodeMcu Lua basée sur un ESP-8266-12F et un connecteur micro USB. ✅ Cette carte WLAN contient 11 broches d'entrée/sortie numériques, toutes les broches ont une interruption / pwm / I2C / 1 fil. ✅ Grâce à sa conception ultra-compacte, le Mini NodeMcu AZ-Delivery D1 avec le module WLAN ESP8266-12F peut être facilement stocké à distance. ✅ La carte de développement sans fil D1 Mini AZ-Delivery est 100% compatible avec IDE et peut être programmée dans Arduino-IDE. ✅ Ce produit inclut un E-Book qui fournit des informations utiles sur la façon de commencer votre projet. Il permet une installation rapide et fait gagner du temps sur le processus de configuration. On y trouve une série d'exemples d'applications, des guides d'installation complets et des bibliothèques.
  • ESP8266 NodeMCU Lua V2 Module RUIZHI 2 pièces ESP8266 WiFi NodeMCU Carte de développement CP2102 ESP-12E Type-C Interface compatibles avec Arduino IDE/Micropython
    Puissante puce ESP8266 : NodeMcu Lua V2 est construit sur l'ESP8266, un puissant module Wi-Fi qui prend en charge les normes Wi-Fi 802.11b/g/n pour une connectivité transparente. Communication USB-série : Intégrant la puce USB-série CP2102, cette carte de développement communique directement avec votre ordinateur via une interface USB, facilitant ainsi le débogage et le téléchargement de code. Support Open-Source : ESP8266 NodeMcu Lua V2 est un projet open-source, vous permettant d'utiliser, de modifier et de distribuer librement les logiciels et le matériel associés. Il est typiquement programmé en utilisant le langage de script Lua, ce qui le rend facile à utiliser pour les débutants. Broches GPIO polyvalentes : Le module ESP8266 étant doté de plusieurs broches GPIO, cette carte de développement peut être utilisée pour connecter et contrôler divers capteurs et périphériques externes, ce qui la rend idéale pour les applications IoT. Possibilité de mise à jour du micrologiciel : Les mises à jour du micrologiciel du module ESP8266 sont prises en charge, ce qui vous permet d'accéder à de nouvelles fonctionnalités et améliorations pour répondre à l'évolution des besoins et de la technologie.
  • DUBEUYEW ESP8266 NodeMCU 340 ESP-12F V3 Carte de développement Internet WiFi Module sans Fil série Flash 4M pour Arduino IDE/Micropython Nouvelle Version (2 pcs)
    L'ESP8266 dispose de puissantes capacités de traitement et de stockage embarquées qui lui permettent d'être intégré aux capteurs et à d'autres appareils spécifiques à l'application via ses GPIO avec un développement initial minimal et un chargement minimal pendant l'exécution. Son degré élevé d'intégration sur puce permet un minimum de circuits externes, et l'ensemble de la solution, y compris le module frontal, est conçu pour occuper une surface de circuit imprimé minimale. ESP8266 est une puce hautement intégrée conçue pour les besoins d'un nouveau monde connecté. Il offre une solution de réseau Wi-Fi complète et autonome, lui permettant d'héberger l'application ou de décharger toutes les fonctions de réseau Wi-Fi d'un autre processeur d'application. Nodemcu v3, mis à niveau vers la puce 340 ; Alimentez votre développement de la manière la plus rapide en combinant avec le micrologiciel NodeMcu ; Il s'agit d'une unité IOT avec toutes les ressources disponibles à bord, prenant en charge la liaison intelligente et la mise en réseau intelligente. Compatible avec Arduino compatible, bibliothèque d'installation NodeMCU 1.0 disponible dans l'IDE Arduino. Cette carte de développement ESP8266 NodeMcu peut être utilisée pour un petit moniteur de température et d'humidité dans les automates domestiques.