Minuterie télécommandée avec NodeMCU : 14 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:07

Ici, nous allons créer une minuterie à l'aide d'un NodeMCU et d'Adafruit. Nous allons afficher notre minuteur avec une bande LED et nous pourrons le contrôler à l'aide de notre téléphone ou de notre ordinateur !

Notre objectif:

Créez une minuterie à l'aide d'une bande LED que nous pouvons: démarrer, mettre en pause et réinitialiser à l'aide de notre téléphone ou de notre ordinateur.

Fournitures

Matériel:

• NodeMCU ESP 8266
• Bande LED NeoPixel Adafruit

Bibliothèques:

• Adafruit_NeoPixel.h
• AdafruitIO_WiFi.h

Autre:

Une connexion WiFi correcte

Étape 1: Créons un flux dans Adafruit

Maintenant que nous avons tout ce dont nous avons besoin, nous sommes prêts à commencer à construire ! Tout d'abord, nous devons créer un flux dans Adafruit. Adafruit est un service qui nous permet de connecter très facilement notre Arduino à Internet et de créer des fonctionnalités de contrôle à distance utiles. Si vous ne l'avez pas déjà fait, inscrivez-vous sur Adafruit.

Créons maintenant un nouveau flux

Nous pouvons nommer notre flux comme nous le voulons, je l'appelle « minuterie ».

Ce que fait un flux, c'est enregistrer tout ce que nous faisons dans notre tableau de bord (que nous allons créer en une minute) et envoyer ces données à notre tableau, mais c'est quelque chose que nous examinerons une fois que nous aurons des données à envoyer.

Étape 2: Maintenant, créons un tableau de bord

Maintenant, de la même manière que nous avons créé un flux, nous allons créer un nouveau tableau de bord. J'appellerai mon tableau de bord: 'timer interface' parce que c'est essentiellement ce que sera notre tableau de bord: une interface avec les boutons pour contrôler notre timer.

Étape 3: Obtenez notre clé

Si nous voulons connecter notre Arduino à notre flux, nous devons obtenir notre clé Adafruit, c'est votre mot de passe secret qui garantira que vous seul pouvez vous connecter à vos flux.

Vous pouvez obtenir votre clé en cliquant sur le bouton jaune AIO Key en haut à droite de votre écran dans Adafruit.

Enregistrez cette clé quelque part, nous en aurons besoin plus tard.

Ne partagez pas votre clé ! Sinon, des personnes mal intentionnées pourraient se connecter à vos flux et appareils.

Étape 4: Ouvrez l'exemple de lecture de flux

Ouvrons maintenant notre IDE Arduino et commençons le processus de codage. Tout d'abord, nous devons installer la bibliothèque Adafruit IO Arduino.

Vous ne savez pas comment installer les bibliothèques ? c'est un excellent guide par Adafruit: Bibliothèques Arduino

Adafruit propose de nombreux exemples prédéfinis à utiliser et à utiliser. L'un de ces exemples est: adafruitio_21_feed_read. Vous pouvez trouver cet exemple ici: Fichier - Exemples Adafruit IO Arduino adafruitio_21_feed_read

(excusez mon interface néerlandaise dans l'image)

Étape 5: Configurons notre connexion

Si vous avez ouvert avec succès le sketch adafruitio_21_feed_read, vous devriez voir 2 onglets dans votre sketch: adafruitio_21_feed_read et config.h. Ce croquis a été fait pour que nous puissions nous connecter au flux que nous avons créé à l'étape 1.

Pour nous connecter à ce flux, nous devons renseigner quelques détails sur notre WiFi et notre compte Adafruit,

Passons à config.h, ici nous allons remplir les détails suivants:

Votre nom d'utilisateur Adafruit:

#define IO_USERNAME "joopert"

Votre clé Adafruit:

#define IO_KEY "1234567890abcdefghijklmnop"

Le nom de votre Wi-Fi:

#define WIFI_SSID "MonWifi"

Et votre mot de passe Wi-Fi:

#define WIFI_PASS "un mot de passe très secret"

Revenons maintenant à l'onglet adafruitio_21_feed_read et remplissons:

Votre nom d'utilisateur Adafruit… encore une fois:

#define FEED_OWNER "joopert"

Et enfin votre nom de flux (à partir du flux que nous avons créé à l'étape 1):

AdafruitIO_Feed *sharedFeed = io.feed("timer", FEED_OWNER);

Étape 6: Vérifiez la connexion à Adafruit IO

Pour vérifier si les étapes que nous avons prises auparavant ont été exécutées correctement, nous allons télécharger notre croquis sur le NodeMCU. Si vous ouvrez votre moniteur série, il devrait ressembler à l'image ci-dessus. Tout d'abord, le moniteur série vous montre qu'il essaie de se connecter à votre WiFi et à Adafruit. si c'est complet, il devrait dire:

Adafruit IO connecté

C'est une super nouvelle! Maintenant, nous pouvons commencer à ajouter des fonctionnalités à notre minuterie…

Étape 7: Laissez LED

Il est maintenant temps d'allumer notre bande LED !

Connectez votre bande LED au PIN D5 (si vous ne trouvez pas le D5, connectez-le à un autre PIN et changez le LED_PIN dans le code).

Définir la bande LED

Le code suivant ajoutera la bibliothèque NeoPixel (en savoir plus sur cette bibliothèque ici: https://learn.adafruit.com/adafruit-neopixel-uberguide/arduino-library-use) et s'assurer que notre Arduino sait où se trouve notre bande LED et combien de lumières il a. Si votre bande LED a des spécifications différentes, modifiez-la dans le code.

Ajoutez le code suivant AU-DESSUS de la configuration void ():

// configurer la connexion NeoPixel#include #ifdef _AVR_ #include #endif

#define LED_PIN D5 // Où la bande LED est-elle connectée ?

#define LED_COUNT 30 // Combien de pixels a-t-il ?

#define BRIGHTNESS 50 // Luminosité NeoPixel, 0 (min) à 255 (max)

Bande Adafruit_NeoPixel (LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800);

Démarrage de la bande LED

Maintenant, nous allons démarrer notre bande LED et régler la luminosité (la luminosité passe de 0 min à 255 max, mais je recommande 50… 255 est VRAIMENT lumineux).

Ajoutez le code suivant DANS le void setup():

strip.begin(); // INITIALISER l'objet bande NeoPixel (REQUIS)strip.show(); // Désactiver tous les pixels dès que possible strip.setBrightness(50); // Réglez la LUMINOSITÉ sur environ 1/5 (max = 255)

ledsOn(); // Appelle la fonction pour allumer chaque LED une par une

Allumer les lumières

Peut-être avez-vous déjà remarqué que nous appelons une fonction qui n'existe pas encore, ce sera notre prochaine partie de codage. Si nous voulons allumer nos lumières, nous devons créer une « boucle for » qui allume chaque LED individuelle une par une (vous ne savez pas ce qu'est une boucle for ? Découvrez-la ici: www.arduino.cc/reference/ fr/langue/structure/structure-de-contrôle/pour/).

Nous allons maintenant créer la fonction: ledsOn();

Ajoutez le code suivant CI-DESSOUS void handleMessage():

void ledsOn() { for (int i = 0; i < strip.numPixels(); i++) { // Pour chaque pixel de la bande… strip.setPixelColor(i, 0, 0, 255); // Définir la couleur du pixel sur bleu strip.show(); // Mettre à jour la bande pour qu'elle corresponde à } }

Télécharger

Maintenant, c'est la partie amusante, téléchargeons notre code sur le NodeMCU… Si tout fonctionne correctement, votre bande LED devrait maintenant devenir complètement bleue !

Aucun pixel n'apparaît ?: avez-vous connecté la bande au bon PIN ? Ou peut-être que votre connexion Internet est perdue.

Seuls quelques pixels ne s'affichent pas ?: vérifiez si vous avez défini la bonne quantité de pixels !

Étape 8: Ajouter une synchronisation à la minuterie

Maintenant, nous allons nous assurer que notre minuteur est réellement… eh bien… fois, quelque chose.

Il existe différentes façons de chronométrer avec Arduino, l'une est delay(), cela arrête le traitement de notre carte pendant une période de temps définie. Nous n'allons pas l'utiliser car notre Arduino se bloque essentiellement pendant le délai, et nous voulons que notre carte soit mise à jour régulièrement. Nous allons donc utiliser Millis(), c'est une façon plus élégante de chronométrer dans Arduino, avec Millis(), nous pouvons toujours exécuter du code entre les intervalles.

Si vous êtes intéressé par la façon dont cela fonctionne, vous pouvez consulter cet article:

Ajoutons le code pour Millis():

Mettez ce code AU-DESSUS de la configuration void ()

long précédentMillis non signé = 0; // stockera la dernière fois que la bande LED a été mise à jour int interval = 1000; // intervalle de notre timer (millisecondes)

Et mettons ce code DANS la boucle vide():

non signé long currentMillis = millis();// démarre le RYTHME MINUTERIE ********************************************* ********* if (currentMillis - previousMillis >= intervalle) { previousMillis = currentMillis;

// fin du TIMER RYTHM ********************************************* ***********

Ce que nous venons de faire, c'est de créer un rythme pour que notre bande LED éteigne les LED, à l'étape suivante, nous ajouterons le code pour faire exactement cela.

Étape 9: compte à rebours

Dans cette étape: nous allons créer une fonction qui garantira que chaque seconde (ou quel que soit l'intervalle que vous avez défini) nous éteindrons UNE LED à la fin de la bande jusqu'à ce que toutes nos LED soient éteintes.

Nous allons créer un 'int' en haut appelé 'leds'. Cela indiquera plus tard à notre minuteur combien de leds il doit encore éteindre.

Ajoutez le code suivant AU-DESSUS de la configuration void ():

int leds = LED_COUNT-1; // indique combien de pixels doivent être allumés

Ajoutons maintenant la fonction 'timer ();', cela éteindra une lumière toutes les secondes

Ajoutez le code suivant SOUS le void ledsOn():

void timer() { strip.setPixelColor(leds, 0, 0, 0);

if (leds > -1) { leds--; } else { blinkie(); } }

Nous voulons informer l'utilisateur que la minuterie est terminée après que toutes les lumières se soient éteintes. Avec 'blinkie();' les LED clignoteront en rouge une fois la minuterie terminée !

Ajoutez le code suivant AU-DESSUS de la configuration void ():

int blinkStatus = 1; // informe le blinkie(); fonction si la lumière doit être allumée ou éteinte

Ajoutez le code suivant AU-DESSOUS du minuteur d'annulation ():

void blinkie() { if (blinkStatus == 1) {

FlashStatus = 0; strip.clear(); } else { blinkStatus = 1; for (int i = 0; i < strip.numPixels(); i++) { // Pour chaque pixel de la bande… strip.setPixelColor(i, 255, 0, 0); // Définit la couleur du pixel (en RAM) strip.show(); // Mettre à jour la bande pour qu'elle corresponde à } } } }

Enfin, nous devons appeler la fonction dans notre boucle void ();, Vous vous souvenez du TIMER RYTHM que nous avons ajouté à l'étape 8 ? Dans cette instruction if, nous appellerons la fonction timer();.

TIMER RYTHM devrait maintenant ressembler à ceci:

// démarrer TIMER RYTHM ********************************************* *********

if (currentMillis - previousMillis >= intervalle) { previousMillis = currentMillis; minuteur(); strip.show();} // fin du TIMER RYTHM ************************************** ******************

Téléchargez maintenant ce code !

À l'heure actuelle, votre bande LED devrait éteindre 1 LED par seconde et clignoter en rouge lorsque c'est fait…

Faisons maintenant contrôler cette maman à distance !

Étape 10: Contrôlez-le à distance: Partie I

Nous avons notre minuteur, c'est bien beau mais je vous ai promis que vous seriez capable de le contrôler avec votre téléphone, n'est-ce pas ? Entrons dans la dernière étape de notre projet: faire télécommander notre minuteur.

Votre onglet Adafruit est-il toujours ouvert ? Revenons à io.adafruit.com et allons à notre tableau de bord d'interface de minuterie et créons un nouveau bloc: TOGGLE

1. Connectez la bascule au flux TIMER
2. Réglez la valeur ON sur: 1
3. Réglez la valeur OFF sur: 0

La raison en est qu'Adafruit n'envoie pas de données texte à notre NodeMCU, mais uniquement des nombres.

Vous pouvez également donner un nom à la bascule si vous le souhaitez, peut-être: « interrupteur marche/arrêt »

Revenons maintenant à l'IDE Arduino

Juste pour nous assurer que notre code est à jour, TÉLÉCHARGEONS à nouveau notre code.

OUVREZ LE MONITEUR SÉRIE une fois le téléchargement terminé et APPUYEZ SUR LA BASCULE sur notre tableau de bord Adafruit à quelques reprises. Nous devrions maintenant voir quelque chose comme ceci apparaître sur notre moniteur série:

reçu <- 0reçu <- 1 reçu <- 0 reçu <- 1 reçu <- 0

Cela signifie que nous pouvons réellement envoyer des contrôles à notre NodeMCU !

Si vous ne recevez pas ces messages, vérifiez si vos données Adafruit dans votre config.h sont toujours correctes.

Étape 11: Contrôlez-le à distance: Partie II

Maintenant, il ne reste plus qu'à faire quelque chose avec nos commandes reçues.

Pour ce faire, nous devons modifier notre instruction TIMER RYTHM if dans la boucle void (); un peu.

Nous allons dire à notre NodeMCU qu'il ne devrait démarrer le minuteur qu'une fois que nous aurons reçu « 1 » (ce qui signifie: ON) d'Adafruit.

Commençons par collecter les données qu'Adafruit nous envoie

Ajoutez le code suivant AU-DESSUS de la configuration void ():

int adaData; // collecte les données qu'AdaFruit nous envoie

Maintenant, collectons réellement ces données

Ajoutez le code suivant À L'INTÉRIEUR du void handleMessage():

adaData = data->toInt();

Modifions notre boucle void();

TIMER RYTHM devrait maintenant ressembler à ceci:

// démarre le RYTHME MINUTERIE ********************************************* *********if (currentMillis - previousMillis >= intervalle) { previousMillis = currentMillis; if (adaData == 0) { Serial.println("je ne cours pas"); } else if (adaData == 1) { timer(); } strip.show(); } // terminer le RYTHME MINUTERIE ******************************************** ************

TÉLÉCHARGEZ votre code…

Vous devriez maintenant pouvoir allumer et éteindre la minuterie en utilisant l'interrupteur dans Adafruit !

Étape 12: Jouez ! Nous avons terminé… ou le sommes-nous ?

En ce moment, vous devriez avoir une minuterie à distance entièrement fonctionnelle ! Si c'est pour vous, merci d'être venu avec ce projet !

Si vous voulez continuer un peu plus longtemps, dans les prochaines étapes, nous allons ajouter un bouton RESET pour notre minuteur !

Étape 13: EXTRA: Créer un bouton momentané

Revenons à notre tableau de bord. Maintenant, nous voulons à nouveau CRÉER UN NOUVEAU BLOC.

1. Créer un bouton momentané
2. Connectez-le au flux « minuteur »
3. Réglez la valeur d'appui sur: 2
4. SUPPRIMER la valeur de libération
5. Donnez-lui une belle couleur !

Idéalement, le bouton momentané s'appelle déjà « Reset » !

Une fois que vous avez créé ce bloc, testez-le, le bouton fonctionne si vous recevez:

reçu <- 2

Dans votre moniteur série.

Si vous ne voyez pas ce message, essayez de télécharger à nouveau le croquis

Étape 14: EXTRA: ajouter la fonction de réinitialisation

Pour que le bouton de réinitialisation fasse quelque chose, nous devons ajouter une fonction qui réinitialise toutes les LED à leur état d'origine.

Ajoutez le code suivant SOUS le void blinkie():

void rerun() { leds = LED_COUNT; ledsOn(); }

Il ne reste plus qu'à appeler notre fonction, pour cela il faut changer une dernière fois TIMER RYTHM

TIMER RYTHM devrait maintenant ressembler à ceci:

// démarrer TIMER RYTHM ********************************************* *********if (currentMillis - previousMillis >= intervalle) { previousMillis = currentMillis if (adaData == 0) { Serial.println("je ne cours pas"); } else if (adaData == 1) { timer(); } else if (adaData == 2) { rerun(); } strip.show(); } // fin du TIMER RYTHM ******************************************** ************

TÉLÉCHARGEZ votre code…

Maintenant, vous devriez également pouvoir réinitialiser la minuterie en appuyant sur le bouton !