Mode d'emploi | Conrad Components 10215 Profi Lernpaket Internet of Things Course material 14 years and over Manuel utilisateur

AVANT DE COMMENCER
À la première connexion du IoT-WiFi-Boards (ci-après également
appelé NanoESP) il peut arriver que l’ordinateur ne trouve pas automatiquement le
pilote indispensable pour le convertisseur série USB. Si c’est le cas, vous devez
télécharger le pilote depuis la page www.iot.fkainka.de/driver et l’installer manuellement. Dans le logiciel Arduino vous pouvez ensuite sélectionner le port et
comme carte Arduino Nano (processeur : Atmega328). Ensuite le contrôleur
doit être prêt à l’emploi.
Pour travailler avec le moniteur série vous devez en effet procéder à des paramétrages. Le débit en bauds utilisé ici est 19 200 Bauds. Pour envoyer des instructions vous devez d’autre part sélectionner l’option CR et NL à côté du menu pour
le débit en bauds.
Les paramétrages corrects dans l’environnement Arduino
J’ai travaillé avec les versions Arduino IDE 1.6 5 et 1.6 6. Les versions plus anciennes peuvent provoquer des problèmes. Vous trouverez la version actuelle
Arduino-IDE sur le site internet www.arduino.cc.
En cas de difficultés ou de problèmes avec la carte ou le kit d’apprentissage vous
pouvez trouver de l’aide à tout moment sur la page webwww.iot.fkainka.de. Sur
cette page vous trouverez de plus un forum, de nouveaux projets d’utilisateurs et
également tous les programmes présentés ici dans la toute dernière version.
Dans le kit d’apprentissage se trouve une platine d’expérimentation sur laquelle
vous pouvez enficher le
NanoESP, comme indiqué sur la figure ci-dessous. Cela laisse plus de place pour
l’expérimentation pendant que le module WLAN derrière dépasse sur la platine
d’expérimentation. Le câble micro USB peut ensuite être enfiché, comme indiqué
sur la figure dans la section suivante, et la perturbation est minimale. Des figures
de montage détaillées se trouvent dans les chapitres respectifs.
La carte IoT-WiFi (NanoESP)
L’élément principal de ce kit d’apprentissage est la carte IoT-WiFi (NanoESP).
Comme on le remarque très bien sur la carte, celle-ci est constituée de deux composants. Sur la moitié gauche il s’agit d’un système microcontrôleur compatible
Arduino qui est comparable au nano Arduino. La partie droite est le module WLAN
avec la désignation ESP8266.
Ces deux composants communiquent entre eux par l’interface série générée par
logiciel.
NanoESP sur la platine d’expérimentation
Disposition des broches de la platine
Sur la platine il y a beaucoup d‘éléments différents, tels que les broches (pin),
parmi lesquels certains ont une fonction particulière, ou également des DELs, dont
les fonctions ne sont pas toujours claires au premier coup d'œil. Pour que vous ne
perdiez pas la vue d’ensemble, les fonctions et désignations les plus importantes
des différents éléments sont répertoriées dans les figures suivantes.
Les broches les plus importantes et désignations de la platine
Le module WLAN est contrôlé par ce qu’on appelle les commandes AT. La partie
Arduino de la platine est reliée au module WLAN par les broches 11 et 12. Un petit
circuit convertit le niveau 5 V en niveau compatible 3,3 V. Vous ne devez donc pas
utiliser les broches 11 et 12 dans vos propres projets.
D’autres propriétés hardware importantes de la carte sont brièvement énumérées
dans le tableau ci-dessous.
Données techniques
Microcontrôleur :
ATmega328
Mémoire-flash :
32 kB (dont 0,5 kB pour le bootloader)
SRAM (mémoire vive statique) : 2 kB
EEPROM (mémoire morte effaçable électriquement et programmable) :
1 kB
Signal d’horloge :
16 MHz
Broches E/S :
20 (dont 2 pour la communication avec le module
WLAN)
U dont MLI :
6
U dont entrées analogiques : 6
USB pour puce de série :
CH340G
Tension de service :
5V
Tension d’entrée recommandée : 7 à 12 V
Courant maximum par broche E/S :
40 mA
Charge admissible de la sortie 3,3 V : 50 mA
Module WLAN :
SPI-Flash
Tension de service :
Normes WLAN :
Modes WLAN :
Firmware :
Divers :
ESP8266
4 Mbit
3,3 V
802.11 b/g/n
Wi-Fi Direct (P2P), Soft-AP
AT-Firmware Version 0.22
Pile TCP/IP intégrée
Puissance de sortie +19,5 dBm en mode 802.11b
Faible puissance CPU 32 bit intégrée
Communication via UART
ELEMENTS DU KIT
D’APPRENTISSAGE
Ci-dessous se trouve un aperçu des éléments contenus dans le kit
d’apprentissage.
1
carte IoT-WiFi (NanoESP)
1
platine d’expérimentation
1m
fil électrique
2
boutons-poussoirs
1
cosse clip 9 V
1
DEL (rouge)
1
DEL RGB (4 pattes de raccordement)
1
résistance 10 kOhm (marron, noire, orange)
1
résistance 1 kOhm (marron, noire, rouge)
1
phototransistor (2 pattes de raccordement)
1
NTC 10 kOhm
1
haut-parleur Piezo
1
potentiomètre 10 kOhm avec bouton rotatif rouge
CONNAITRE LE MODULE
Ce premier chapitre aborde les fonctions de base du module WLAN. Le module
est contrôlé par ce qu’on appelle les commandes AT. Vous retrouverez tous les
exemples de programmes utilisés ainsi que l’aide et d’autres information sur
www.iot.fkainka.de
Le plus simple est de télécharger le répertoire zip complet et de copier le dossier
décompressé complètement dans votre dossier Sketch. Ensuite vous pouvez
ouvrir tous les programmes l’un après l’autre confortablement depuis l’interface
Arduino.
1.1 | Commandes AT essentielles
C’est tout simplement en l’essayant que l’on obtient la meilleure première impression des commandes AT. C’est pourquoi vous allez vous familiariser dans cette
section avec quelques unes des commandes de base du module.
Ouvrez pour cela le programme P01_SoftwareSerial dans Arduino-IDE. Il s’agit
ici d’un programme simple qui ne fait rien de plus que transférer les données reçues par l’interface hardware du microcontrôleur au contrôleur ESP par l’interface
logiciel définie. Tout fonctionne également en sens inverse. Comme on peut le voir
dans le code source, les deux connexions de l’interface logiciel sont les broches
11 et 12. Celles-ci ne doivent pas être utilisées comme broches GPIO dans vos
propres projets. D’autre part, vous avez besoin de la librairie SoftwareSerialLibrary, qui est déjà préinstallée dans la plupart des versions Arduino. Dans le
cas contraire, vous devez télécharger la libraire par le gestionnaire.
Une fois le programme téléchargé, vous pouvez démarrer le moniteur série de
l’interface Arduino. Avant de le lancer, vous devez encore procéder à deux paramétrages importants sur le moniteur série, à savoir placer le débit en bauds sur
19 200 dans le coin inférieur droit et procéder au paramétrage CR et NL dans la
case à côté à gauche.
Vous pouvez maintenant déjà voir un message, à savoir AT et quelques lignes en
dessous OK. La commande AT a été envoyée par le microcontrôleur au module
ESP et le module a répondu par OK. À partir de là vous pouvez remarquer que le
module WLAN fonctionne et est prêt à être utilisé.
Paramétrages du terminal : CR et NL et un débit en bauds de 19 200
1.1.1 | Commandes de base
Vous pouvez désormais tester certaines commandes de base du module, en saisissant simplement la commande et en l’envoyant au module par [Enter].
L’utilisation des majuscules pour l’instruction a son importance ici. Vous pouvez
transmettre votre première instruction en saisissant
AT
dans le moniteur en série et en appuyant sur [Enter]. Le programme téléchargé
transmet l’instruction au module ESP qui répond par retour à AT et ensuite OK .
La commande suivante que vous pouvez tester est :
AT+GMR
Le firmware actuel et le numéro de version sont affichés par cette instruction.
Avec l’instruction
AT+RST
Vous pouvez réinitialiser le module. Vous voyez d’abord dans le terminal quelques
caractères illisibles et au bout readycomme caractère, indiquant que le module est
prêt maintenant. Une autre instruction est :
ATE0
Avec celle-ci on peut désactiver ce qu’on appelle l’écho du module. Cela signifie
que vous n’avez pas reçu la commande envoyée mais seulement la réponse. Si
par exemple vous envoyez AT il n’y a pas d’abord AT et ensuite OK, mais seulement OK en retour. Pour vos premiers pas, il est cependant souhaitable que l’écho
ATE1
soit de nouveau activé.
Premiers essais avec les instructions AT
1.1.2 | Instructions WLAN
Avec les commandes WLAN suivantes vous pouvez modifier les propriétés WLAN
du module. Avec la plupart des instructions vous pouvez non seulement définir un
état mais également vérifier l’état actuel. Cela se fait en ajoutant un point
d’interrogation directement après l’instruction, p. ex.
AT+CWMODE?
Comme valeur de retour est généralement présentée
+CWMODE=2
suivie de OK. Si vous saisissez
AT+CWMODE=?
Le module vous répond avec les paramètres possibles de l’instruction, à savoir ici
1-3. AvecCWMODE il s’agit d’ailleurs de l’instruction avec laquelle vous pouvez
déterminer le mode WLAN.
Il y a trois modes de fonctionnement que je peux appeler l’un après l’autre.
1 AT+CWMODE=2 – le module comme point d’accès (Access Point mode AP)
À la livraison, le module est un point d’accès. Cela signifie que vous pouvez enregistrer avec un appareil compatible WLAN, comme un smartphone ou un PC, une
connexion directe avec le module. Pour cela, recherchez simplement le WLAN ouvert avec le nom NanoESP et connectez-le avec. En réglage usine, aucun mot de
passe n’est attribué de façon à ce que la connexion ne représente aucun problème.
Lorsque vous êtes connecté au module, vous n’avez pas de connexion internet car
le module n’est pas un routeur avec une propre connexion au réseau téléphonique.
Ce mode WLAN est néanmoins utile si vous avez besoin par exemple d’un réseau
fermé sécurisé. À propos de sécurité : Il est également possible d’attribuer un mot
de passe au réseau et ce par l’instruction :
AT+CWSAP
Des paramètres doivent encore être indiqués et dans l’ordre et séparés par des
virgules :
U le nom du réseau entre guillemets,
U le mot de passe entre guillemets,
U l’identifiant du canal (Channel ID de préférence une valeur entre 1 et 13),
U et le mode de cryptage (valeur de 0 à 4).
Un paramétrage potentiel serait :
AT+CWSAP="MyNanoESP","MyPassword",5,3
Après un bref moment apparaît OK comme confirmation. Si ERROR apparaît,
vérifiez à nouveau vos données, avant tout les guillemets. Si cependant ERROR
apparaît, vérifiez si le CWMODE est vraiment 2.
Si tout a fonctionné, vous pouvez vous connecter avec un appareil compatible
WLAN avec la platine. Vous pouvez afficher tous les appareils connectés au module avec les adresses IP et MAC par l’instruction
AT+CWLIF
.
Module en mode socle L’IP de l’ordinateur connecté est marquée.
2 AT+CWMODE=1 – Module en mode socle
Avec l’instruction
AT+CWMODE=1
Mettez le module en mode socle. Ce mode vous permet de mettre en place une
connexion à votre routeur WLAN. De ce fait, le module est également connecté à
internet et a plusieurs possibilités.
Vous pouvez d’abord lister avec l’instruction
AT+CWLAP
tous les réseaux à portée et ainsi vérifier si votre réseau est dans le rayon de réception. Pour pouvoir établir une connexion à votre routeur, vous avez besoin de
l’instruction
AT+CWJAP
Celle-ci, comme l’instruction CWSAP, a des paramètres importants, à savoir le
nom du réseau WLAN (également appelé SSID) et le mot de passe, les deux de
nouveau entre guillemets et séparés par une virgule. La mise en place d’une connexion à un deuxième module, paramétré avec les données mentionnées dans la
section précédente, ressemblerait donc à :
AT+CWJAP="MyNanoESP","MyPassword"
La mise en place de la connexion peut durer quelques secondes et devrait ensuite
renvoyer OK. Vous pouvez d’ailleurs appeler l’IP du module attribuée par le routeur par l’instruction
AT+CIFSR
. Cela sera important plus tard si vous voulez établir une connexion au serveur
TCP du module. Avec l’instruction
AT+CWQAP
Vous pouvez à nouveau séparer la connexion de votre routeur.
La platine établit une connexion à un deuxième NanoESP.
3 AT+CWMODE=3 – le mode double
Le troisième mode possible de paramétrage WLAN est le mode double. Il permet,
comme son nom le laisse entendre, d’utiliser le module en modes socle et AP.
Cela signifie qu’il peut à la fois établir une connexion sans fil avec le module ou
atteindre le module via le routeur en station intermédiaire. Un mode pratique lorsqu’on envisage un réseau interne avec plusieurs
ctions dans l’annexe et sur la page
modules et que cependant un module doive servir
de serveur, qui livre les données au réseau. Mais
des importantes se trouvent d’ailleurs
davantage à ce sujet plus tard.
la page web déjà mentionné
Certaines commandes, telles que le
bauds n’ont pas été répertoriées voes peuvent rendre le module inutilisa-
1.2 | Configuration automatique
Vous pouvez déjà tester les instructions de base manuellement. Dans ce chapitre
la question est maintenant de préciser comment ces instructions peuvent être
actionnées directement par le contrôleur. D’autre part, vous vous familiarisez avec
une autre instruction avec laquelle vous pouvez tester si un PC dans un réseau ou
un serveur sur internet peut être atteint. Dans cet exemple le serveur Google est
en effet pingué. Dans ce programme d’exempleP02_GooglePing les processus,
que vous avez saisis manuellement dans le premier exemple, sont maintenant
principalement automatisés. Le contrôleur envoie des instructions les unes après
les autres au module ESP et établit ainsi la connexion au WLAN. Les différents
longs Timeout (temps de latence) donnent suffisamment de temps de réponse au
module.
Avant que le programme puisse cependant fonctionner correctement, vous devez
inscrire vos données derrière #define SSID et #define PASSWORD dès le début du
programme code source. Le module nécessite en effet un accès internet pour pouvoir
exécuter sa dernière instruction. Avec l’instruction
AT+PING
d’autres appareils peuvent être pingués au réseau. Le ping signifie que l’on demande si un ordinateur est généralement accessible. Ici la commande ping est
envoyé au serveur Google-Server avec AT+PING="www.google.de". Si une information revient, un message de réussite apparaît dans le moniteur en série et la
DEL inscrite avec D3 qui est connectée à la broche D13 de la platine est activée.
Alors la première communication avec internet aurait réussi.
Le programme
Par la suite nous analyserons progressivement les fonctions du programme. Pour
commencer nous abordons la communication avec le module.
1 Communication série
L’ensemble fonctionne par l’interface logiciel série qui est fournie avec SoftwareSerial-Library . À l’initialisation les broches utilisées doivent en outre être indiquées, dans ce cas les broches 11 et 12.
001 #include <SoftwareSerial.h>
002 SoftwareSerial esp8266(11, 12);
Précisément comme avec l’interface série normale des octets ou des lignes entières peuvent être transmises avec l’instruction esp8266.print ou esp8266.println .
Les instructions esp8266.find et esp8266.findUntil, avec lesquelles un flux entrant
sur certaines chaînes de caractères peut être contrôlé, sont particulièrement pratiques. De ce fait, il est très simple d’intercepter la réponse appropriée du module.
Toutefois, si une chaîne de caractères attendue n’est pas échangée, cela peut
prendre un certain temps avant que le programme continue. Le temps de latence
(Timeout) est défini par esp8266.setTimeout . Avec findUntil() une deuxième chaîne de caractères peut cependant être définie par laquelle la fonction de recherche
s’arrête et fournit false comme valeur de retour. Nous exploitons ceci dans la fonction sendCom():
001 //-------Controll ESP-------002
003 boolean sendCom(String command, char respond[])
004 {
005
esp8266.println(command);
006
if (esp8266.findUntil(respond, "ERROR"))
007
{
008
return true;
009
}
010
else
011
{
012
debug("ESP SEND ERROR: " + command);
013
return false;
014
}
015 }
Si vous appelez la fonction, vous devez également remettre à la fonction
l’instruction et la valeur de retour attendue, p. ex. AT et la valeur de retour attendue OK. La commande est transmise par println() et finalement attendue jusqu’à la
valeur de retour attendue ou un ERROR est reçu. Si l’attente est remplie, la fonction renvoie la valeur true . Dans le cas contraire, le module transmet par la fonction debug()-un ESP SEND ERROR et la commande envoyée revient pour pouvoir
contrôler facilement quelle instruction est à l’origine des problèmes.
Pas toutes les instructions ATont une valeur de retour explicite ou à une ligne. Si
par exemple l’adresse IP est interrogée, il n’y a pas nécessairement de valeur
connue à l’avance. C’est pourquoi il y a une deuxième fonction sendCom()qui n’a
besoin que du paramètre command et renvoie ensuite toute la chaîne (string)
reçue. La chaîne ne doit cependant pas être trop longue car la mémoire tampon
du SoftwareSerial peut être dépassée.
001 String sendCom(String command)
002 {
003
esp8266.println(command);
004
return esp8266.readString();
005 }
2 Recherche des erreurs
En développant le programme il y a souvent des erreurs et des complications.
Pour avoir vraiment une chance, il y a deux fonctions debugqui sont activées ou
désactivées par un paramètre au tout début du programme.
#devine DEBUG true
La première fonction n’a pas plus d’effet qu’une simple édition de texte par
l’interface série définie comme standard. Lorsque la constante DEBUGest vraie, le
contenu de la chaîne de caractères Msgest envoyé.
001 void debug(String Msg)
002 {
003
if (DEBUG)
004
{
005
006
Serial.println(Msg);
}
007 }
La deuxième fonction est rapidement expliquée. Si la fonction
serialDebug est appelée, le programme passe dans une boucle et se comporte à
partir de là comme le premier programme SoftwareSerialtesté. Cela signifie que
toutes les données qui ont été envoyées par le moniteur série au contrôleur passent directement sur le module et inversement. En cas d’erreur on peut appeler la
fonction et envoyer des instructions manuellement pour tester où se trouve
l’erreur.
001 //---Debug Functions---
002 void serialDebug() {
003
while (true)
004
{
005
if (esp8266.available())
006
Serial.write(esp8266.read());
007
if (Serial.available())
008
009
esp8266.write(Serial.read());
}
010 }
3 Configuration
Pour rendre les programmes en général plus clairs, la plupart des paramètres sont
externalisés dans des fonctions propres, tous dans la fonction espConfig, dans
laquelle sont placés les principaux paramètres pour le programme respectif.
001 //---Config ESP8266--002 boolean espConfig()
003 {
004
boolean success = true;
005
esp8266.setTimeout(5000);
006
success &= sendCom("AT+RST", "ready");
007
esp8266.setTimeout(1000);
008
009 if (configStation(SSID, PASSWORD)) {
010
success &= true;
011
debug("WLAN Connected");
012
debug("My IP is:");
013
debug(sendCom("AT+CIFSR"));
014
}
015
else
016
{
017
018
success &= false;
}
019
020
success &= sendCom("AT+CIPMODE=0", "OK");
021
success &= sendCom("AT+CIPMUX=0", "OK");
022
023
return success;
024 }
Au début de la fonction la variable success est d’abord posée sur true , car cette
variable est liée désormais avec différentes fonctions et. Cela signifie que même si
une seule des fonctions retourne la valeur, falsesuccess est donc immédiatement
false et toue la configuration a échoué. La première instruction AT contrôlée avec
succès est l’instruction Resetqui est presque toujours exécutée au début du programme, pour s’assurer que les essais précédents ne revendiquent pas encore le
module. Cela peut durer en effet jusqu’à cinq secondes jusqu’à ce que le module
renvoie le message ready. C’est pourquoi brièvement avant la fonction sendCom()le temps de latence pour esp8266.findUtil est fixé haut. Après le reset, le
temps de latence et de nouveau établi sur la valeur standard d’une seconde.
Ce qui suit ensuite est l’appel d’une fonction elle-même définie avec le nom
configStation()qui est abordée dans la section suivante. Elle sert à connecter le
module avec son réseau domestique. À cette fin, les paramètres SSID et PASSWORD que vous avez enregistrés au début du programme, sont transmis. Si la
connexion a été établie avec succès, le message de réussite d’abord et ensuite
l’adresse IP actuelle du module sont transférés au module série. À la fin de la
fonction sont encore fixés des paramètres sur lesquelles je reviendrai plus tard.
Enfin la variable success est renvoyée qui, nous l’espérons, a gardé le valeur true.
001 boolean configStation(String vSSID, String vPASSWORT)
002 {
003
boolean success = true;
004
success &= (sendCom("AT+CWMODE=1", "OK"));
005
006
esp8266.setTimeout(20000);
success &= (sendCom("AT+CWJAP=\"" + String(vSSID) + "\",\""
+ String(vPASSWORT) + "\"", "OK"));
007
esp8266.setTimeout(1000);
008
return success;
009 }
La fonction configStation() a été appelée dans la fonction espConfig(). Ici le paramétrage du mode WLAN sur le mode socle a été entrepris avec la commande
CWMODE et ensuite la connexion avec le réseau par l’instruction CWJAP. Cela
peut durer relativement longtemps jusqu’à ce que la connexion soit établie, c’est
pourquoi le temps de latence est brièvement dépassé à 20 secondes. Si vous
préférez le mode sans fil double, vous pouvez inscrire ici pour CWMODEun3.
001 boolean configAP()
002 {
003
boolean success = true;
004
005
006
success &= (sendCom("AT+CWMODE=2", "OK"));
success &= (sendCom("AT+CWSAP=\"NanoESP\",\"\",5,0",
"OK"));
007
008
return success;
009 }
La fonction configAP() n’est pas appelée dans cet exemple mais doit être cependant traitée brièvement. Elle représente pour ainsi dire la contrepartie à la fonction
configStation()car le module est ici paramétré comme point d’accès. Un temps de
latence plus long n’est pas nécessaire ici car le module peut transformer la commande CWSAPplus rapidement. Dans des essais ultérieurs dans la fonction espConfig()à la place de configStation() la fonctionconfigAP()sera appelée.
001 void setup()
002 {
003
// Open serial communications and wait for port to open:
004
Serial.begin(19200);
005
// set the data rate for the SoftwareSerial port
006
esp8266.begin(19200);
007
008
if (!espConfig()) serialDebug();
009
else debug("Config OK");
010
011
if (sendCom("AT+PING=\"www.google.de\"", "OK"))
012
{
013
Serial.println("Ping OK");
014
digitalWrite(13, HIGH);
015
}
016
else
017
{
018
019
Serial.println("Ping Error");
}
020 }
021
022 void loop() // run over and over
023 {
024
//Start serial Debug Mode - Type Commandos over serial Monitor
025
serialDebug();
026 }
Les fonctions les plus importantes que vous trouverez dans presque tous les programmes sont traitées ainsi. Dans les fonctions Arduino connues setup() et loop()
ces fonctions sont maintenant utilisées. Les deux interfaces série sont d’abord
initialisées avec 19 200 bauds. Ensuite seulement est appelée la fonction espConfig(). En cas d’erreur la fonction serialDebug()est immédiatement lancée. Si
tout est correct un message de réussite est envoyé. Dans les programmes ultérieurs, la DEL à la broche 13 qui est marquée D3 sur la platine s’allumera en plus
dans une configuration réussie. Pour cela vous avez également un retour si le
module n’est pas connecté à un PC avec un moniteur série. Dans cet essai la DEL
est en effet nécessaire pour le message de retour du statut ping La requête
s’exécute également dans les lignes suivantes après la configuration. La commande AT+PINGest envoyée comme paramètre à l’adresse Google. Vous pouvez
appeler également une adresse IP dans votre réseau local à la place de cette
adresse. En cas de réussite un message apparaît et la DEL nommée D3 est activée. En dernière action le programme saute à la fonction loopqui de son côté
appelle la fonction serialDebug()-. Vous pouvez donc tester d’autres instructions
après le programme et par exemple envoyer une commande ping à d’autres
adresses.
1.3 | Détection d’un réseau
Dans ce chapitre entre autres il s’agit pour la première fois d’une petite structure
hardware. Le but de ce projet est un type d'alarme qui réagit quand un certain
réseau est à portée ou est activé.
Il ne nécessite que deux composants et un peu de
fil. Vous pouvez voir la conception précise dans
ssaires
les figures de construction.
nanoESP, 1 piezo, fil électrique
Branchement du haut-parleur piezo
Le code source pour ce projet est différent de l’essai précédent principalement
pour les fonctions suivantes :
001 void findSSID()
002 {
003
004
005
esp8266.println("AT+CWLAP");
if (esp8266.findUntil(ToFindSSID,"OK")) alarm();
else debug("SSID not found!");
006 }
007
008 void alarm()
009 {
010
debug("alarm!");
011
012
digitalWrite(LED_ALARM, HIGH);
013
014
for (int i; i <=30; i++)
015
{
016
tone(PIEZO, 400, 500);
017
delay(500);
018
tone(PIEZO, 800, 500);
019
delay(500);
020
}
021
022 digitalWrite(LED_ALARM, LOW);
023 }
La fonction findSSID() est appelée environ toutes les 30 secondes dans la routine
loopet recherche ensuite tous les réseaux avoisinants. Lorsque le réseau a été
trouvé, la fonction alarm() est déclenchée, qui active la DEL D3 et émet un signal
sonore sur le piezo. Dans le programme d’exemple, un réseau est recherché avec
le SSID NanoESP donc en fait d’autres réseaux nanoESP à portée. Vous pouvez
cependant simplement au démarrage du programme enregistrer une autre SSID
par #define ToFindSSID . De ce fait vous pouvez par exemple vérifier la distance
de portée de votre réseau WLAN.
UDP ET IP
Il s’agit dans ce chapitre de l’échange de données entre deux systèmes via un
réseau WLAN. Nous aborderons les sujets tels que ports IP et protocole UDP.
Ces concepts de base doivent d’abord être expliqués.
Qu’est-ce qu’une adresse IP ?
Une adresse IP fonctionne comme une adresse postale. Un ordinateur du réseau
peut être identifié et adressé clairement par celle-ci. Une adresse IP selon la norme IPv4 encore en cours est la suivante :
192.168.4.1
Il s’agit de quatre chiffres ou plus précisément de quatre octets. Cela signifie que
la valeur d’un chiffre peut être 255 maximum. Fondamentalement, il y a des
adresses IP locales qui sont réparties sur les ordinateurs et appareils de votre
réseau domestique et des IP globales.
Les IP locales sont en général réparties par votre routeur. La plupart commence
par 192 168. Le chiffre qui suit est différent de routeur à routeur. Lorsque le NanoESP fonctionne en point d’accès et se connecte aux ordinateurs dans son réseau, les PC reçoivent une adresse qui commence par 192 168.4. En même
temps il y a un sous-réseau étendu. Les routeurs Fritz!Box répartissent en général
des adresses IP locales selon le schéma 192.168.178.X. Vous pouvez trouver
votre IP en entrant par exemple dans Windows dans l’invite de commande (sous
Start-> Programmes->Accessoires->Invite de commande) l’instruction ipconfig.
Une plus longue liste apparaît qui contient également le point adresse IPv4 avec
votre IP locale dans le réseau..
Les IP globales sont transmises en général par le fournisseur internet. Il s’agit par
exemple de l’adresse par laquelle votre routeur peut être atteint dans le réseau
mondial. Le routeur fixe le réseau local et répartit les données aux clients. Une
possibilité de trouver votre adresse IP globale est par exemple d’appeler la page
web http://www.meine-aktuelle-ip.de/. Sur la page sont présentées en plus
d’autres données visibles par un serveur web. Sur internet vous n'êtes donc pas
aussi anonyme que vous le croyez.
Qu’est-ce qu’un port ?
Par analogie à l’adresse postale, un port pourrait être quelque chose comme la
porte d’entrée d’un immeuble. Un ordinateur avec une IP unique peut fournir différents services par différents ports. Vous pouvez atteindre le serveur par l’IP mais
vous devez choisir le service à utiliser via le port. Cela peut être par exemple le
port 20 pour le transfert de données FTP ou le port 23 pour une connexion telnet.
En général, vous pouvez choisir librement le port, en effet, il y a des ports normalisés qui rendent le traitement des applications web plus facile. Vous trouverez une
liste des ports normalisés dans
https://de.wikipedia.org/wiki/Liste_der_standardisierten_Ports
Qu’est-ce que UDP ?
UDP est l’abréviation de User Datagram Protocol (protocole de datagramme utilisateur). Il s’agit d’un protocole réseau minimal sans connexion. C’est à dire qu’il
est plus minimaliste et simple que tous les autres protocoles internet, comme p.
ex. TCP que nous aborderons ultérieurement. La comparaison à ce stade n’est
pas encore particulièrement simple mais vous pouvez vous rappeler ce qui suit sur
les propriétés du protocole :
U UDP peut transmettre.
U Il n’y a aucun contrôle de l’exactitude des données et aucune
correction des erreurs.
U Il n’y a également aucune garanties que les données ont été
transmises avec succès.
U Il n’y a d’autre part aucune garantie que les données ne sont pas
corrompues pendant la transmission ou interceptées par un tiers.
U Il n’est pas nécessaire d’établir une connexion mais c’est plutôt un
échange de données plus rapide.
U Il n’y a pratiquement pas de fluctuations de retards de transfert.
U Le format est adapté par exemple à VoIP (Voice over IP – téléphone
via internet).
Ce sont en premier lieu les bases les plus importantes pour les principes des projets suivants. On pourrait traiter le sujet de façon plus approfondie et au moment
opportun d’autres informations suivront. Mais d’abord la partie pratique.
2.1 | Échanger des données entre la platine et le PC avec l’UDP
Dans ce premier projet pour le sujet UDP des données sont échangées entre la
platine et le PC via WLAN. À condition que votre ordinateur dispose d’un adaptateur WLAN. Un programme du côté PC assure la bonne réception des messages.
Une structure hardware n’est pas nécessaire pour cette expérience.
Le programme
Lorsque vous chargez le programme P04_UDPBasics.ino sur le contrôleur, le
contrôleur est configuré comme point d’accès et vous pouvez trouver un réseau
ouvert appelé NanoESP. Avant de vous connecter avec le réseau, vous devez
d’abord télécharger un programme pour le PC depuis internet. Pour mes tests j’ai
utilisé le programme Packet Sender de Dan Nagle, que vous pouvez télécharger
par le lien suivant :
https://packetsender.com/
Après le chargement et l’installation du programme, vous pouvez connecter votre
PC avec le réseau ouvert NanoESP. Assurez-vois que le firewall reconnaît le
réseau comme réseau domestique pour qu’aucune donnée ne soit bloquée. Votre
ordinateur doit avoir reçu maintenant l’IP 192.168.4.2. Vous pouvez le vérifier en
envoyant l’instruction
AT+CWLIF
au module via le moniteur série. Cette instruction indique tous les ordinateurs
connectés au point d’accès avec l’adresse IP et MAC.
Maintenant lancez Packet Sender, établissez sous Paramètres -> Réseau le port
du serveur UDP sur 90 et cliquez la case Activer le serveur UDP . En général en
bas à gauche se trouve UDP:90 . Dans le cas contraire, vous devez redémarrer le
logiciel.
Les paramétrages corrects du programme Packet Sender
Le programme sur l’ordinateur est utilisé maintenant comme serveur UDP pendant
que le contrôleur est paramétré en client UDP. Dans le protocole UDP la distinction client/serveur n’est pas essentielle, mais dans ce cas cela signifie que vous
envoyez des données à votre ordinateur avec le contrôleur.
Le message
a été transmis avec succès.
Pour envoyer des données, utilisez l’instruction :
AT+CIPSEND=7
Ici 7 représente le nombre de caractères à envoyer. Le caractère > apparaît comme valeur de retour. Cela signifie que vous pouvez maintenant transférer votre
message. Saisissez Hello et confirmez à nouveau par [Enter]. Le module envoie
comme valeur de retour SEND OK, et cela même si vous n’avez saisi que cinq
caractères. Cela vient du fait qu’après votre saisie, encore que Carriage Return et
New Lineont été envoyés, donc deux caractères de plus que vous devez calculer
dans votre longueur de message.
Si vous basculez à nouveau Packet Sender et regardez là sous journal de trafic,
vous pouvez voir l’entrée du message. Dans l’affichage ASCII vous voyez même
les deux caractères envoyés représentés par \r et \n.
Le message a été reçu par Packet Sender.
001 boolean configUDP()
002 {
003
boolean success = true;
004
005
success &= (sendCom("AT+CIPMODE=0", "OK"));
006
success &= (sendCom("AT+CIPMUX=0", "OK"));
007
008
success &=
sendCom("AT+CIPSTART=\"UDP\",\"192.168.4.2\",90", "OK");
//UDP-Server
return success;
009 }
Dans le programme Arduino la fonction configUDP() est avant tout décisive pour le
trajet de communication. Ici sont entrepris les paramétrages importants pour le
transfert. D’abord, le mode transparence des données est placé avec CIPMODE
sur0. Ensuite avec CIPMUX=0 est paramétré la connexion d’une seule connexion.
L’instruction essentielle est CIPSTART. Avec celle-ci une connexion est établie et
notamment à l’IP 192.168.4.2, donc votre PC, et le PORT 90, auquel le programme Packet Sender écoute avec son serveur UDP. Ce sont avant tout les étapes
nécessaires pour établir une première connexion.
2.2 | Envoyer et recevoir des données avec UDP
Dans le projet précédent, la communication UDP a été testée dans une direction,
à savoir de la platine au PC. Dans ce programme le module est paramétré de telle
manière qu’une communication dans l’autre direction est également possible,
presque comme dans un chat.
Le programme
Dans le fond, le programme comporte seulement une modification minime qui a
cependant un effet important sur la communication avec le protocole UDP. Lorsque vous téléchargez le programme, un point d’accès est à nouveau établi avec
lequel vous pouvez vous connecter à votre PC. Ici aussi vous avez besoin de
Packet Sender ou d’un programme similaire. Démarrez le programme et prenez
les mêmes paramétrages que précédemment (Fichier -> Paramètres -> Réseau :
Activer serveur UDP, Port 90). Enfin vous devez encore saisir dans la fenêtre
principale dans le champ Adresse IP l’adresse du module (192.168.4.1), placer le
Port sur 91 et dans le menu déroulant plus loin à droite choisir le point UDP. Si
ces paramétrages sont faits et le moniteur série ouvert, vous pouvez envoyer le
premier message au module en tapant p. ex. Hi dans le champ étiqueté ASCII .
Lorsque vous cliquez sur Send apparaît dans le moniteur série :
001 +IPD,2:Hi
002 OK
Packet Sender a transmis « Hi » avec succès.
Le message a donc été reçu. Vous pouvez répondre en utilisant l’instruction CIPSENDdonc p. ex. :
001 AT+CIPSEND=7
002 >Hello
La différence par rapport au projet précédent réside dans une seule ligne :
success &= sendCom("AT+CIPSTART=\"UDP\",\"192.168.4.2
\",90,91", "OK");
Comme vous voyez, un deuxième port a été indiqué. Ce port dans ce cas avec le
numéro 91 est le port par lequel le module surveille de son côté les données entran-
tes. Avec l’ajout de cette simple ligne, il est possible également d’envoyer des données au module. Vous pouvez d’ailleurs surveiller le même port auquel vous envoyez. Vous pourriez donc attribuer le chiffre 90 aux deux ports. Théoriquement, il
est cependant possible avec la modification que le module reçoive ses propres données.
2.3 | Activer une DEL avec UDP
Dans le programme P06_UDPLED.ino il s’agit maintenant finalement de commander du matériel via le protocole UDP. Avec ce programme il est possible d’allumer et
d’éteindre une DEL avec de simples instructions. De plus, un autre paramètre sur la
communication UDP est effectué, qui permet de contrôlér la matériel simultanément
de plusieurs ordinateurs. Pour cela vous avez besoin d’un circuit comme le montre
l’image la figure ci-dessous. La DEL ressemble beaucoup à un autre composant, le
phototransistor. Vous pouvez distinguer les deux
ssaires
composants en regardant la tête du dispositif d’en
haut. L’intérieur de la DEL a une grande surface
NanoESP, 1 DEL (rouge), 1 résistanblanche.
noir, rouge), fil électrique
Packet Sender a transmis « Hi » avec succès.
Le programme
Alors que les programmes d’exemples précédents demandaient beaucoup de
saisie de l’utilisateur via le moniteur série, ce programme doit travailler de manière
autonome. Toutefois, à des fins de debugage d’autres informations seront transmises via le moniteur série.
Le contrôleur attend les données reçues par le module WLAN, qui ont été annoncées par le message +IPD. Les commandes légitimes, que vous pouvez envoyer
par Packet Sender s’appellent led1 et led0. Le contrôleur les interprète et allume
ou éteint la DEL en fonction. Un message de retour est transmis à l’émetteur. Si
une autre commande a été envoyée, le message « Wrong UDP Command » apparaît sur le moniteur série. Le même message est transmis à l’émetteur via le
réseau. Dans le code source nous examinons à nouveau d’abord une ligne dans
la fonction configUDP():
success &= sendCom("AT+CIPSTART=\"UDP\",\"192.168.4.255
\",90,91", "OK");
Cette fois l’IP est modifiée. Cette IP doit vous paraître surprenante car il ne s’agit
pas de l’IP de votre ordinateur. Alors comment les données peuvent-elles arriver ?
Cette IP fonctionne car il s’agit d’une toute autre IP, à savoir une IP que nous
appelons IP de diffusion (Broadcast). Diffusion (Broadcast) signifie traduit en
rayonnement, p. ex par les émissions radio. Comme avec les émissions radio, des
données de diffusion peuvent être réceptionnées par plusieurs participants, dans
ce cas par tous les participants qui sont eux-mêmes dans le sous-réseau.
L’adresse 255 à la fin de l’IP est toujours une adresse de diffusion. Vous pouvez
maintenant lancer le programme Packet Sender sur un autre ordinateur et écouter
tous les messages envoyés et également envoyer des commandes. La communication ne se fait plus uniquement entre deux participants.
001 void loop() {
002
if (esp8266.available())
003
{
004
if (esp8266.find("+IPD,"))
005
{
006
if (esp8266.find("led")) {
007
int setLed = esp8266.parseInt();
008
digitalWrite(LED, setLed);
009
010
debug("LED=" + String(setLed));
011
if (sendCom("AT+CIPSEND=7", ">"))
012
{
013
sendCom("LED=" + String(setLed), "OK");
014
}
015
}
016
017
else {
018
debug("Wrong UDP Command");
019
if (sendCom("AT+CIPSEND=19", ">"))
020
{
021
sendCom("Wrong UDP Command", "OK");
022
}
023
024
}
025
026
}
}
027 }
L’analyse des instructions qui arrivent a lieu dans la routine loopqui tourne en
permanence. S’il y a des données du module (esp8266.available()), elles sont
analysées sur la présence des caractères « +IPD, ». Si d’autre part l’instruction
led est trouvée, l’instruction parseInt()mémorise automatiquement les prochains
nombres dans les variables setLed. Grâce à notre définition des instructions, ce
doit être soit 1 ou 0 pour ainsi activer ou désactiver la DEL. Ensuite, la fonction
debug transmettra une confirmation à l’ordinateur via l’instruction CIPSEND. Si
l’instruction led ne faisait pas partie des données reçues par le module, un message d'erreur informe d’une instruction défaillante. La première commande par le
réseau serait ainsi complète.
2.4 | Commutateur réseau
Dans le programme précédent, les premières commandes ont été évaluées et une
DEL activée en fonction.
Le programme suivant comprend cette fonction mais peut en plus de manière
autonome envoyer une commande au réseau.
ssaires
Connectez un bouton-poussoir avec le contrôleur
NanoESP, 1 DEL (rouge), 1 boutoncomme indiqué dans l’illustration.
ce 1 kOhm (marron, noir, rouge), fil
Commutateur compact connecté à D8
Le programme
Le programme continue à évaluer les instructions qui entrent. De plus, le bouton
est interrogé continuellement. S’il est actionné par l’utilisateur, le contrôleur envoie
le code
Bouton = 1
au réseau. Tous les appareils connectés au module avec un serveur UDP au port
90 peuvent recevoir l’instruction. Vous pouvez à nouveau vérifier cela avec Packet
Sender. Si vous disposez de deux contrôleurs, vous pouvez établir le même circuit
sur le deuxième contrôleur et uploader le programme sur les deux contrôleurs
avec une légère variation. En effet, si vous transmettez à la place de Bouton=1 la
commande led=1 , vous pouvez contrôler la LED de chaque contrôleur en appuyant sur une touche. En revanche, il peut arriver que vous contrôliez simultanément la DEL du propre contrôleur.
Déroulement dans Packet Sender
Les modifications du programme sont avant tout dans la routine loop. Une simple
requête ifcontrôlée en appuyant sur le commutateur. Si c’est le cas, le contrôleur
transmet le message Bouton=1 au réseau. De plus il y a un message debug. La
boucle whilequi suit a pour effet qu’un flux de commandes ne soit pas immédiatement envoyé tant que vous appuyez sur le bouton. Vous devez donc d’abord relâcher le bouton avant de poursuivre le programme.
001 if (!digitalRead(SWITCH))
002 {
003
debug("Button=1");
004
sendUDP("Button=1");
005
while (!digitalRead(SWITCH)) {}
006 }
Dans un projet d’automatisation de la maison, un serveur recevrait maintenant le
message d’état par exemple d’un capteur de proximité et enverrait ensuite la
commande d’allumer la lumière à un autre contrôleur. Ainsi se monte tout un réseau de capteurs et acteurs.
2.5 | Capteur analogique
Le dernier projet a traité la forme la plus simple d’un capteur avec un boutonpoussoir. Cette fois il faut utiliser un potentiomètre comme capteur analogique
pour envoyer des valeurs de mesure en permassaires
nence au réseau. Le potentiomètre livré 10 kΩ est
NanoESP, 1 DEL, 1 résistance 1
utilisé. Le montage est indiqué sur la figure cirouge), 1 potentiomètre, fil électrique dessous.
Montage avec potentiomètre sur A6
Le programme
À côté du capteur analogique, il y a encore une autre modification du programme.
Cette fois-ci le contrôleur ne doit plus être exploité en mode point d’accès mais se
connecter avec votre réseau domestique. Vous pouvez également cette fois-ci
inscrire vos données de station tout simplement en haut dans le programme.
Après l’upload il peut s’écouler un moment jusqu’à ce que la connexion au réseau
soit établie. Si elle est réussie, la DEL D3, qui est assemblée solidement sur la
platine, commence à s’éclairer. C’est le signe que le contrôleur est prêt. Tant que
le moniteur série est actif, vous verrez un message correspondant, mais pour les
tests ultérieurs vous voulez éventuellement utiliser la platine de façon autonome et
ce retour peut donc s’avérer très utile. Par le moniteur série vous recevez également l’information sur quelle adresse IP le routeur a affecté la platine. Cette IP est
importante, dans la mesure où vous voulez adresser la platine ultérieurement.
La communication avec la platine fonctionne de manière similaire aux tests précédents. Seules les IP du module et de son ordinateur ont été modifiées car une IP a
été attribuée par le routeur aux deux appareils. Après le lancement Packet Sender
ne reçoit d’abord aucun résultat de mesure. Vous devez d’abord envoyer un message, p. ex. la commande led=1 au module. À cela indiquez à Packet Sender la
nouvelle IP du module que vous pouvez connaître par le module série. Après
l’instruction des nouvelles données de mesure arrivent env. toutes les secondes.
Les données de mesure ont été reçues par Packet Sender
Dans ce programme, il y a une autre modification dans l’instruction CIPSTART.
D’une part l’adresse de diffusion a été étendue, parce qu’on ne peut pas prédire
quel sous-réseau votre routeur étend. La deuxième modification réside dans
l'ajout d’un paramètre, ici le deuxième. Le nouveau paramètre permet de changer
l’adresse de destination de la commande
CIPSEND. Le module écoute d’abord dans tout l’espace qui commence
par192.168. Et dès qu’une commande est reçue, le module se règle sur la nouvel-
le IP.
success &=sendCom("AT+CIPSTART=\"UDP\",\"
192.168.255.255\",90,91,2", "OK");
Pour ce paramètre, il y a les possibilités suivantes :
1 Mode 0: Cela signifie que l’IP et le port ne se modifient pas. C’est également la
configuration par défaut, ce qui est clair si vous considérez d’autres modes.
2 Mode 1: Les paramètres se modifient une fois. Cela signifie ce qui suit : si le
module démarre avec l’adresse de diffusion déjà utilisée et reçoit ensuite quelque
chose d’un PC, le module se règle sur la nouvelle adresse du PC. En d’autres
termes, l’IP de destination que vous avez enregistrée devient superflue et il est
envoyé à la place à la nouvelle adresse. Cette adresse reste valable même si le
module reçoit des données envoyées d’un autre module.
3 Mode 2: Les paramètres se modifient à chaque réception d’un nouvel appareil.
Cela signifie que l’IP, même si elle avait déjà été modifiée une fois, peut cependant se régler sur un nouveau PC.
C'est également la raison pour laquelle vous devez d’abord envoyer une instruction au module avant de pouvoir recevoir des données. Vous devez aussi pouvoir
recevoir des données depuis cet ordinateur. Sauf si vous envoyez à nouveau un
message au module depuis le nouveau PC.
001 boolean sendUDP(String Msg)
002 {
003
boolean success = true;
004
005
success &= sendCom("AT+CIPSEND=" + String(Msg.length() + 2),
006
if (success)
007
{
008
success &= sendCom(Msg, "OK");
009
}
010
return success;
011 }
L’envoi de la valeur analogique se fait dans la routine loop. D’ailleurs la nouvelle
fonction sendUDP() est utilisée, et rend les fonctions connues plus facilement
accessibles. Il ne doit pas y avoir nécessairement de retard entre les envois
d’instructions car le transfert dure un certain temps. En effet, la fréquence, par
laquelle les nouvelles données sont transférées, est tellement élevée que le PC
est littéralement bombardé de messages.
CLIENT TCP
Le dernier chapitre a traité du protocole UDP avec lequel les données sont envoyées et reçues de façon simple. Une multitude d’applications peut déjà être
réalisée avec le protocole. Dans ce chapitre nous allons nous intéresser au protocole TCP (Transmission Control Protocol). Le module va prendre le rôle d’un client
TCP dans ce chapitre. C’est le rôle que prend votre PC à domicile face à un serveur web. La différence entre TCP et UDP se résume en gros dans les mots-clés
suivants :
U La connexion est précisément uniquement entre deux appareils.
U Les paquets envoyés sont contrôlés sur les erreurs de transfert et
corrigés le cas échéant.
U TCP est avant tout utilisé pour internet.
U Le protocole est un peu plus lent que UDP mais plus sûr.
Le protocole est également utilisé par votre PC et un serveur web, dont vous voulez charger une page web, pour établir une connexion entre les deux participants.
Les contenus véritables des pages web sont transférés ensuite sous format HTTP
(HyperText Transfer Protocol). Nous verrons dans le chapitre suivant comment
cela fonctionne exactement.
3.1 | Un navigateur
Cet essai utilise à nouveau l’installation existante. Il s’agit de se familiariser avec
les structures de base de la communication TCP avec le moniteur série.
Le programme
Le programme dans son mode de fonctionnement ressemble à SoftwareSerial-
Le programme du premier test établit entre autres la connexion WLAN indépendamment au démarrage. Vous économisez ainsi une quantité de travail d’écriture
et pouvez commencer plus vite. N’oubliez pas de transférer les données de votre
réseau domestique dans le programme. Saisissez ensuite dans le moniteur série
les lignes de commandes suivantes :
AT+CIPSTART="TCP","www.example.com",80
Avec cette commande vous établissez une connexion TCP avec le site web
www.example.com. Le port 80 est le port par défaut pour les requêtes HTTP.
Après confirmation de la connexion par OK vous pouvez saisir l’instruction suivante que vous connaissez déjà.
AT+CIPSEND=40
Vous voulez maintenant envoyer un message par la connexion établie. Lorsque
vous êtes invité par > à saisir un code, tapez d’abord
GET / HTTP/1.1
et appuyez ensuite sur [Enter]. [Enter]n’apparaît pas dans le moniteur série
mais le module le reçoit. Ensuite le message continue avec
Host:www.example.com
suivi deux fois par[Enter]. Vous devez en effet envoyer les saisies l’une après
l’autre très vite. Le mieux est de préparer un document texte à partir duquel vous
pouvez copier rapidement les lignes. Un long texte revient. La première partie est
la réponse du serveur et contient quelques informations pour le navigateur. Le
texte après <!doctype html> est la page web que vous voyez également quand
vous appelez directement la page www.example.com ici en format texte brut. Un
navigateur interprèterait ce texte et nous le représenterait dans une forme courante.
Extrait de la réponse du serveur web
Sur cet exemple vous voyez les principes de base du format HTTP. Un client établit une connexion avec un serveur web. Que vous ne deviez pas saisir l’adresse
IP, mais que vous puissiez utiliser le nom de domaine en format texte est lié à ce
qu’on appelle le DNS (Domain Name System). Cela transmet la requête à l’IP
difficile à remarquer. Si le client est connecté, le navigateur envoie une requête
Get Request. La page appelée ou les ressources (dans ce cas la page principale),
le protocole utilisé (http 1.1) et l’hôte demandé (www.example.com) doivent au
moins être indiqués dans cette requête. Les données de l’hôte sont importantes
car il peut y avoir plusieurs adresses internet sur un serveur et avec derrière une
IP. Si vous souhaitez demander une autre page que la page principale, écrivez à
la place p. ex. /example.html. À côté de la sous-page demandée votre navigateur
envoie d’ailleurs une quantité d’informations en plus des ressources appelées.
Des données telles que navigateur utilisé, système d'exploitation, résolution de
l’écran et d’autres encore sont transmises. Ainsi le serveur peut ajuster les contenus. Ensuite arrive la réponse du serveur qui d’abord semble complexe. La partie
entête de la réponse comprend beaucoup d’informations supplémentaires pour
votre navigateur. Uniquement à la fin suit le contenu réel de la page web.
3.2 | Une horloge internet
Ce projet nécessite de connaître les chapitres précédents pour que le NanoESP
récupère de façon autonome les informations d’un site web. Concrètement, le
programme charge l’heure en cours depuis une page spécialement conçue pour
cela et règle ainsi l’heure interne du contrôleur réalisée par librairie pour afficher
une heure précise. L’heure est donnée par le moniteur série. Pour l'installation
vous n’avez besoin que de la platine.
Le programme
Lors du programme précédent, il devait encore être principalement utilisé manuellement, celui-ci travaille de façon autonome. Le contrôleur se connecte complètement automatiquement au site web :
http://chronic.herokuapp.com/
Différents systèmes et fuseaux horaires peuvent être demandés par l’URL.
L’heure actuelle en hiver en Allemagne est demandée par l’URL
http://chronic.herokuapp.com/utc/in-one-hour
. C’est pourquoi se trouve dans l’appel de la fonction expliquée ultérieurement
getTime() comme deuxième paramètre utc/in-one-hour. Sur la base de l’UTC
(temps universel coordonné) vous devriez changer l‘appel pour utc/in-two-hours.
Selon le même système vous pouvez traiter également les autres fuseaux horaires.
Le temps déterminé est maintenant remis à la time library (librairie heure) par
Michael Margolis (source http://www.pjrc.com/teensy/td_libs_Time.html). Pour des
raisons pratiques, une copie de la version time library que j’ai utilisée se trouve
dans le dossier sketch. Elle doit être copiée dans le dossier librariesde votre dossier sketchbook. En arrière-plan la nouvelle heure est calculée en permanence et
chaque seconde transmise au terminal. Vous pourriez de manière simple programmer un réveil ou une autre application temporisée. Pour que la récupération
de l’heure puisse fonctionner, une nouvelle fonction est utilisée :
001 boolean getTime(String Host, String Subpage)
002 {
003
004
boolean success = true;
int xyear, xmonth, xday, xhour, xminute, xsecond; //lokal
variables
005
006
success &= sendCom("AT+CIPSTART=\"TCP\",\"" + Host +
"\",80", "OK");
007
String getRequest = "GET " + Subpage + " HTTP/1.1\r\nHost:" +
Host + "\r\n";
008
success &= sendCom("AT+CIPSEND=" +
String(getRequest.length() + 2), ">");
009
010
esp8266.println(getRequest);
011
012
if (esp8266.find("+IPD"))
013
{
014
if (esp8266.find("\r\n\r\n"))
015
{
016
xyear = esp8266.parseInt();
017
xmonth = esp8266.parseInt();
018
xday = esp8266.parseInt();
019
xhour = esp8266.parseInt();
020
xminute = esp8266.parseInt();
021
xsecond = esp8266.parseInt();
022
023
if (xday < 0) xday *= -1;
parseInt detects negativ integer
024
if (xmonth < 0) xmonth *= -1;
parseInt detects negativ integer
//Because of date seperator //Because of date seperator -
025
026
027
setTime(xhour, xminute, xsecond, xday, xmonth, xyear);
028
sendCom("AT+CIPCLOSE", "OK");
029
return true;
030
}
031
else return false;
032
}
033
else return false;
034 }
Des paramètres pour l’adresse hôte et la sous-adresse sont transmis à cette fonc-
tion. Il en résulte que la requête Get Request crée et, après la création d’une connexion, transmet au serveur TCP de la page web. La réponse du serveur doit
maintenant être analysée. De plus, toute la partie Request Header est sautée en
recherchant \r\n\r\n, qui ne signifie rien d’autre que ce qu’il se passe après un
double Carriage Return und New Line. Les autres chiffres correspondent à la date
et heure recherchées qui ont été mémorisées en variables intermédiaires par un
certain nombre de fonctions parseInt(). Il y a une particularité dans la date, car ici
les valeurs distinctes sont séparées par un trait, ce que la fonction parseInt()interprète comme un chiffre négatif. Par conséquent, les valeurs sont simplement multipliées par -1. Enfin, l’heure est réglée avec la fonction setTime()et
affichée par la routine loopune fois par seconde. L’heure est maintenant totalement opérationnelle.
3.3 | Affichage de la température
Avec ce projet il s’agit de l’affichage de la température actuelle et de la météo
générale. Cette fois également les valeurs sont transmises par le moniteur série. Il
y a en plus cependant une sortie intuitive avec la
ssaires
DEL RVB. On peut ainsi estimer par un seul coup
NanoESP, 1 DEL RVB, 3 résistances
d'œil s’il est opportun d’emmener une veste chauir, rouge), fil électrique
de.
Il est important lors du montage de brancher correctement la DEL RVB. RVB signifie Rouge, Vert, Bleu, car la DEL est composée de plusieurs DELs avec une
broche de cathode commune. Par une combinaison des différentes couleurs avec
des luminosités distinctes, il est possible de représenter pratiquement chaque
couleur. La DEL doit être branchée aux sorties PWM D3, D5 et D6 du contrôleur
avec prérésistances, comme indiqué sur la figure.
Branchement de la DEL RVB aux broches D3, D5 et D6
Le programme
Dans Sketch il s’agit à nouveau de la requête d’une page internet, mais cette fois il
s’agit d’une page spécialement programmée pour ce projet qui prend des données
depuis la page météo
http://www.openweathermap.com/
. Sur cette page on peut obtenir des informations sur la météo d’une ville par variation de l’URL. Vous pouvez saisir la ville, que vous voulez interroger, simplement dans le code source derrière City. Comme exemple j’utilise ma ville natale
Essen : www.temp.fkainka.de/?city=Essen
Le programme extrait la température de cette page et représente le résultat en
couleur via la DEL RVB. Simultanément la valeur est transmise par le moniteur
série. La plage de température utilisée dans le programme d’exemple pour la
représentation sur la DEL va de –20 °C à +40 °C.
Fondamentalement le programme fonctionne rapidement comme le précédent
mais avec quelques petites particularités. La fonction getTemp() est cette fois-ci
chargée de l’acquisition des données et renvoie la température actuelle, comme la
fonction de l’heure du programme précédent.
001 void rgbTemp(int val)
002 {
003
int green, blue, red ;
004
005
006
007
if (val <= 10 & val >= -20)
blue = map(val, -20, 10, 255, 0);
else blue = 0;
008
009
010
if (val >= 10 & val <= 40)
green = map(val, 10, 40, 255, 0);
011
else if (val >= -20 & val < 10) green = map(val, -20, 10, 0, 255);
012
else green = 0;
013
014
if (val > 10 & val <= 40) red = map(val, 10, 40, 0, 255);
015
else red = 0;
016
017
analogWrite(RED, red);
018
analogWrite(GREEN, green);
019
analogWrite(BLUE, blue);
020 }
L'ajustement des luminosités DEL est exécuté dans la fonction rgbTemp() . À
l’aide de la commande maples valeurs sont basculées en valeurs octets (0-255)
adéquates et délivrées à la DEL. Bleu correspond aux températures particulièrement froides et a un impact dans la plage de –20 °C à +10 °C. Vert est dans toutes les plages de températures mais a un maximum avec la valeur 10 °C. Rouge
débute à la valeur de +10 °C avec un maximum à +40 °C. Ce codage intuitif est
conçu pour évaluer la température actuelle en plus de l’affichage plus précis dans
le moniteur série.
SERVEUR TCP
Après avoir appris certains éléments sur l’utilisation du module en client TCP dans
le chapitre précédent, le module doit maintenant agir comme serveur TCP. D’une
manière pratique il existe également une instruction AT simple avec laquelle vous
pouvez démarrer cette application serveur complexe. Le module se comporte
ensuite comme un serveur TCP internet, sauf que vous devez programmer vousmême l’envoi de la page web.
4.1 | Serfvice web TCP
Les premières étapes en terme de serveur web TCP se font sans configuration
matérielle supplémentaire. Testez d’abord les instructions les plus importantes
simplement via le moniteur série.
Le programme
Saisissez comme jusqu’à présent les données WLAN et téléchargez le programme sur votre platine. Ensuite démarrez le moniteur. Cela peut durer à nouveau
quelques secondes jusqu’à ce que le message apparaisse, selon lequel la platine
est connectée. Lorsque le message de réussite est apparu et l’IP du module a été
affichée, vous pouvez démarrer dans le moniteur série avec la première instruction :
AT+CIPMUX=1
Vous autoriser plusieurs connexions au module par cette instruction. Ainsi plusieurs ordinateurs peuvent accéder au serveur web. Vous démarrer le serveur
web avec l’instruction suivante :
AT+CIPSERVER=1,80
Le paramètre 1 signifie que le serveur est démarré. Avec0 vous arrêtez le serveur. Le chiffre 80 représente le port par lequel le serveur est accessible. Les
requêtes HTTP envoyées par le navigateur sont généralement envoyées par le
port 80.
Vous pouvez maintenant ouvrir un navigateur de votre choix et saisir dans la barre
d’adresse l’IP du module et confirmer avec [Enter]. Dans le navigateur apparaît
d’abord un message de chargement mais vous pouvez remarquer une modification dans le moniteur série. Vous voyez une requête similaire à celle que vous
avez déjà envoyé manuellement.
La requête
du navigateur
Le navigateur attend une réponse et indique un caractère de chargement jusqu’à
ce que la connexion soit arrêtée en raison du temps de latence. Vous pouvez
envoyer un message avec une variante d’une instruction connue au navigateur :
AT+CIPSEND=0,7
Le paramètre 0 indique ici le client auquel le message doit être envoyé. Ceci est
nécessaire car plusieurs connexions sont autorisées et donc plusieurs clients
peuvent être connectés. Le deuxième paramètre, ici 7, indique de nouveau le
nombre de caractères à envoyer. > apparaît et vous pouvez saisir un simple
Salut
et envoyer avec [Enter]. Pourtant dans votre navigateur rien ne change d’abord
car vous devez fermer la connexion. Utilisez pour cela la commande :
AT+CIPCLOSE=0
Maintenant vous pouvez voir Salut dans votre navigateur. Vous avez réalisé ainsi
une première application serveur web.
Ce premier test montre beaucoup sur les processus précis de communication
dans internet. La représentation de « Salut » dans le navigateur est encore assez
facile car un texte plus simple à la place d’une page HTML complexe a été envoyé. Pour une page HTML correcte vous avez dû écrire manuellement toute une
entête aussi bien pour la requête Get Request que pour le texte HTML. Je vous
épargne cet effort dans le premier test.
4.2 | Serveur web autonome
Les résultats des essais précédents vont maintenant être utilisés dans un programme autonome. Le nouveau programme envoie non seulement une page web
au navigateur mais il permet également de contrôler une DEL. De plus, vous
voyez sur la figure du montage comment vous pouvez brancher une alimentation
électrique externe à la platine. Comme alternative
ssaires
à ce type de courant électrique s’offre également
une Power Bank (batterie externe, souvent pour
NanoESP, 1 clip 9 V, 1 DEL (rouge),
smartphone), qui peut alimenter simplement la
m (marron, noir, rouge), fil électrique,
platine par la connexion micro USB.
’apprentissage)
Vous connectez ainsi une pile au montage d’essai.
Le programme
Le programme envoie une page plus complexe que lors de l’essai précédent.
D’autre part, vous pouvez activer la DEL à la broche D9, en inscrivant /LED derrière l’IP du module. L’état actuel de la DEL est alors inversé, l’état basculera donc à
chaque fois (changement d’état).
Inscrivez vos données WLAN et téléchargez le programme. L’IP de la platine est
affichée dans le moniteur série. Vous pouvez ensuite ouvrir le navigateur et appeler l’IP de la platine. La page web a maintenant un titre et un peu plus de texte. Le
texte vous indique comment contrôler la DEL. Vous avez ainsi un premier serveur
web complètement autonome.
001 void loop() {
002
if (esp8266.available()) // check if the esp is sending a message
003
{
004
if (esp8266.find("+IPD,"))
005
{
006
debug("Incomming Request");
007
int connectionId = esp8266.parseInt();
008
009
if (esp8266.findUntil("LED","\n")) digitalWrite(LED, !digitalRead(LED));
010
011
String webpage = "<h1>Hello World!</h1>Open [IP]/LED to Toggle LED on D9";
012
013
if (sendCom("AT+CIPSEND=" + String(connectionId) + "," + String(webpage.length()),
">"))
014
{
015
sendCom(webpage,"SEND OK");
016
sendCom("AT+CIPCLOSE=" + String(connectionId),"OK");
017
debug("Send and Close");
018
}
019
020
}
}
021 }
Pour démarrer le serveur web, on dispose d’une fonction simple qui s’appelle
configTCPServer(). Derrière ne se trouve rien d’autre que ce que vous avez saisi
manuellement auparavant. Dans la routine loopsont attendues les données entrantes. Si ces données contiennent « DEL », la LED change d’état. Là la routine
ne fait aucune différence, là ou se trouve précisément « DEL », d’où la légitimité
de la commande dans l’URL transmise. Dans ce test, la page web elle-même se
trouve dans la variable de la page web et comprend le texte suivant :
001 <h1>Hello World!</h1>
002 Open [IP]/LED to Toggle LED on D9
Ici <h1> est une indication pour le navigateur de représenter le texte jusqu’à </h1>
comme titre de type 1. Il ne s’agit pas encore de véritable code HTML mais beaucoup plus d’une forme simple de représentation de texte. La longueur de la page
web est passée avec webpage.length() (une fonction de la classe de chaîne) à la
commande CIPSENDet transmise ensuite à la page.
4.3 | Page web avec boutons
Dans ce test la représentation de la page web est encore plus sophistiquée.
D’autre part, il y a désormais des éléments de commande par lesquels une DEL
peut être contrôlée vraiment confortablement. Le montage de ce test ne se différencie pas du précédent : une DEL sur la broche D9 est contrôlée par le module.
Pour cela, il y a quelques nouveautés dans le code source.
Le programme
Après le téléchargement du programme vous pouvez à nouveau appeler la page
web du contrôleur via un navigateur. Pour cela vous devez seulement saisir l’IP du
module qui a été donnée au démarrage par le moniteur série. La page web ellemême dans ce projet est en effet mémorisée un peu différemment que dans le
précédent.
La page web du serveur web
Alors qu’avant la page web était simplement contenue dans le code source, cette
fois-ci elle est mémorisée dans ce qu’on appelle des variables progmem (Program
Memory). L’utilisation de ce type de mémorisation décharge la SRAM de la platine
qui serait autrement responsable du stockage des variables. La SRAM ne comporte que 2 kB et est déjà très chargée par l’utilisation des chaînes. Le contenu du
site sera placé dans la mémoire du programme par la fonction progmem, qui est
beaucoup plus grande avec environ 32 kB. L'accès aux données est également un
peu plus complexe.
001 const char site[] PROGMEM = {
002 "<HTML><HEAD>\n<meta name=\"viewport\" content=\"width=device-width, initialscale=2.0,
003 (…)
004 };
Dans cet extrait on voit comment la page web est mémorisée dans la variable
progmem. Il s’agit d’un document HTML plus grand dans un format compatible C.
Le format se caractérise entre autres par le fait que les guillemets sont affichés
sous la forme \" et les nouvelles lignes sous la forme \n. Vous connaissez cela
probablement d’autres projets qui contiennent des chaînes. Vous pouvez également trouver un aperçu de la page web au format HTML dans le dossier programme.
001 String createWebsite()
002 {
003
String xBuffer;
004
005
for (int i = 0; i <= sizeof(site); i++)
006
{
007
char myChar = pgm_read_byte_near(site + i);
008
xBuffer += myChar;
009
}
010
011
012 }
return xBuffer;
Dans la fonction createWebsite() le contenu de la variable progmem est chargé et
retransmis en chaîne. On voit clairement comment la variable progmem est rechargée depuis la mémoire du programme.
001 boolean sendWebsite(int connectionId, String webpage)
002 {
003
boolean success = true;
004
005
if (sendCom("AT+CIPSEND=" + String(connectionId) + "," +
String(webpage.length()), ">"))
006
{
007
esp8266.print(webpage);
008
esp8266.find("SEND OK");
009
success &= sendCom("AT+CIPCLOSE=" + String(connectionId),
"OK");
010
}
011
else
012
{
013
success = false;
014
}
015
return success;
016 }
Dans la routine loopon attend uniquement une demande Request. Si elle vient, la
fonction sendWebsite() est appelée, qui transmet comme paramètre le résultat de
la fonction createWebsite(). La longueur du texte est déterminée par la fonction
longueur(). Après le transfert du site web, la connexion avec l’instruction AT+CIPCLOSEest
de nouveau fermée. L’activation de la DEL fait partie de la routine loopet se différencie légèrement du schéma précédent. Comment précisément, le cours intensif
HTML suivant le clarifie
4.4 | Parenthèse: Cours intensif HTML
Dans de chapitre je vais donner un petit cours intensif en HTML. Plus précisément
l’accent sera mis sur la création de pages web pour le contrôle du NanoESP. Les
structures de base d’un document HTML sont une partie de ce cours, la création
d’éléments d’entrée et de sortie et enfin l’intégration des propres pages web dans
le programme Arduino.
Une donnée HTML est toujours reconnaissable par <HTML> au début du document. La fin du document doit être reconnaissable par </HTML>. En général, le
début et la fin d’une section ou d’un élément sont affichés sous une forme comparable, comme on peut le voit sur l’entête. Dans l’entête se trouvent des informations et des formes importantes, comme dans ce cas le titre de la page web, qui
doit être affiché en haut dans la barre du navigateur. Dans ce cas il y a une autre
indication dans l’entête qui n’appartient pas aux bases HTML, mais qui améliore
l’affichage sur les appareils mobiles (<meta name ="viewport" …). Vous pouvez
ajouter ces lignes à tout moment dans votre page web HTML.
001 <HTML><HEAD>
002 <meta name="viewport" content="width=device-width, initial-scale=2.0, userscalable=yes">
003 <title>
004 Switch LED
005 </title>
006 </HEAD>
Après HEAD suit BODY. Celui-ici comporte le contenu de la page web. Dans la
zone de démarrage BODY sont fixés les paramètres supplémentaires tels que
arrière-plan et couleur de texte. Vous pouvez bien entendu adapter ceux-ci à tout
moment selon vos goûts. Ensuite vient la définition de la police et de sa taille dans
l’élément FONT. Ceux-ci ne s’appliquent ici que pour le texte Switch LED,qui
semble particulièrement grand car ensuite l’élément FONTest de nouveau terminé
par </FONT> .
001 <BODY bgcolor="#FFFF99" text="#000000">
002 <FONT size="6" FACE="Verdana">
003 Switch LED
004 </FONT>
La partie suivante se comporte exactement pareil avec seulement deux éléments
nouveaux, à savoir <HR>, qui produit une ligne horizontale sur la page web et
<BR>, qui gère le saut à la ligne suivante.
001 <HR>
002 <BR>
003 <FONT size="3" FACE="Verdana">
004 Switch the LED <BR>
005 on D9 ON and OFF
006 <BR>
007 <BR>
Tous les éléments présentés jusqu’ici étaient des facteurs de formes purs qui
servent à la conception de la page web. Ensuite vient en effet l’élément important
formavec lequel l’activation de la DEL est réalisée.
001 <form method="GET">
002
<button type="submit" name="led" value="1">LED ON</button>
003
<button type="submit" name="led" value="0">LED OFF</button>
004 </form>
L’élément formest comme le nom le laisse entendre conçu pour la production de formulaires sur internet. Il peut s’agir de formulaires de message pour une page web ou
un sondage ou quelque chose de similaire. Le transfert des données saisies par
l’utilisateur peut se produire totalement différemment. Dans cet élément, nous utilisons
la méthode GET par laquelle les données saisies sont transférées simplement au
serveur web avec l’URL. Dans ce formulaire, il y a deux boutons à cet effet. Les deux
sont du type submit, ce qui signifie qu’en appuyant sur un des deux boutons le formulaire est directement transféré. Les deux boutons ont le nom led, mais chacun des
valeurs différentes (values). En appuyant sur le premier bouton qui porte l’inscription
LED ON, l’URL actuelle est rappelée avec un petit supplément. Derrière l’URL, également dans ce cas derrière l’IP du module se trouve en effet /?led=1. Ce texte précisément est évalué dans le programme Arduino en recherchant puis le nombre suivant
est lu avec parseInt() et transmis à la DEL Avec cette première version simple d’un
formulaire le contrôle confortable d’une DEL est possible sans problème.
Voici à quoi ressemble l’URL après avoir appuyé sur le bouton LED ON.
001 <BR>
002 <HR>
003
004 </font>
005 </HTML>
Les dernières lignes de code source HTLM ne contiennent rien de nouveau. Un
saut à la ligne suivante et une ligne horizontale complètent l’image, avant que le
document avec </HTML> soit terminé. Vous pouvez maintenant modifier la page
web dans le dossier sketch selon vos souhaits. Vous pourriez par exemple modifier la couleur de l’arrière-plan ou ajouter plus de texte sur la page web. Vous ne
devez cependant pas surcharger la page car la SRAM peut vite être débordée.
Lorsque vous avez exécuté les modifications, il est temps de les transférer dans
votre programme Arduino. Copiez le texte entier dans le presse-papiers et allez
sur la page web avec le Swiss Converter Tool:
http://www.percederberg.net/tools/text_converter.html
La page Swiss-Converter-Tool-après conversion réussie
Là collez le texte du presse-papiers et passez au point 2. Select Output : les paramètres C/C++/PHP – StringText et UTF-8 – Unix (LF). Déjà le texte compatible
Arduino apparaît dans la fenêtre inférieure que vous pouvez copier dans la variable progmem site . Lorsque vous téléchargez le programme modifié avec la nouvelle variable, vous voyez la nouvelle page web en appelant l’IP de la platine dans
le navigateur.
4.5 | Contrôler la DELRVB par TCP
Dans le projet actuel il s’agit de la commande de la DEL RVB par une page web
sur un serveur web. La couleur de la DEL peut être modifiée par une interface
précise. La page a été ajustée et doit être bien
ssaires
affichée sur les smartphones. Le montage nécesNanoESP, 1 DEL RVB, 3 résistances
saire est indiqué sur la figure ci-dessous.
ir, rouge), fil électrique
Branchement de la DEL RVB aux broches D3, D5 et D6
Le programme
La nouvelle page web peut être de nouveau trouvée dans la variable progmem site.
Ici aussi vous pouvez consulter la page HTML dans le dossier sketch. Après le paramétrage des données WLAN et l’upload du programme, la page web du serveur
web peut être atteinte par l’IP du module. La page est identique à la précédente en
ce qui concerne la couleur de l’arrière-plan et le titre. Pourtant il y a un nouvel élément sur la page, à savoir l’élément HTML5Color Picker. Avec celui-ci on peut choisir une couleur pour la DEL. Dès que vous avez confirmé la couleur, elle s’affiche
depuis la DEL. L’affichage de l’élément Color-Picker peut fortement varier en fonction du navigateur sélectionné.
La page web dans le navigateur
La sélection
de la couleur dans
le navigateur Chrome
Même si le design de la page web n’est pas très différent du précédent, j’aimerais
vous décrire brièvement de façon plus précise quelques éléments. D’abord il y a
une modification dans l’entête du document HTML et ce concernant la ligne suivante :
<link rel="icon" href="data:;base64,iVBORw0KGgo=">
Cette ligne est là pour que le navigateur n’essaie pas après le chargement de
charger ce qu’on appelle Favicon. En général, une page web a en effet un symbole particulier qui est différent des autres pages web et identifie clairement la page
web dans une barre du navigateur avec plusieurs onglets. Pour que le navigateur
puisse charger ces caractères, il envoie après l’appel de la page une deuxième
requête et demande ce favicon. Dans les premiers essais avec le serveur TCP
vous avez peut-être remarqué cette requête supplémentaire. Pour empêcher ces
deux requêtes et ne pas surcharger inutilement la platine, la deuxième ligne de
code ci-dessus fait comprendre au navigateur qu’il ne doit pas envoyer de
deuxième requête. Je vous recommande de prendre cette ligne pour vos propres
pages HTML.
La deuxième particularité de ce document est l’élément déjà mentionné ColorPicker. Il remplace pour ainsi dire les boutons de l’exemple précédent. Il s’agit
d’un élément HTML5 relativement nouveau.
Dans la page web précédente nous avons simplement choisi des boutons de type
submit pour que les valeurs du formulaire soient directement transmises en appuyant. Ceci n’est malheureusement pas possible avec un élément de saisie de
type color. Une possibilité de résoudre le problème serait de créer un bouton de
type submit qui devrait ensuite être appuyé après le paramétrage de la couleur.
Ceci sera démontré dans un test ultérieur. Ici a été collé un petit code JavaScriptCode (il s’agit de la partie onchange="this.form.submit()"), qui veille à ce que le
formulaire soit directement transmis après une modification.
L’élément Color-Picker-dans le navigateur Android-5.0.
On économise un autre bouton.
001 <form method="GET">
002
<input type="color" name="rgb" onchange="this.form.submit()"><BR>
003 </form>
La couleur choisie est maintenant transmise sous la forme /?rgb=%23,suivie de
six autres caractères. Le terme %23 signifie qu’il s’agit d’une hexadécimale. Pour
la couleur blanche l’URL est donc :
[IP]/?rgb=%23ffffff
Le contrôleur doit maintenant extraire les couleurs respectives de la DEL de ce
nombre hexadécimal, ce qui se passe dans la partie suivante de la fonction loop :
001 if (esp8266.findUntil("?rgb=", "\n"))
002
{
003
String hexstring = esp8266.readStringUntil(‚ ‚);
004
long number = (long) strtol( &hexstring[3], NULL, 16);
005
006
int r = number >> 16;
007
int g = number >> 8 & 0xFF;
008
int b = number & 0xFF;
009
010
analogWrite(RED, r);
011
analogWrite(GREEN, g);
012
analogWrite(BLUE, b);
013
}
Par la fonction strtol() le texte reçu derrière %23 devient d’abord un longnombre et
est ensuite converti par manipulation de bits en trois valeurs d’octets. Ceux-ci sont
finalement transmis par la fonction analogWrite()-à la DEL RVB.
4.6 | Capteur de lumière
Dans ce projet, la page web du serveur web n’est pas utilisée comme interface de
commande mais comme élément de sortie. La luminosité mesurée via un capteur
de luminosité est représentée précisément comme valeur relative avec un nouvel
élément HTML.
Pour le montage de l’expérience il faut le phototransistor qui sert de capteur de
lumière. Le phototransistor peut être facilement être échangé par une DEL. Vous
pouvez distinguer le phototransistor en regardant en haut dans la tête de
l’élément. La surface interne du phototransistor est grande et noire. La figure suivante montre le montage du test. Le collecteur du phototransistor est la plus petite
connexion, à +5 V. La résistance connectée en
ssaires
série au phototransistor a 10 kOhm
NanoESP, 1 phototransistor, 1 résisrron, noir, orange), fil électrique
Branchement du phototransistor à la broche A6 avec une résistance de protection de
10 kOhm
Le programme
Jusqu’à présent les pages web du serveur web consistaient toujours en une page
non modifiable qui envoyait les données au contrôleur. Maintenant la page web
doit être modifiée avant le transfert au navigateur pour indiquer la luminosité mesurée du phototransistor. Cela fonctionne car une sorte d’espace est caché dans
le code source de la page web. Le programme remplace maintenant au chargement des données de la variable progmem l’espace réservé *bright* par la valeur
de luminosité actuelle. Ainsi le texte de sortie et l’écart du curseur sont modifiés.
Une autre ligne dans les données HTML assure que la page se recharge automa-
tiquement toutes les deux secondes. Déjà, la luminosité actuelle est affichée clairement dans le navigateur.
La page web du capteur de luminosité
Pour que le système puisse fonctionner, il y a quelques petites modifications dans
les données HTML. La première modification se trouve de nouveau dans la zone
entête :
<meta http-equiv="refresh" content="3">
Cette petite ligne assure que le navigateur recharge la page web automatiquement toutes les trois secondes. Cela vous évite d’appuyer constamment sur [F5]
pour pouvoir voir une nouvelle valeur.
La deuxième modification est là où se trouve normalement l’élément form :
001 <label for="hell">Current Brightness: *bright*</label> <BR>
002 <input type="range" max = "1024" name="hell" value=*bright*><BR>
Ici aucun formulaire n’est nécessaire car vous n’utilisez la page web qu’en sortie.
Les deux éléments label et range servent d’élément de sortie. Dans Label, qui est
normalement utilisé pour le titre, on trouve dans le texte la place *bright* .
L’élément curseur range reçoit comme value la valeur *bright* assignée, qui n’est
pas vraiment une valeur légitime mais sera remplacée par l’une d’elles ultérieurement. La valeur maximale de range est 1 024 et a été adaptée à la plage 10 bits
du contrôleur ADC.
Il faut encore veiller dans le code source avant le transfert de la page web à ce
que l’espace réservé *bright* soit remplacé par une valeur légitime.
001 String createWebsite()
002 {
003
String xBuffer;
004
005
for (int i = 0; i <= sizeof(site); i++)
006
{
007
char myChar = pgm_read_byte_near(site + i);
008
xBuffer += myChar;
009
}
010
011
xBuffer.replace("*bright*", String(analogRead(SENSOR)));
012
013
return xBuffer;
014 }
Le remplacement de l’espace réservé est exécuté dans la fonction createWebsite(). D’abord la variable progmem est chargée comme d’habitude sur la mémoire
et stockée dans une chaîne. Toutefois, avant que la fonction renvoie cette chaîne,
toutes les chaînes de caractères *bright*sont remplacées par la valeur actuelle
mesurée sur le capteur. La fonction String replace() exécute la tâche complètement automatiquement. Enfin la chaîne modifiée est rendue et transférée par le
mécanisme connu sur votre navigateur.
4.7 | Commande GPIO
Ce nouveau projet permet la simple commande des broches numériques D2-D7
par la page web. Le statut des broches respectives est affiché dans le navigateur
pour que l’on ne perde jamais l’aperçu.
Pour pouvoir vérifier correctement l’état de la broche, un montage tel que dans la
figure ci dessous est recommandé. La DEL RVB ainsi que la DEL normale sont
utilisées. Cependant les cathodes des DELs ne sont pas cette fois-ci branchées à
la longue ligne de masse sur la partie extérieure de la carte mais elle se trouvent
sur une sortie numérique. Les DELs peuvent s’éclairer seulement si ces broches
sont activés en position basse.
ssaires
NanoESP, 1 DEL RVB, 1 DEL (rouge),
Branchement des DELs sur D2-D7
Attention ! Les DELs ne doivent pas être branchées sans prérésistances. Ce qui
est admissible ici dépend des résistances On du port interne FET d’environ 30
ohm. Étant donné que les DELs sont entre deux ports, elles travaillent donc avec
une prérésistance de 60 ohm. Selon le type et la couleur de DEL, un courant DEL
se règle entre 15 mA et maximum 360 mA, ce qui est encore admissible.
Le programme
La page web de ce programme nécessite ce qu’on appelle les Checkbox comme
éléments HTML. Quand vous téléchargez le programme et appelez la page de la
carte vous voyez une série de cases cliquables. Une coche dans la case signifie
que le pin est haut. Pas de coche signifie bas. Vous pouvez maintenant tester
quels pins doivent être hauts et lesquels bas pour que toutes les DELs s’éclairent.
La page web de la commande GPIO
Dans ce code HTML, la page web est utilisée aussi bien en formulaire d’entrée
qu’en élément de sortie. Lorsque vous jetez un coup d'œil à l’élément du formulaire, vous voyez qu’une série d’éléments d’entrée de type checkbox est utilisée Il
vous affectera un nom individuel dérivé du nom des pins. Le texte *checkedX*sert
à chaque fois d’espace réservé dans le texte. Lorsque le pin est bas, l’espace
réservé est simplement supprimé. Lorsque le pin est haut, le programme utilise à
la place de *checkedX* CHECKED ,qui affiche la Checkbox au chargement avec
une coche. Cette fois il y a également un bouton qui doit être cliqué après la sélection de la case correcte pour transférer le formulaire.
001 <form method="GET">
002 <input type="checkbox" *checked2* name="ld2">D2
003 <input type="checkbox" *checked3* name="ld3">D3
004 <input type="checkbox" *checked4* name="ld4">D4
005 <br><br>
006 <input type="checkbox" *checked5* name="ld5">D5
007 <input type="checkbox" *checked6* name="ld6">D6
008 <input type="checkbox" *checked7* name="ld7">D7
009 <br><br>
010 <input type="submit" value="Send">
011 </form></HTML>
L’évaluation dans le programme fonctionne désormais comme suit : Supposons
que les cases 3, 5 et 7 aient été sélectionnées dans le formulaire. L’URL se modifie pour :
[IP]/?ld3=on&ld5=on&ld7=on
Cela signifie que seules les cases sélectionnées sont transmises et identifiées
avec l’indice. Dans la routine loopvoici ce qu’il se passe exactement : D’abord tout
le port D, sur lequel se trouvent les sorties numériques, est activé bas. Ensuite
une boucle whilerecherche toutes les « Id » dans le lien ressources. Sur la base
de l’indice des ldtrouvées, enld3 serait p. ex. la 3,l’octet 0b0001000 se génère par
le décalage de 1 dans un octet autour de l’indice dit 3. Il est ensuite lié à la valeur
actuelle de l’octet. Cela se produit avec tous les indices transmis jusqu’à ce que le
registre de sorties de D trouve la valeur correcte. Cette forme de sortie au lieu de
digitalWrite() est sans doute quelque peu inhabituelle pour un utilisateur Arduino
dans ce cas mais bien plus pratique.
001 if (esp8266.find("+IPD,"))
002 {
003
debug("Incomming Request");
004
int connectionId = esp8266.parseInt();
005
if (esp8266.find("/?")) PORTD = B00000000;
006
while (esp8266.findUntil("ld", "\n"))
007
{
008
int ld = esp8266.parseInt();
009
PORTD |= (1 << ld);
010
}
011 }
À l’inverse, la sortie des cases à cocher fonctionne de la manière suivante : dans
la fonction createWebsite()les espaces réservés sont échangés depuis le document HTML. Une boucle forpasse un par un tous les ports utilisés de la série. Si le
pin est haut (également remarqué ici par la comparaison d’un octet qui a été généré en décalant les octets hauts), l’espace réservé avec l’indice est remplacé par le
texte checked. Lorsque le pin est bas, l’espace réservé est simplement seulement
supprimé. Ainsi l’affichage correct du port actif est garanti.
001 String createWebsite()
002 {
003
String xBuffer;
004
005
for (int i = 0; i <= sizeof(site); i++)
006
{
007
char myChar = pgm_read_byte_near(site + i);
008
xBuffer += myChar;
009
}
010
011
for (int x = 2; x <= 7; x++)
012
{
013
if (PORTD & (1 << x))
014
{
015
xBuffer.replace("*checked" + String(x) + "*", "checked");
016
}
017
else
018
{
019
xBuffer.replace("*checked" + String(x) + "*", "");
020
}
021
}
022
return xBuffer;
023 }
Lors de la création de ce programme, j’ai eu quelques problèmes dont la cause
n’était pas claire au début. Au chargement de la page web il y a eu des erreurs
étranges et souvent les cases à cocher complètement erronées étaient sélectionnées.
À
l’aide
de
la
librairie
Arduino-MemoryFree-Master-Library
(http://playground.arduino.cc/Code/AvailableMemory) je suis arrivé à la solution :
La mémoire SRAM était poussée à sa limite et pour cette raison causait des erreurs extraordinaires et imprévisibles. J’ai dû considérablement alléger la version
originale du programme et le code HTML pour que le programme puisse fonctionner dans cette version. Je mentionne cela car la même chose peut se produire
lors de la création de votre propre programme. La raison de l’importante sollicitation de la SRAM provient avant tout de l’utilisation généreuse certes bien pratique,
mais aussi l’utilisation dévorante de ressources des fonctions chaîne et en général
de l’utilisation de chaînes à la place de chaînes char. Un string.replace() est très
pratique mais réclame aussi beaucoup d’espace mémoire. Si vous êtes face à des
erreurs inexpliquées, je vous recommande de réduire le code source du fichier
HTML et d’autre part éventuellement d’optimiser quelques opérations de chaîne.
La libraire nommée ci-dessus peut vous aider dans la recherche d’erreur.
4.8 | Parenthèse: Accéder à la carte depuis internet
Beaucoup des tests présentés ici sont pratiques pour la commande de la carte
dans son propre réseau domestique. En tout cas cela peut être utile pour atteindre
la carte depuis de plus grandes distances. On pourrait p. ex. activer l’éclairage
chez soi alors que l’on est en vacances pour effrayer les cambrioleurs. Ou on
contrôle par le capteur de lumière si la lumière est vraiment éteinte. Ou on envoie
un message court à ceux à la maison qu’il se fait tard. Pour que ces idées puissent devenir réalité vous devez procéder à quelques paramétrages sur votre routeur.
En général, les différents types de routeurs utilisent également différents logiciels.
Je vais présenter ici les étapes principales avec un routeur Fritz!Box. Les paramétrages de votre routeur devraient être similaires.
La plupart des routeurs modernes ont une interface web simple similaire à celle
que nous avons créée avec le module. Vous avez besoin d’un identifiant et d’un
mot de passe pour pouvoir vous enregistrer sur l’interface. Pour des routeurs de
type Fritz!Box l’IP est souvent 192.168.178.1. Ou vous pouvez également entrer
http://fritz.box. Si vous utilisez un autre routeur vous devez essayer de trouver l’IP
adaptée. En général le routeur utilise dans le sous-réseau l’IP avec l’adresse 1. Si
l’IP de votre ordinateur est p. ex. 192.168.4.2, l’IP de votre routeur sera vraisemblablement 192.168.4.1. Le mot de passe et l’identifiant se trouvent la plupart du
temps au dos du routeur ou dans le manuel correspondant.
Lorsque vous vous êtes inscrit dans l’interface utilisateur vous devez trouver le
point renvoi de port ou redirection de port. Dans ma Fritz!Box le point se trouve
sous Internet -> Renvoi. Créez une nouvelle règle de port. Les paramètres doivent
être choisis de façon à ce que les requêtes externes sur le port 80 soient redirigées sur l’IP de votre carte et sur le port 80. Dans le menu de la Fritz!Box le réglage est facilité et j’ai juste dû choisir le point HTTP-Serverensuite j’ai pu choisir
dans le menu déroulant simplement dans les IP présentes. Le résultat doit être
identique sur tous les ordinateurs.
Les paramétrages corrects dans la Fritz!Box
Les paramétrages sur le routeur seraient ainsi clarifiés et on peut tenter un premier test. Pour cela, cette fois-ci vous avez besoin de l’IP, pas de l’IP de la carte
dans votre réseau locale mais de l’IP globale. Vous pouvez trouver celle-ci sur la
page
http://www.meine-aktuelle-ip.de/
. Si vous entrez là l’IP transmise maintenant dans votre navigateur, la page web
du module doit apparaître. Cette fois-ci toutefois le long chemin est pris via internet. Si vous n’êtes pas convaincu que la carte peut maintenant être atteinte via
internet, vous pouvez utiliser un smartphone avec internet mobile et appeler ainsi
la page. Si le smartphone n’est pas connecté directement à votre WLAN, la page
peut dans tous les cas être appelée via internet.
Le système que vous avez établi se prête bien aux tests, il y a cependant deux
problèmes pour une utilisation pratique. D’une part l’IP ne se remarque pas facilement et d’autre part elle change assez fréquemment. La plupart des routeurs se
reconnecte au moins une fois par jour pour que l’IP globale de votre routeur change également. Pour ce problème, il y a un remède, c’est à dire le Domain Name
System (DNS). Ce système permet p. ex. que vous puissiez appeler
www.google.de et ne deviez pas saisir l’IP car il encode des IP compliquées dans
des noms faciles à remarquer. Chaque site internet normal utilise un DNS et il
existe également pour vous la possibilité d’utiliser ce système gratuitement.
Il y a différents sites web gratuits qui proposent des DDNS. DDNS signifie Dynamic Domain Name System et est un service qui garantit que votre IP est associée
au domaine correct. Je propose ici le service du site http://www.anydns.info/ et
vous pouvez également utiliser tout autre service web qui propose ce service.
Le site web info AnyDns
Vous devez d’abord vous inscrire sur le site et déjà indiquer un nom de domaine.
J’ai choisi le nom nanoesp et comme hôte dynpc.net. Le domaine qui en résulte
après l’inscription :
http://nanoesp.dynpc.net/
Maintenant le service doit encore apprendre votre IP. Transférez le service dans
votre routeur de façon à qu’une nouvelle IP soit dirigée directement au service
DDNS. Dans la Fritz!Box je devais d’abord cliquer sous l’affichage : Étendu pour
que toutes les options soient affichées. Ensuite je pouvais sous Partages enregistrer également le service DDNS.
Les paramétrages de la Fritz!Box pour l’utilisation du Dynamic DNS
Quelques mots encore en avertissement :
Le service DDNS est sans doute très pratique, cependant vous devez être prudent
lorsque vous donnez votre nom de domaine. Ils vous rendent accessible car un
hacker n’a besoin de connaître que votre domaine et pas votre IP actuelle pour
accéder à votre routeur. C’est pourquoi je laisserai dans le réseau la page nommée ci-dessus comme test.
THINGSPEAK
Dans ce dernier chapitre il s’agit d’un tout nouveau sujet, à savoir la plate-forme
ThingSpeak. Ce site a été spécialement développé pour le sujet Internet of Things
et met à votre disposition différentes fonctions pratiques. Entre autres, vous pouvez à l’aide de cette page d’une manière simple journaliser une surveillance longue durée de capteurs de mesure et les représenter sous forme plus claire. Tant
que vous êtes connecté à internet, vous vous épargnez l’enregistrement des valeurs sur un support de stockage externe. De plus, vous pouvez réaliser différentes commandes via internet. Vous apprendrez au cours de ce chapitre à quoi
ressemblent exactement ces fonctions.
5.1 | ThingSpeak
Comme d’habitude, avant de voir le montage et le programme, vous devez vous
créer d’abord un compte sur le site
www.ThingSpeak.com
. Connectez-vous ensuite avec vos données utilisateur sous le point Sign In .
Vous voyez une page qui indique votre canal (channel). Comme vous n’avez encore aucun canal cette page semble plutôt vide. Cliquez sur New Channel et
donnez un nom p. ex. Light,car dans ce projet vous allez mesurer la luminosité.
Sous le point Field 1 vous pouvez encore donner un nom pour le champ, éventuellement Brightness. Tous les autres champs peuvent rester vides pour
l’instant.
Création d’un canal sur le site ThingSpeak
Cliquez sur Save Channel pour sauvegarder les paramètres. Vous êtes redirigé
sur la page de votre canal sur laquelle on peut voir uniquement un diagramme
vide. Cliquez dans l’onglet ci-dessus sur API Keys. Les suites de chiffres et de
lettres que vous trouvez sous le point Write API Key vous serviront bientôt.
Le montage de ce test consiste en un capteur sur l’entrée analogique A6. Un diviseur de tension avec une résistance de 10 kΩ et un phototransistor permet la
mesure de la luminosité actuelle. Vous pouvez également utiliser le capteur de
température. Le circuit reste à peu près le même
ssaires
sauf que vous remplacez le transistor de lumière
NanoESP, 1 phototransistor, 1 résispar la thermistance NTC noire. La polarité est
rron, noir, orange), fil électrique
arbitraire en NTC.
Montage avec phototransistor sur A6
Le programme
Le programme mesure maintenant la luminosité. Mais contrairement à
l’expérience précédente, les données ne sont pas sur une page web mais directement envoyées sur le site ThingSpeak. Ce site ne mémorise pas seulement les
données, il les représente également en aperçu dans un diagramme – une fonction très pratique pour une station de mesure avec surveillance longue durée.
Pour que le programme puisse envoyer au site web, vous devez enregistrer
d’abord, en plus de vos données WLAN, la clé API mentionnée ci-dessus sous le
point ThingSpeakKEY dans le programme. Après l’upload vous voyez les valeurs
de mesures actuelles dans le moniteur série. Pendant 15 secondes les données
sont rassemblées et ensuite transmises. Cette valeur est ensuite inscrite dans le
site ThingSpeak. Les 15 secondes sont importantes car vous ne pouvez pas surcharger le site ThingSpeaktoutes les secondes avec de nouvelles valeurs. Vous
visualisez le résultat de la mesure maintenant sur votre page canal dans le diagramme de représentation en bas.
Les résultats de mesure dans le diagramme
Le code source semble très différent de tous les programmes précédents. Il s’agit
cependant essentiellement d’une compilation des éléments bien connus. La requête HTTP contient une variable progmem qui doit être envoyée sur le site
ThingSpeakà côté de quelques espaces réservés qui doivent être remplacés en
fonction des requêtes.
001 POST *URL* HTTP/1.1
002 Host: api.thingspeak.com
003 Connection: close
004 Content-Type: application/x-www-form-urlencoded
005 Content-Length: *LEN*
006
007 *APPEND*
Comme vous voyez, l’appel correspond presque à l’appel get. Ici également une
*URL* doit être précisée. De plus vous devez remplacer *LEN* par la longueur du
message que vous saisissez à la place de *APPEND* .
Ceci est le format universel valide pour les sites web avec les données qui sont
envoyées avec POSTrequête sur le site. Si vous voulez enregistrer maintenant,
comme indiqué dans l’exemple, les données de mesure dans un canal dans votre
compte, vous devez utiliser la structure suivante : *URL* est
/update. C’est le sous-site sur lequel les données doivent être envoyées. Le message est maintenant composé de votre clé API, du champ à remplir et de la valeur. La longueur du message se détermine facilement par la longueur de la chaîne. Dans l‘ensemble, un exemple POST ressemble à ceci :
001 POST /update HTTP/1.1
002 Host: api.thingspeak.com
003 Connection: close
004 Content-Type: application/x-www-form-urlencoded
005 Content-Length: 35
006
007 api_key=GXE93O4WF03Q3X8I&field1=954
Le site web peut clairement identifier l’utilisateur et le canal par la clé API et enregistre les valeurs. L’ensemble de la fonctionnalité de la compilation des requêtes
est cachée derrière plusieurs fonctions. Pour envoyer la nouvelle valeur vous
devez seulement appeler la fonction sendThingPost() qui a besoin comme paramètre de la KEY et des données du capteur. Tout le reste est exécuté automatiquement en arrière-plan.
5.2 | Affichage Twitch
Le site web ThingSpeak propose un peu plus que la surveillance longue durée de
capteurs. Le projet suivant est similaire au projet du client TCP. Les informations
sont en effet obtenues depuis un site web sur internet. Dans ce cas il s’agit de
savoir s’il y a déjà ou non un flux en ligne.
Il y a deux avantages significatifs de la variante ThingSpeak par rapport aux premières expériences. Premièrement, d’autres sites web peuvent être traités par
ThingSpeak via HTTPS (HyperText Transfer Protocol Secure) alors que le module
de supporte que le protocole HTTP qui est bien moins sûr. Deuxièmement le site
web peut déjà préfiltrer des informations et ainsi réduire la quantité de données à
traiter par le contrôleur.
Dans ce projet vous réaliserez un affichage Twitchen streaming comme exemple
type pour différentes possibilités. Twitch (www.twitch.tv) est un site web sur lequel
des jeux en live ou d’autres contenus autour des jeux sur ordinateur sont diffusés.
Un des canaux les plus connus de streaming est RocketBeansTV l’ancien concepteur de GameOne. Ce canal diffuse 24/24 et pour cela est bien adapté pour un
ssaires
NanoESP, 1 DEL (rouge), 1 résistannoir, rouge), fil électrique
premier essai. Ultérieurement vous pouvez bien
entendu utiliser un canal de votre choix.
Montage de l’expérience avec une DEL sur le pin D9
Le programme
À côté de la structure hardware quelques étapes sur le site ThingSpeaksont nécessaires. Lorsque vous cliquez sur le site tout en haut dans le menu Apps
une série de différentes applications s’affiche. Cette fois-ci nous nous occupons
de l’appli ThingHTTP. Lorsque vous cliquez sur le bouton correspondant, une
interface complètement vide s’affiche. Cliquez sur New ThingHTTP. Dans le formulaire qui est apparu saisissez ce qui suit :
Nom :
Twitch
URL :
https://api.twitch.tv/kraken/streams?channel=
rocketbeanstv
Méthode :
GET
HTTP Version: 1.1
Parse String:
_total
Si vous préférez un autre canal de streaming, vous pouvez entrer dans l’URL
derrière channel un autre canal. Cliquez sur Save ThingHTTP et copiez ensuite la
clé API apparue dans l’aperçu dans le presse-papiers. Vous devez maintenant
copier la clé dans le programme et derrière #define ThingHTTP. Ne pas oublier les
données WLAN et vous pouvez déjà uploader le programme. Une fois par minute
la présence d’un flux est contrôlée. Si c’est le cas, la DEL commence à s ‘éclairer.
Ce programme est possible dans la mesure où les informations du site Twitchsont
également disponibles dans le format connu JSON. Par le site
https://api.twitch.tv/kraken/streams?channel=rocketbeanstv
Vous pouvez regarder la sortie en format JSON. C’est une quantité de texte mais
seul l’attribut nous intéresse _total,qui affiche le nombre de flux actifs Si ce chiffre
est supérieur à zéro, cela signifie qu’au moins un flux est actif. Cet attribut est
automatiquement préanalysé par ThingSpeaket sorti en valeurs plus claires. Cette
valeur est ensuite facilement appelée et évaluée dans le programme par la fonction getThingSpeakHttp().
5.3 | Système d’alarme Twitter
Dans ce projet il s’agit d’un système d’alarme avec lequel vous pouvez par exemple contrôler si quelqu’un ouvre un tiroir sans autorisation. En cours la lumière est
contrôlée sur le capteur de lumière connecté si la luminosité fixée diminue. Si c’est
le cas, un signal d'alarme est émis et en plus un message est envoyé via Twitter.
Le montage est sur la figure ci-dessous. Ou bien vous pouvez naturellement également ici utiliser le capteur de température et
ssaires
surveiller le dépassement d’une certaine tempéraNanoESP, 1 phototransistor, 1 résisture.
rron, noir, orange), 1 piezo, fil électri-
Capteur de lumière sur A0, piezo sur D8
Le programme
Le sujet est ici entre autres l’appli Twitter du site ThingSpeak. Cliquez donc sur
Apps et ensuite sur ThingTweet. En cliquant sur Link TwitterAccount et en saisissant vos données d’accès, vous établissez une connexion entre les deux services.
Si vous n’avez pas encore de compte Twitter, cela vaut la peine de créer un
compte pour travailler avec le kit d’apprentissage pour les essais. Une fois que
Twitter a été lié avec succès avec ThingSpeak vous pouvez sous
Apps/ThingTweet enregistrer la clé API derrière le point #define TwitterKEY .
Le programme vérifie maintenant en permanence si la luminosité mesurée passe
au-dessus d’une valeur de 500. Si c’est le cas, un message Twitter est envoyé et
l’alarme sonne et ce tant que la luminosité n’est pas redescendue sous 500. Vous
pouvez suivre les valeurs de luminosité actuelles mesurées par le moniteur série.
Pour les premières expériences je recommande de couvrir le capteur de lumière
pour que l’alarme ne se déclenche pas trop tôt.
La nouvelle fonction dans ce projet s’appelle sendTwitterPost(). Seuls TwitterKEY
et le message doivent être spécifiés comme paramètres. La fonction regroupe
toutes les parties nécessaires pour en faire un post ThingSpeak. Vous pouvez
également envoyer des messages en appuyant sur le bouton ou publier les résultats de mesure. Tout cela grâce à ThingSpeak-API.
5.4 | TalkBack
Dans ce projet il s’agit d’une autre appli du site ThingSpeak à savoir l’appli TalkBackAvec cette fonction il est possible de créer une instruction qui est lue et exécutée par le contrôleur. Ce qui semble inutile avec un seul contrôleur prend tout
son sens lorsque l’on utilise deux contrôleurs ou même tout un réseau de contrôleurs. Certaines cartes peuvent agir comme capteurs, par exemple avec des capteurs de proximité, et lors de la détection d’un mouvement envoyer une instruction
TalkBack. Un autre module lit l’instruction du site ThingSpeaket ouvre ensuite la
porte ou déclenche l’alarme.
Pour le montage de l’expérience vous avez besoin
ssaires
de deux boutons. Une DEL avec prérésistance
NanoESP, 2 boutons,1 DEL (rouge),
affiche l’état actuel.
m (marron, noir, rouge), fil électrique
Montage avec deux interrupteurs sur D5 et D10 et une LED sur D9
Le programme
D’abord il faut mettre en place surApps/TalkBack un nouveau canalTalkBack.
Vous pouvez utiliser comme nom p. ex. Doors. Si vous souhaitez vous pouvez
également enregistrer la commande sur un canal. Il peut s’agir du canal light déjà
créé de la première expérience ThingSpeak
ou d’un propre canal. Toutes les commandes sont ensuite journalisées. Ce qui est
important avant tout c’est la clé API que vous enregistrez via #define TalkBackKEY . En plus de la clé API, il faut cette fois une ID que vous trouvez sous TalkBack ID après avoir cliqué sur Save TalkBack. Vous enregistrez cette ID derrière
#define TalkBackID dans le programme.
Si maintenant vous avez téléchargé le programme et appelé le moniteur série,
vous verrez d’abord le message No Command. Appuyez maintenant sur un des
deux boutons. Après un bref moment apparaît le message OpenDoor ou CloseDoorselon le bouton sur lequel vous avez appuyé. Avec la commande OpenDoorla DEL commence à s’éclairer.
L’aperçu TalkBack lors de l’enregistrement d’une commande
Il existe une possibilité par laquelle vous pouvez saisir les commandes directement sur internet. Lorsque vous cliquez sur le site TalkBacksur votre canal Door
vous voyez sous l’option Add a new command. Avec celle-ci vous pouvez saisir
manuellement la commande OpenDoor ou CloseDoor et ainsi piloter le module.
Vous pouvez donc piloter la platine depuis plusieurs sources par les commandes
TalkBack. Dans le code source, la fonction getTalkBackCom() supporte la requête
de nouvelles commandes. Lorsque quelque chose a été trouvée, la commande est
retournée. Vous devez uniquement indiquer les paramètres key et id .
5.5 | Cheerlights
Cette expérience est basée sur un projet de Hans Scharler, qui s’appelle Cheerlights. L’idée : Dans le monde il y a des lumières en réseau qui se commandent
simultanément via les commandes Twitter. Un bon
ssaires
exemple est que le monde et internet se dévelopNanoESP, 1 DEL RVB, 3 résistances
pent ensemble.
ir, rouge), fil électrique
Les DEL RVB sur le circuit imprimé aux broches D3, D5 et D6
Le programme
Pour ce programme exceptionnellement vous ne devez procéder à aucune modification ThingSpeakcar le projet a déjà un canal public que vous trouvez sous
https://thingspeak.com/channels/1417
. Sur le site vous trouvez d’autre part toujours la couleur actuelle ainsi que d’autres
informations sur le projet.
Le site Cheerlights
avec la
couleur actuelle mauve
Pour ce programme il faut en plus la librairie Crossfade de Radek Wierzbicki
(source
:
https://github.com/radekw/Arduino/tree/5f24ce7c8db9dfbb5252b59824c3217d851
b3a3c). Pour des raisons pratiques, une copie de la version library utilisée se
trouve dans le dossier sketch. Elle doit être copiée dans le dossier libraries de
votre dossier sketchbook. La librairie permet de définir des couleurs rapidement et
simplement et veille à ce que les DELs apparaissent lentement dans une autre
couleur (fade).
Lorsque vous téléchargez le programme, la couleur actuelle de la DEL s'affiche
après quelques secondes. Vous pouvez maintenant soumettre un message Twitter et donc modifier votre couleur et également celle des autres utilisateurs Cheerlights. Le message doit contenir pour l’un #Cheerlights, @Cheerlights ou simplement juste le mot-clé Cheerlights et pour l’autre une des couleurs prédéfinies derrière le mot-clé. Font partie des couleurs prédéfinies :
red, green, blue, cyan, white, warmwhite, purple,
magenta, yellow, orange, pink
Un Tweet possible pourrait par exemple ressembler à :
Testing my #cheerlights project on my #NanoESP with the
color blue #ThingSpeak #IoT
Et déjà vous avez transmis au monde entier une nouvelle couleur.
La requête de la couleur actuelle est réalisée avec la fonction getCheerlightColor()
. Comme paramètres sont indiqués l’hôte, donc api.thingssspeak.comet l’URL, ici
/channels/1417/field/1/last.txt. Il s’agit donc d’une requête client TCP simple de
type connu. Ici également la réponse du serveur est réduite au texte pertinent et
renvoyée. La comparaison avec les mots-clés donne la couleur recherchée qui
apparaît ensuite à l’aide de la libraire crossfade. Un essai comparativement plus
simple avec cependant un effet aah plus important.
5.6 | Détecteur d’incendie Twitter avec fonction TalkBack
Ce projet de détecteur d’incendie relie deux éléments que avez rencontrés au
cours du travail avec le kit d’apprentissage. La platine est utilisée entre autres
pour la surveillance longue durée de la température. En même temps la platine
déclenche un signal d’alarme si la température dépasse une valeur définie, p. ex à
l’apparition d’un incendie. Ici la surveillance du dépassement de seuil n’est pas la
tâche de la platine mais de ThingSpeak-App React.
Pour le détecteur d’incendie, le type CTN (Coefficient de Température Négative)
présenté seulement comme alternative de capteur de lumière est utilisé cette foisci comme capteur. Celui-ci modifie sa résistance en fonction de la température.
Vous pouvez le commuter contre une résistance
ssaires
10 kOhm, mais dans ce cas le potentiomètre est
NanoESP, 1 potentiomètre, 1 piezo, 1
utilisé car on ne peut pas encore ajuster la mesul électrique
re.
Le montage du projet détecteur d’incendie
Le programme
Le programme doit réunir plusieurs éléments. Ici le site ThingSpeaka de nouveau
une grande importance. La surveillance du dépassement de seuil du CTN est
cette fois-ci supportée entre autre par une appli ThingSpeak. Les actions d’alarme
sont également exécutées de là, c’est à dire un message Twitter envoyé et une
commande TalkBackinsérée qui déclenche l’alarme sur le contrôleur.
La première étape est de créer un nouveau canal sur la page ThingSpeak. Vous
pouvez par exemple l’appeler FireAlarm . Le champ 1 reçoit ensuite la désignation
Temp. Sous API Key se trouve la première clé que vous devez enregistrer pour
ThingSpeakKEY . Déjà avec cela la transmission de la valeur actuelle de température serait garantie.
La deuxième étape est la création d’un nouvel élément TalkBack. Vous pouvez par
exemple utiliser comme nom Alarms. D’autre part vous pouvez laisser se connecter
les commandes dans le canal FireAlarm. Vous devez enregistrer la clé API derrière
TalkBackKEY et l’ID derrière TalkBackID. Vous pouvez désormais envoyer des
commandes à la platine. Vous pouvez également enregistrer les commandes manuellement, en cliquant dans l’aperçu TalkBack du canal d’alarme sur Add a new
Command et là enregistrer sous Command String Alarm . Une indication de la position n’est pas nécessaire puisque l’instruction est mémorisée automatiquement à la
première place. Vous pouvez maintenant télécharger et tester le programme, si la
transmission de la valeur de température actuelle fonctionne et si la platine exécute
la commande. À cette position cela vaut la peine de calibrer le CTN sur le potentiomètre par un thermomètre d’intérieur.
Au fond, ce serait déjà un projet de valeur mais il manque les fonctions bonus.
Celles-ci en effet ne doivent plus être exécutées dans le programme mais sur le
site ThingSpeak. Pour cela allez sur Apps et sélectionnez ensuite React . Avec React il y peut y
avoir une réaction à certains résultats . Créez donc en cliquant sur New React une
nouvelle fonction Reactet saisissez les valeurs suivantes :
Name:
FireDetect1
Condition Type: Numeric
Test Frequency: On Data Insertion
Condition:
If Channel
FireAlarm
field 1 (Temp)
is greater than
40
Action:
ThingTweet
then tweet:
Fire Alarm on the #NanoESP! Temp: %%trigger%%C #ThingSpeak #IoT
Using Twitter Account
[Twitter Account]
Options:
Run action only the first time the condition is met
Avec Save Reactvous enregistrez les paramètres. Ainsi la première étape de la
surveillance est exécutée. Si la valeur est dépassée ThingSpeak envoie un message Twitter par votre compte. Pour la deuxième étape, l’insertion de la commande alarme, vous devez encore piocher un peu plus au fond dans la boîte à astuces
car cette fonction n’est pas prise en compte automatiquement. Mais ce qui est pris
en compte c’est ThingHTTP. Donc cliquez sur Apps et ensuite sur ThingHTTP. Là
créez un nouvel élément et saisissez ce qui suit :
Name:
Alarm
URL :
https://api.thingspeak.com/talkbacks/[YOUR
TALKBACK ID]/commands
Method:
POST
HTTP Version: 1.1
Host:
api.thingspeak.com
Headers:
Body:
api_key=[YOUR TALKBACK ID]Key command_string=Alarm&position=1
Assurez-vous de remplacer [YOUR TALKBACK ID] et [YOUR TALKBACK KEY]
dans l’URL et le Body-Part par votre TalkBack ID et votre KEY . Maintenant vous
pouvez créer un autre élément Reactqui comporte les mêmes paramètres que le
premier avec seulement la modification que vous avez sélectionnée par Action
ThingHTTP et là le point Alarm . Vous avez ainsi garanti qu’une alarme se déclenche si la valeur critique est dépassée.
Vous pouvez d’ailleurs laisser sonner l’alarme temporisée. Pour cela vous devez
cliquer sous Apps sur TimeControl et créer un nouvel élément, avec p. ex. le nom
AlarmClock. Là procédez aux paramétrages suivants :
Name:
Presents
Frequency:
One Time
Time Zone:
Berlin
Run At:
2015-24-12 7:00 am
Fuzzy Time:
± 0 minutes
TalkBack:
Alarms, add command: Alarm
Les paramètres TalkBack corrects pour l’alarme incendie
Pour un premier test il est recommandé de choisir un temps de quelques minutes.
Lorsque cela a fonctionné, on peut régler le temps correct. Ce n’est certainement
pas le meilleur son pour être réveillé mais c’est certainement plus efficace.
ANNEXE
Commandes AT
Instruction
Orthographe
fondamentale
Instruction de test
AT
Reset
AT+RST
Infos firmware
AT+GMR
Echo marche/arrêt
ATE<1/0>
Instructions WLAN
Mode WLAN
(1 = Client, 2 = AP, 3 = Dual)
AT+CWMODE=<mode>
Chercher le réseau WLAN
AT+CWLAP
Connecter WLAN
AT+CWJAP=«<ssid>«,«<pass
>«
Séparer WLAN
AT+CWQAP
Réglages point d’accèst WLAN
AT+CWSAP=«<ssid>«,«<pas
s>«[,<chan>,<enc>]
Donner adresse IP
AT+CIFSR
Activer/désactiver DHCP
AT+CWDHCP=<1/0>
Connecter automatiquement au
WLAN
AT+CWAUTOCONN=<1/0>
Modifier l’adresse Mac du poste
AT+CIPSTAMAC=<MAC>
Paramétrer l’adresse IP (poste)
AT+CIPSTA=<IP>
Paramétrer l’adresse IP (point
d’accès)
AT+CIPAP=<IP>
Démarrage SmartConfig
AT+CWSTARTSMART=<typ>
Arrêt SmartConfig
AT+CWSTOPSMART
Communication
Fonction ping
AT+PING=<HOST>
Autoriser plusieurs connexions
AT+CIPMUX=<mode>
Mode données
(0=Transparent, 1=mode données)
AT+CIPMODE=<mode>
Structure données reçues
+IPD,<id>,<len>:<data>
Connecter
AT+CIPSTART=«<type>«,«<a
ddress>«,<port>
Envoyer des données
AT+CIPSEND=<id>,<len>
Déconnecter
AT+CIPCLOSE=<id>
Instructions serveur
Démarrer le serveur
AT+CIPSERVER=1,<port>
Arrêter le serveur
AT+CIPSERVER=0
Statut du serveur et des clients connectés
AT+CIPSTATUS
Définir le Server-Timeout
AT+CIPSTO=<timeout>
Afficher les clients connectés
Pinout
AT+CWLIF