Serveur d'impression

Bouclier Wifi V2.0 – Seeed Wiki – Serveur d’impression

Le 13 juin 2019 - 45 minutes de lecture

modifier

Ce blindage WiFi comprend le module RN171 TCP / IP pour permettre à votre Arduino / Seeeduino de se connecter à des réseaux sans fil jusqu’à 802.11b / g.

Le protocole de communication par défaut du blindage avec l'Arduino est UART / Serial. Vous pouvez sélectionner les broches numériques (D0 à D7) à utiliser pour la réception et la transmission avec deux rangées de cavaliers que nous avons incorporées. Le blindage comporte également deux connecteurs Grove intégrés pour I2C et Serial, ce qui permet de l'utiliser avec tous nos périphériques Grove.

Une antenne embarquée permet au bouclier de couvrir une plage plus étendue et de transmettre des signaux plus puissants. Le module RN171 prend en charge les protocoles de communication TCP, UDP, FTP et HTTP afin de répondre aux besoins de la plupart des projets de réseaux sans fil et Internet des objets (IdO), par exemple. réseaux domestiques intelligents, commande de robots, stations météorologiques personnelles.

Le bouclier est très bien documenté avec nos exemples ci-dessous et son manuel d'utilisation.

Suivi de version

Paramètre Bouclier Wifi V1.0 Bouclier Wifi V1.1 (v1.2) Bouclier Wifi V2.0
Tension + 3.5V ~ + 5V + 3.5V ~ + 5V + 3.5V ~ + 5V
Bouclier standard Oui Oui Oui
Mode de communication Port série Port série Port série
Bouclier standard Non Oui Oui
Type d'antenne antenne de mât Antenne PCB antenne embarquée
Fichier de bibliothèque Bibliothèque de bouclier Wifi V1.0 Nouvelle bibliothèque de bouclier wifi Nouvelle bibliothèque de bouclier wifi le même que v1.2

Caractéristiques

Paramètre Valeur
Tension de fonctionnement 3,3 ~ 5,5 V
Conseil compatible directement Arduino Uno / Seeeduino
Actuel 25 ~ 400mA
Puissance de transmission 0-10 dBm
La fréquence 2402 ~ 2480 MHz
Canal 0 ~ 13
Débit du réseau 1-11 Mbps pour 802.11b / 6-54Mbps pour 802.11g
Dimension 60X56X19 mm
Poids net 24 ± 1 g
Authentification WiFi sécurisée WEP-128, WPA-PSK (TKIP), WPA2-PSK (AES)
Applications réseau intégrées Client DHCP, client DNS, ARP, ping ICMP, FTP, TELNET, HTTP, UDP, TCP
La certification RN171: FCC, CE

Compatibilité

Nous avons produit de nombreuses cartes d'extension qui peuvent rendre votre carte de plate-forme plus puissante. Cependant, toutes les cartes d'extension ne sont pas compatibles avec toutes les cartes de plate-forme. Nous utilisons ici un tableau pour illustrer la compatibilité de ces cartes avec la plate-forme.

Remarque

Veuillez noter que "Non recommandé" signifie qu'il peut avoir la chance de travailler avec la carte de la plate-forme, mais nécessite un travail supplémentaire, tel que des câbles de jonction ou la réécriture du code. Si vous souhaitez en savoir plus, n'hésitez pas à contacter [email protected]

Cliquez pour voir l'image complète

Vue d'ensemble du matériel

Le blindage WiFi est compatible avec toutes les cartes de développement Arduino / Seeeduino, car il ne nécessite que deux broches numériques de votre choix, entre D0 et D7, pour la communication UART / série. Pour l'installer, empilez simplement le bouclier sur la carte Arduino / Seeeduino.

  1. Connexions d'interface périphérique série (SPI) (MOSI, SCK, MISO): Ces broches ne sont connectées à aucune des broches de l'Arduino, elles sont indépendantes et leur entrée / sortie de niveau logique est de 3,3V. Ils peuvent être utilisés pour communiquer avec l'Arduino via SPI mais un convertisseur logique 3.3V entre ces broches et celles de l'Arduino sera nécessaire. Le débit de données en mode SPI peut atteindre 2 Mbps.

    RES_Wifi: Le bouclier Wifi possède un "bouton de repos" intégré pour le module RN-171. Vous pouvez également réinitialiser le RN-171 via un logiciel en envoyant la commande de réinitialisation. De plus, si vous souhaitez connecter cette broche à la broche numérique à 6 broches de l’Arduino, soudez simplement le plot portant la mention "P5" sur le blindage.

  2. RN171: Un module sans fil à très faible consommation d’énergie avec pile TCP / IP intégrée.

  3. Antenne: Connecteur I.PEX.
  4. RN171 section d'évasion: Le module RN171 possède sa propre entrée analogique et ses broches GPIO, auxquelles le blindage donne accès via cette section épanouie. Les broches GPIO (IO3, IO7, IO8 et IO9) sont tolérantes à 3,3 V, tandis que les broches d'entrée analogique (S_0 et S_1) peuvent lire 0-400 mV (ne pas dépasser 1,2 V). Le RN171 peut être configuré pour utiliser ces broches à l'aide d'un logiciel ou peut être connecté à d'autres broches pour utiliser d'autres fonctions RN171 telles que le mode ad hoc. La tension de VCC dépend de la puissance d'alimentation du blindage WiFi.
  5. Zone de sélection UART / Serial: Deux rangées de cavaliers vous permettent de sélectionner les broches RX et TX que vous souhaitez utiliser pour communiquer avec l’Arduino.
  6. Connecteurs Grove: Analog I2C Grove (si vous utilisez Arduino UNO ou Seeeduino) pour les broches A4 et A5 et Digital Serial Grove pour D8 et D9. La tension VCC dépend de l’alimentation de la carte.

Compatibilité des broches utilisées / du bouclier

Le blindage WiFi utilise deux broches numériques de votre choix, entre D0 et D7, pour communiquer avec le module WiFi RN171. Cependant, gardez à l’esprit que D0 et D1 sont utilisés par Arduino à des fins de programmation et de communication série et que leur utilisation pourrait interférer avec ces deux les fonctions.

Dans les exemples de codes de cette page, nous utilisons D2 et D3 comme réception et émission pour le bouclier. Dans ce cas, les casquettes doivent être connectées comme indiqué ci-dessous:


D2 sélectionné pour WIFI_TX, D3 sélectionné pour WIFI_RX

Module WiFi RN171

Le RN-171 est un module de réseau sans fil TCP / IP complet et autonome. En raison de son faible encombrement et de sa consommation électrique extrêmement faible, le RN-171 est idéal pour les applications sans fil mobiles. Il intègre une radio 2,4 GHz, un processeur SPARC 32 bits, une pile TCP / IP, une horloge en temps réel, un accélérateur de cryptage, une gestion de l'alimentation et des interfaces de capteurs analogiques.

Dans la configuration la plus simple, le matériel nécessite seulement quatre connexions (PWR, TX, RX et GND) pour créer une connexion de données WiFi sans fil. De plus, les entrées de capteur analogiques du RN171 peuvent être utilisées en tant que broches d'entrée analogique. Leur calibre est compris entre 0 et 400 mV (ne pas dépasser 1,2 V CC).

Puissance: La tension de fonctionnement du module RN-171 est généralement de 3,3 VCC. Un régulateur de tension et un convertisseur de niveau logique sont donc conçus sur le blindage WiFi. Le régulateur LD1117 sur le blindage est converti en 3,3 VCC, ce qui alimente le module RN171. Toutefois, en raison du schéma d’appréciation de l’alimentation, le RN-171 peut être alimenté via les broches 3V3 et 5V. Mais l’alimentation serait de 5v si les versions 3.3v et 5v étaient fournies au tableau. Si vous utilisez une carte Arduino / Seeeduino, empilez simplement le bouclier WiFi sur la carte.


Diagramme de la façon dont le module RN171 est interfacé avec l'Arduino

GPIO_6: La broche GPIO6 du module WiFi RN171 est par défaut uniquement connectée à la diode D5 sur le blindage WiFi. Ce voyant permet d’afficher l’état de la connexion du point d’accès. Si toutefois vous souhaitez connecter GPIO6 à la broche numérique 5 de l’Arduino, soudez simplement le plot portant la mention "P6" sur le blindage WiFi.

Voyants d'état

D5 LED verte. Indique le statut de l'association. DE: signifie que le module n'est pas associé à un réseau.
Allumé en continu: indique qu'il est associé et que l'accès Internet est correct
Connecté à GPIO6 du module RN171
D1 LED rouge Indique l'état de la connexion TCP / IP. Allumé en continu: connecté via TCP.

Basculement rapide (2 fois / seconde): Aucune adresse IP ou module n'est en mode commande.

Basculement lent (une fois / seconde): L'adresse IP est OK.

Connecté à GPIO4 du module RN171
RST LED rouge Etat de réinitialisation du module WiFi. Allumé en continu: Le bouton de réinitialisation (WIFI_RST) a été enfoncé. Connecté à la réinitialisation du module RN171.
PWR LED verte. Indique l'état de mise sous tension du module WiFi. Allumé en continu:Le module / blindage est sous tension. Connecté à la sortie 3,3 V du régulateur de tension LD1117.

Bibliothèque WiFi

Nous avons créé une bibliothèque pour vous aider à vous connecter au bouclier. Dans cette section, nous allons vous montrer comment configurer la bibliothèque et présenter certaines des fonctions.

Installer

  1. Téléchargez le code de la bibliothèque sous forme de fichier zip à partir de la page Wifi Shield github.
  2. Décompressez le fichier téléchargé dans votre dossier… / arduino / libraries /.
  3. Renommez le dossier décompressé "WifiShield"
  4. Démarrez l'IDE Arduino (ou redémarrez s'il est ouvert).

Les fonctions

C’est la fonction la plus importante / utile de la bibliothèque, nous vous invitons à consulter vous-même les fichiers .h pour voir toutes les fonctions disponibles.

joindre()

  • La description:
    • Utilisé pour rejoindre un point d'accès WiFi
  • Syntaxe:
    • join (const char * ssid, const char * phrase, int auth)
  • Paramètres:
    • ssid: Le nom du point d'accès auquel le bouclier doit se connecter
    • phrase: Le mot de passe / la phrase du point d'accès auquel vous voulez que le bouclier se connecte
    • auth: Le type d'authentification du point d'accès auquel le bouclier doit se connecter. Peut être l'une des constantes suivantes:
      • WIFLY_AUTH_OPEN
      • WIFLY_AUTH_WEP
      • WIFLY_AUTH_WPA1
      • WIFLY_AUTH_WPA1_2
      • WIFLY_AUTH_WPA2_PSK
      • WIFLY_AUTH_ADHOC
  • Résultats:
    • booléen: true si la connexion au point d'accès a réussi, false sinon.
  • Exemple:
    1
 2
 3
 4
 5
 6
 7
 8
 9
dix
11
12
13
14
15
16
17
18
19
20
21
22
#comprendre 
#comprendre "WiFly.h"

LogicielSerial uart(2, 3) // crée une connexion série aux broches TX et RX du blindage WiFi.
WiFly vif(Etuart) // crée un objet de bibliothèque WiFly à l'aide de la connexion série au bouclier WiFi créé ci-dessus.

vide installer()

    uart.commencer(9600) // commence la connexion série au bouclier
    En série.commencer(9600) // démarre la connexion de la fenêtre du moniteur série Arduino
    vif.réinitialiser(); // réinitialiser le bouclier
    tandis que(vif.joindre("mySSID","mySSIDpassword",WIFLY_AUTH_WPA2_PSK) == faux)
    
        En série.imprimer("Échec de la connexion au point d'accès. Je vais essayer à nouveau.")
    
    En série.imprimer("Connecté au point d'accès!")


vide boucle()



Pointe

Les exemples sont basés sur Arduino UNO et nous prenons D2 / D3 comme les broches SoftwareSerial. Si vous utilisez un Arduino Mega, le D2 n'est plus disponible. Plus de détails s'il vous plaît se référer à Arduino Software Serial
Voici un exemple.

En ce qui concerne le code, vous devez également apporter des modifications:

LogicielSerial uart(dix, 3) // crée une connexion série aux broches TX et RX du blindage WiFi.

recevoir()

  • La description:
    • Peut être utilisé pour lire les données du bouclier, une alternative à la fonction read () de l’Arduino.
  • Syntaxe:
    • recevoir (uint8_t * buf, int len, int timeout)
  • Paramètres:
    • buf: Un tableau tampon où les octets lus à partir du bouclier sont stockés.
    • len: La longueur / taille du tableau tampon
    • temps libre: Une valeur de délai d'attente pour savoir quand arrêter d'essayer de lire.
  • Résultats:
    • int: Le nombre d'octets lus à partir du bouclier.
  • Exemple:
carboniser c;
tandis que (vif.recevoir((uint8_t *)Etc, 1, 300) > 0) 
    En série.impression((carboniser)c)

Voir Fichier-> Exemples-> WiFi_Shield-> Esquisse wifly_test pour un exemple complet.

sendCommand ()

  • La description:
    • Certaines de nos fonctions (par exemple join (), reboot (), save ()) agissent comme des wrappers pour les commandes de texte répertoriées dans le manuel d'utilisation du module RN171. La fonction sendCommand () vous permet de créer votre propre fonction d’emballage si la nôtre ne répond pas à vos besoins.
  • Syntaxe:
    • sendCommand (const char * cmd, const char * ack, int timeout)
  • Paramètres:
    • cmd: Toute commande du manuel d'utilisation du RN-171.
    • ack: La chaîne de retour attendue à partir de la commande
    • temps libre: Le temps alloué avant de considérer la sortie comme une requête / réponse incorrecte
  • Résultats:

    • booléen: true si le bouclier WiFi répond avec la chaîne d'ack, false sinon.
  • Exemple:

    // notre fonction join () est un wrapper pour la commande join, comme vu ci-dessous.
    // La chaîne "Associé" correspond à ce que le manuel d'utilisation dit que le RN171 retournera en cas de succès.
    si(sendCommand("joindre r", "Associés",DEFAULT_WAIT_RESPONSE_TIME*dix))
    
        // rejoint
    autre
        // impossible de rejoindre
    
    

Voir Fichier-> Exemples-> WiFi_Shield-> Esquisse wifly_test pour un exemple complet.

Exemples de bouclier WiFi / Applications

Exemple 1: Envoi de commandes à WiFi Shield et réception de la réponse via la fenêtre du moniteur série Arduino

Le module RN-171 du blindage WiFi est configuré en lui envoyant les commandes figurant dans sa fiche technique. Vous pouvez écrire un croquis pour envoyer les commandes automatiquement, mais c’est un excellent exemple que nous vous recommandons de parcourir car il vous expliquera exactement le fonctionnement du bouclier WiFi et du RN-171.

Pour continuer, suivez les étapes ci-dessous, nous avons également créé une vidéo si vous préférez le regarder

Vidéo – Prise en main du WiFi Shield de Seeeduino.

Étape 1: Configuration des cavaliers WiFi Shield

Placez les cavaliers dans le blindage WiFi de manière à ce que la broche numérique 2 (D2) soit sélectionnée pour WIFI_TX et que la broche numérique 3 (D3) soit sélectionnée pour WIFI_RX, comme indiqué sur la photo ci-dessous. Ce sont les broches que nous utiliserons pour envoyer et recevoir des informations du RN-171.

Broches D2 pour TX et D3 pour RX

Étape 2: logiciel / code

Dans l'esquisse ci-dessous, nous avons créé un objet UART pour nous permettre d'envoyer et de recevoir des données à partir du RN-171 / WiFi Shield. Nous utilisons ensuite cet objet avec la bibliothèque WiFly pour envoyer des données au bouclier. L'objet Série de l'Arduino est utilisé pour imprimer les données que nous recevons du bouclier et pour recevoir les commandes que nous voulons envoyer au bouclier via l'objet WiFly / UART.

Téléchargez le code suivant sur votre carte Arduino:

    1
 2
 3
 4
 5
 6
 7
 8
 9
dix
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#comprendre 
#comprendre 
#comprendre "WiFly.h"

// configure un nouveau port série.
LogicielSerial uart(2, 3) // crée une connexion série aux broches TX et RX du blindage WiFi.
WiFly vif(Etuart) // crée un objet de bibliothèque WiFly à l'aide de la connexion série au bouclier WiFi créé ci-dessus.

vide installer()

    uart.commencer(9600) // commence la connexion série au bouclier
    En série.commencer(9600) // démarre la connexion de la fenêtre du moniteur série Arduino
    retard(3000) // attend 3 secondes pour permettre à l'objet série / uart de démarrer


vide boucle()

    tandis que (vif.disponible())  // s'il y a des données disponibles du bouclier
    
        En série.écrire(vif.lis()); // affiche les données dans la fenêtre du moniteur série.
    
    tandis que (En série.disponible()) // si nous avons tapé une commande
    
        vif.écrire(En série.lis()); // envoie la commande au bouclier WiFi.
    

Étape 3: Entrée en mode de commande

Le module WiFly RN-171 dans le blindage WiFi peut fonctionner selon deux modes: données et commande. En mode données, le bouclier peut recevoir et établir des connexions. En mode commande, nous pouvons configurer le module à l'aide des commandes répertoriées dans sa fiche technique.

Pour entrer en mode commande, procédez comme suit:

  1. Ouvrez le moniteur Arduino Serial.
  2. Réglez le moniteur série sur «Pas de fin de ligne» et le débit en bauds sur 9600.
  3. Tapez "$$$" dans le moniteur série Arduino et appuyez sur Entrée.
  4. Le module répondra par les lettres «CMD», indiquant qu'il est entré en mode commande.

Continuons et testons quelques commandes, procédez comme suit:

  1. Dans la fenêtre du moniteur série Arduino, sélectionnez «Retour de chariot» et une vitesse de transmission de 9600 bauds.
  2. Tapez maintenant chacune des commandes du tableau ci-dessous dans le moniteur série Arduino et appuyez sur Entrée.
  3. Le module émettra une réponse, comme décrit dans le tableau, pour chaque commande.
Les commandes La description
balayage Cette commande effectue une analyse active des points d’accès sur les 13 canaux. Lorsque vous utilisez cette commande, le module renvoie l'adresse MAC, la force du signal, le nom SSID et le mode de sécurité des points d'accès trouvés.
obtenir ip Cette commande affiche les paramètres d'adresse IP et de numéro de port.

Pour une liste complète des commandes de configuration, veuillez consulter le Guide de référence RN-171 à partir de la page 11.

Exemple 2: connexion à un point d'accès / routeur Internet

Dans cet exemple, nous allons vous montrer comment connecter le blindage WiFi à un point d'accès (votre routeur Internet) avec et sans saisie des commandes requises:

Se connecter en tapant des commandes

Cette section vous apprendra comment connecter le blindage WiFi à un point d'accès à l'aide des commandes de la fiche technique RN-171. En parcourant cette section, vous saurez alors exactement ce qui se passe en arrière-plan lorsque vous utilisez nos bibliothèques WiFi Arduino.

Faites ce qui suit:

  1. Téléchargez le code de l'exemple un sur votre carte Arduino
  2. Entrer en mode commande:

    1. Réglez le moniteur série sur «Pas de fin de ligne» et le débit en bauds sur 9600.
    2. Type $$$ dans le moniteur série Arduino et appuyez sur Entrée.
  3. Réglez le moniteur série sur «Retour chariot».

  4. Rechercher les points d’accès disponibles:

    1. Type balayage et appuyez sur Entrée. La fenêtre du moniteur série Arduino générera une liste de valeurs séparées par des virgules pour chaque point d'accès détecté par le bouclier WiFi. De gauche à droite, la troisième valeur est le mode de sécurité, la dernière valeur est le SSID. Cet exemple montre un mode de sécurité de 4 avec un nom SSID MySSID: 01,01, -88,041104,1c, 00,45: 56: 78🇧🇪93: 1f,MySSID
  5. Dans la liste des points d’accès trouvés, trouvez celui qui correspond à votre routeur Internet et notez le mode de sécurité, ainsi que le SSID, car nous aurons besoin de ces deux valeurs pour pouvoir vous y connecter.

  6. Définissez le mode de sécurité dans le bouclier:

    1. Type set wlan auth m. Remplacer m avec le numéro de mode de sécurité (dans cet exemple, 4) du point d'accès auquel vous souhaitez vous connecter.
    2. Les modes de sécurité pris en charge par le bouclier WiFi sont répertoriés dans la Figure 1 ci-dessous.
  7. Définir la phrase du point d'accès

    1. Type définir la phrase wlan myPhrase. Remplacer myPhrase avec le mot de passe / clé de sécurité de votre point d'accès.

      Remarque

      Si le type de sécurité de votre point d'accès est WEP clé au lieu de phrase dans la commande ci-dessus.

    2. La phrase du point d'accès (routeur Internet) est le mot de passe que vous utilisez pour vous y connecter à partir de votre PC. Sous Windows, vous pouvez le trouver comme indiqué dans l'image animée ci-dessous:

      Comment trouver la clé de sécurité / mot de passe d'un réseau

  8. Rejoindre le point d'accès

    1. Maintenant que nous avons défini le type de sécurité et la phrase du point d’accès, nous pouvons nous y connecter.
    2. Type rejoindre MySSID. Remplacez MySSID par le nom de diffusion de votre point d'accès.
    3. Le mot "associé!" sera affiché dans la fenêtre du moniteur série Arduino en cas de succès.

Une description des commandes que vous avez entrées dans les étapes ci-dessus est disponible dans le tableau ci-dessous. Une description plus détaillée de chaque commande se trouve dans le manuel d'utilisation du RN171.

Nombre Les commandes La description
1 balayage Cette commande effectue une analyse active des points d’accès sur les 13 canaux. Lorsque vous utilisez cette commande, le module renvoie l'adresse MAC, la force du signal, le nom SSID et le mode de sécurité des points d'accès trouvés.
2 set wlan auth 4 Recherchez la valeur qui correspond au protocole de sécurité sur votre point d'accès. Ensuite, indiquez à WiFly le protocole de sécurité à utiliser, il s’agit du numéro indiqué dans Figure 1 cela correspond au protocole de sécurité du point d'accès. Ici nous choisissons “4”.
3 définir la phrase wlan seeed-mkt Dites le mot de passe au bouclier WiFi.
4 rejoindre SEEED-MKT Dites au bouclier WiFi de se joindre, "SEEED-MKT" est le nom du point d'accès que nous avons choisi de connecter. Après l'envoi de la commande, le module doit maintenant se connecter et imprimer des informations sur la connexion. (Si la connexion échoue, essayez de renvoyer la commande jusqu'à ce que cela fonctionne.)
Valeur Mode d'authentification
0 Ouvrir (par défaut)
1 WEP-128
2 WPA1
3 Mixte WPA1 et WPA2-PSK
4 WPA2-PSK
5 Non utilisé
6 Mode AD hoc (rejoindre n'importe quel réseau ad hoc)
8 WPE-64

Figure 1

Se connecter en utilisant nos bibliothèques WiFi

Maintenant que vous savez vous connecter à un point d'accès en tapant chaque commande, il est temps d'utiliser les bibliothèques et les exemples fournis.

Pour voir le code requis pour se connecter à un point d'accès, allez à «Fichier -> Exemples -> Wifi_Shield -> wifi_test». Changez le code pour utiliser votre propre SSID (nom du point d'accès) et KEY (mot de passe de votre point d'accès), puis chargez l'esquisse sur votre IDE Arduino.

#define SSID "SEEED-MKT"
#define KEY "seeed-mkt"

Une fois l’esquisse chargée sur votre carte Arduino, ouvrez la fenêtre du moniteur série. Si le bouclier a réussi à rejoindre le point d'accès, un message "OK" sera affiché avec les informations de connexion résultant de la commande "tout obtenir". Si le bouclier n'a pas réussi à rejoindre le point d'accès, un message "Echec" sera affiché.

Configuration du bouclier pour se connecter au démarrage

Le bouclier peut être configuré pour se connecter à la mise sous tension, il suffit de le faire une fois:

  1. Envoyez la commande "set wlan ssid mySSID" en remplaçant mySSID par votre SSID
  2. Envoyez la commande "set wlan join 1".
  3. Envoyez la commande "enregistrer".

Maintenant, le bouclier se connectera automatiquement au point d'accès lors de la mise sous tension.

Vous trouverez une description de chaque commande dans la fiche technique RN-171 et dans le tableau ci-dessous.

Nombre Les commandes La description
1 mettre wlan ssid ""est le nom du point d'accès auquel vous souhaitez vous connecter automatiquement
2 définir wlan rejoindre 1 Cela indique au module d'essayer de se connecter au SSID enregistré en mémoire automatiquement.
3 enregistrer Stocker / sauvegarder ces paramètres dans le fichier de configuration du Wifi

Définition d'une adresse IP statique

Pour que le bouclier obtienne une adresse IP statique du point d'accès, une fois connecté au point d'accès, envoyez les commandes suivantes:

Nombre Les commandes La description
1 set ip dhcp 0 Tour de DHCP.
2 set ip address

Définissez l'adresse IP de votre choix.

Exemple 3: communication avec le réseau ()

Cet exemple vous montrera comment un appareil tel que votre PC et / ou votre téléphone peut communiquer avec le bouclier WiFi.

Suivez ces étapes:

  1. Configurez le module avec step1-7 dans la section Exemple 2 Se connecter en tapant des commandes
  2. Définissez le port IP d'écoute sur "80" en envoyant les commandes "set ip local 80"
  3. Connectez / connectez votre bouclier à un point d'accès, comme indiqué à l'étape 8 de la section Exemple 2. Se connecter en tapant des commandes
  4. Enregistrez ces paramètres en envoyant la commande "save"
  5. Obtenez l'adresse IP de votre bouclier avec la commande "get ip". L'adresse IP et le port seront affichés à la droite de "IP =" dans la réponse (par exemple, IP = 192.168.0.10: 80).
  6. Ouvrez votre navigateur Web et tapez l’adresse IP de votre bouclier dans la barre d’URL de votre navigateur Web, puis appuyez sur Entrée pour le visiter.
  7. La fenêtre du moniteur série de votre Arduino affiche une réponse HTTP similaire à celle ci-dessous. Ce sont les informations que votre navigateur a envoyées au bouclier pour demander des données.
*OUVRIR*OBTENIR / HTTP/1.1
Hôte: 192.168.0.dix
Lien: rester en vie
Acceptez: texte/html,application/xhtml+xml,application/xml;q=0.9,image/webp, * / *;q=0.8
Agent utilisateur: Mozilla/5.0 (les fenêtres NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, comme Gecko) Chrome/39.0.2171.95 Safari/537.36
Accepter l'encodage: gzip, dégonfler, sdch
Accepter la langue: en-US,en;q=0.8

Le navigateur attend maintenant des données, le module Wifi peut envoyer des valeurs de capteur, servir des pages Web ou toute autre donnée directement au navigateur! Dans ce cas, le navigateur attend une page Web. Si le module Wifi répond avec une page au format HTML, le navigateur l'affichera. Les exemples suivants vous apprendront comment faire tout ce travail amusant.

Exemple 4: utilisation du bouclier WiFi en tant que serveur Web (Servir des pages Web à partir du bouclier)

Comme vous l'avez vu dans l'exemple 3, un navigateur Internet / Web peut se connecter au bouclier WiFi. Une fois la connexion établie (lorsque le navigateur envoie sa requête HTTP), le bouclier WiFi peut ensuite renvoyer le code HTML que le navigateur affichera sous forme de page Web. Dans cet exemple, vous apprendrez ce dont le bouclier a besoin pour répondre à un navigateur Web.

Première étape: code Arduino

Téléchargez le code suivant sur votre carte Arduino en remplaçant "myssid" et "mypassword" par les valeurs de votre point d'accès, respectivement:

    1
 2
 3
 4
 5
 6
 7
 8
 9
dix
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
#comprendre 
#comprendre "WiFly.h"

#define SSID "myssid"
#define KEY "mypassword"
// vérifie le mode de sécurité de ton point d'accès, le mien était WPA20-PSK
// si le vôtre est différent, vous devrez changer la constante AUTH, voir le fichier WiFly.h pour les codes de sécurité disponibles
#define AUTH WIFLY_AUTH_WPA2_PSK

int drapeau = 0;

// connexion des pins
// Arduino WiFly
// 2    <---->    TX
// 3    <---->    RX

LogicielSerial wiflyUart(2, 3) // crée un objet série bouclier WiFi
WiFly vif(EtwiflyUart) // passe l'objet série wifi siheld à la classe WiFly

vide installer()

    wiflyUart.commencer(9600) // commence le port wifi bouclier uart
    En série.commencer(9600) // démarre le port série arduino
    En série.imprimer("--------- Serveur Web WIFLY --------")

    // attend l'initiation de wifly
    retard(1000)

    vif.réinitialiser(); // réinitialiser le bouclier
    retard(1000)
    // définir les paramètres WiFly

    vif.sendCommand("set ip local 80 r") // définit le port de communication local sur 80
    retard(100)

    vif.sendCommand("set comm remote 0 r") // n'envoie pas de chaîne par défaut à l'ouverture d'une connexion
    retard(100)

    vif.sendCommand("set comm open * OPEN * r") // définit la chaîne que le bouclier wifi produira quand une connexion sera ouverte
    retard(100)

    En série.imprimer("Rejoindre" SSID )
    si (vif.joindre(SSID, CLÉ, AUTH)) 
        En série.imprimer("D'ACCORD")
     autre 
        En série.imprimer("Échoué")
    

    retard(5000)

    vif.sendCommand("obtenir ip r")
    carboniser c;

    tandis que (vif.recevoir((uint8_t *)Etc, 1, 300) > 0)  // affiche la réponse à partir de la commande get ip
        En série.impression((carboniser)c)
    

    En série.imprimer("Serveur Web prêt")



vide boucle()


    si(vif.disponible())
     // le bouclier wifi a des données disponibles
        si(wiflyUart.trouver("*OUVRIR*")) // voir si les données disponibles proviennent d'une connexion ouverte en recherchant la chaîne * OPEN *
        
            En série.imprimer("Nouvelle requête de navigateur!")
            retard(1000) // retarde le navigateur à envoyer sa chaîne de requête HTTP
            // envoie l'en-tête HTTP
            wiflyUart.imprimer("HTTP / 1.1 200 OK")
            wiflyUart.imprimer("Content-Type: text / html; charset = UTF-8")
            wiflyUart.imprimer("Longueur du contenu: 244") // longueur du code HTML
            wiflyUart.imprimer("Connexion: proche")
            wiflyUart.imprimer();

            // envoie le code HTML de la page Web
            wiflyUart.impression("")
            wiflyUart.impression("")
            wiflyUart.impression("Ma page Web sur le bouclier WiFI")
            wiflyUart.impression("")
            wiflyUart.impression("")
            wiflyUart.impression("

Bonjour le monde!

"
) wiflyUart.impression("

Ce site est desservi par mon module WiFi

"
) wiflyUart.impression("<a href = "http://yahoo.com "> Yahoo! <a href = "http://google.com "> Google") wiflyUart.impression("
"
) wiflyUart.impression("") wiflyUart.impression("")

Deuxième étape: Obtenir l'adresse IP du bouclier

Ouvrez la fenêtre du moniteur série et attendez que le message "Serveur Web prêt" s'affiche. Le moniteur série affichera également l'adresse IP du bouclier WiFi:

Programme de communication série du programme Arduino. L'adresse IP du bouclier est en surbrillance.

Troisième étape: visiter la page Web

Maintenant, visitez cette adresse IP dans votre navigateur Web. La page Web ci-dessous devrait être affichée, elle contient un lien vers Yahoo! et Google et un bouton qui ne fait rien (encore):

Une simple page Web avec deux liens et un bouton servi depuis le bouclier WiFi.

Lorsque la page Web est visitée, la fenêtre du moniteur série affiche également une "Nouvelle requête de navigateur!" chaîne comme indiqué ci-dessous:

La fenêtre de communication série Arduino indiquant qu’elle a détecté une nouvelle connexion / demande du navigateur.

Remarque

Dans le cas de certains navigateurs, tels que Google Chrome, même la saisie de l'URL dans la barre envoie une demande de page Web, car ces navigateurs essaient d'obtenir le titre de la page Web pour plus de commodité, même avant que celui-ci ne la visite.

Exemple 5: Contrôle des broches numériques Arduino à partir d'une page Web (Basculement des voyants à partir d'une page Web)

Dans cet exemple, nous allons créer une page Web avec trois boutons pour contrôler trois broches numériques différentes dans l’Arduino.

Pour ce tutoriel, suivez les étapes ci-dessous. Nous avons également créé une vidéo dans laquelle nous expliquons le code plus en détail.

Vidéo – Contrôle des broches numériques Arduino WiFi Shield From Webpage

Étape 1: matériel

Connectez trois DEL et la résistance aux broches numériques 11, 12 et 13, comme indiqué dans le schéma ci-dessous:

Trois DEL et des résistances 1k connectées aux broches 11, 12 et 13.

Étape 2: Croquis Arduino

Téléchargez le code suivant sur votre carte Arduino mais remplacez "mySSID" et "myPassword" par le nom SSID et le mot de passe de votre point d'accès:

        1
  2
  3
  4
  5
  6
  7
  8
  9
 dix
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
#comprendre 
#comprendre "WiFly.h"

#define SSID "mySSID"
#define KEY "monPassword"
// vérifie le mode de sécurité de ton point d'accès, le mien était WPA20-PSK
// si le vôtre est différent, vous devrez changer la constante AUTH, voir le fichier WiFly.h pour les codes de sécurité disponibles
#define AUTH WIFLY_AUTH_WPA2_PSK

int drapeau = 0;

// connexion des pins
// Arduino WiFly
// 2    <---->    TX
// 3    <---->    RX

LogicielSerial wiflyUart(2, 3) // crée un objet série bouclier WiFi
WiFly vif(EtwiflyUart) // passe l'objet série wifi siheld à la classe WiFly
carboniser ip[[[[16];

vide installer()

    pinMode(11,SORTIE)
    digitalWrite(11,FAIBLE)

    pinMode(12,SORTIE)
    digitalWrite(12,FAIBLE)

    pinMode(13,SORTIE)
    digitalWrite(13,FAIBLE)

    wiflyUart.commencer(9600) // commence le port wifi bouclier uart

    En série.commencer(9600) // démarre le port série arduino
    En série.imprimer("--------- Serveur Web WIFLY --------")

    // attend l'initiation de wifly
    retard(1000)

    vif.réinitialiser(); // réinitialiser le bouclier
    retard(1000)
    // définir les paramètres WiFly

    vif.sendCommand("set ip local 80 r") // définit le port de communication local sur 80
    retard(100)

    vif.sendCommand("set comm remote 0 r") // n'envoie pas de chaîne par défaut à l'ouverture d'une connexion
    retard(100)

    vif.sendCommand("set comm open * OPEN * r") // définit la chaîne que le bouclier wifi produira quand une connexion sera ouverte
    retard(100)

    En série.imprimer("Rejoindre" SSID )
    si (vif.joindre(SSID, CLÉ, AUTH)) 
        En série.imprimer("D'ACCORD")
     autre 
        En série.imprimer("Échoué")
    

    retard(5000)

    vif.sendCommand("obtenir ip r")

    wiflyUart.setTimeout(500)
    si(!wiflyUart.trouver("IP ="))
    
        En série.imprimer("ne peut pas obtenir ip")
        tandis que(1) ;;
    autre
    
        En série.impression("IP:")
    

    carboniser c;
    int indice = 0;
    tandis que (vif.recevoir((uint8_t *)Etc, 1, 300) > 0)  // affiche la réponse à partir de la commande get ip
        si(c == ':')
        
            ip[[[[indice] = 0;
            Pause;
        
        ip[[[[indice++] = c;
        En série.impression((carboniser)c)
        ?
    
    En série.imprimer();
    tandis que (vif.recevoir((uint8_t *)Etc, 1, 300) > 0) ;;
    En série.imprimer("Serveur Web prêt")


vide boucle()
{
    si(vif.disponible())       // le bouclier wifi a des données disponibles
    {

        si(wiflyUart.trouver("*OUVRIR*")) // voir si les données disponibles proviennent d'une connexion ouverte en recherchant la chaîne * OPEN *
        {
            En série.imprimer("Nouvelle requête de navigateur!")
            retard(1000) // retarde le navigateur à envoyer sa chaîne de requête HTTP

            si(wiflyUart.trouver("pin =")) // cherche la chaîne "pin =" dans la requête http, si c'est le cas, alors nous voulons contrôler le voyant
            
                En série.imprimer("Contrôle LED")
                // l'utilisateur veut basculer les voyants
                int code PIN = (wiflyUart.lis()-48) // obtient le premier numéro, c'est-à-dire si la broche 13 est le premier numéro: 1
                int secondNumber = (wiflyUart.lis()-48)
                si(secondNumber> =0 && secondNumber<=9)
                
                    code PIN* =dix;
                    code PIN + =secondNumber; // obtenir le deuxième numéro, c'est-à-dire si le numéro d'identification personnelle est 13, le deuxième numéro est égal à 3, puis ajouter au premier numéro
                
                digitalWrite(code PIN, !numériqueLire(code PIN)); // broche à bascule
                // Construit la chaîne pinstate. L'Arduino répond au navigateur avec cette chaîne.
                Chaîne pinState = "Pin";
                pinState+ =code PIN;
                pinState+ =" est ";
                si(numériqueLire(code PIN)) // vérifie si la broche est activée ou désactivée
                
                    pinState+ ="SUR"; // l'épingle est sur
                
                autre
                
                    pinState+ ="DE";  // l'épingle est éteinte
                
                // construit l'en-tête HTTP Content-Length string.
                Chaîne contentLength="Longueur du contenu:";
                contentLength+ =pinState.longueur(); // la valeur de la longueur est la longueur de la chaîne avec laquelle Arduino répond au navigateur.
                // envoie l'en-tête HTTP
                wiflyUart.imprimer("HTTP / 1.1 200 OK")
                wiflyUart.imprimer("Content-Type: text / html; charset = UTF-8")
                wiflyUart.imprimer(contentLength) // longueur du code HTML
                wiflyUart.imprimer("Connexion: proche")
                wiflyUart.imprimer();
                // envoyer une réponse
                wiflyUart.impression(pinState)
            
            autre
            
                // envoie l'en-tête HTTP
                wiflyUart.imprimer("HTTP / 1.1 200 OK")
                wiflyUart.imprimer("Content-Type: text / html; charset = UTF-8")
                wiflyUart.imprimer("Longueur du contenu: 540") // longueur du code HTML
                wiflyUart.imprimer("Connexion: proche")
                wiflyUart.imprimer();

                // envoie le code HTML de la page Web
                wiflyUart.impression("")
                wiflyUart.impression("")
                wiflyUart.impression("Page Web du Bouclier WiFi")
                wiflyUart.impression("")
                wiflyUart.impression("")
                wiflyUart.impression("

LED bascule page Web

"
) // Dans le ") // bouton pour la broche 11 wiflyUart.impression("<id bouton = "12 " class="led">Toggle Pin 12 ") // button for pin 12 wiflyUart.impression("<button id="13" class="led">Toggle Pin 13 ") // button for pin 13 wiflyUart.impression("") wiflyUart.impression("") wiflyUart.impression("") wiflyUart.impression("") En série.println("Data sent to browser") } } }

Step 3: Serial Monitor Window

Open the serial monitor window and wait for the "Web server ready" message to display. The serial monitor will also display the WiFi shield's IP address:

Arduino program serial comm output. The IP address of the shield is highlighted.

Step 4: Visit The Webpage

Visit the IP address in a web browser. A webpage with three buttons, like the one below, should display. Click on the buttons to control the LEDs.

LED control webpage served from the WiFi shield.

The Arduino will also respond back to the web browser with the pin's state, the browser will display this in an alert window.

Alert dialog displaying the state of Pin12, The string Pin12 is ON was sent from the Arduino.

The serial monitor window will also show when a browser sends a request to either visit the webpage or control the LED pins.

Arduino serial comm output when an HTTP request is sent to the shield.

Example 6: WiFi Shield and Android App

The Android app you can use to control the Arduino's pins through the WiFi or Ethernet Shield.

Android Application

We've created an Android app that can toggle the digital pins in the Arduino through the WiFi shield, to see how the app works and learn about the code watch the video in this link:

Video – WiFi Shield Android App for Arduino Pin Control

Logiciel

Download the Android Studio project/source form this link:

Example 7: Sending Data To and Retrieving Data From an External Server

The RN-171 module in the WiFi shield has the ability to act as an HTML client (a text based web browser essentially), this means that we can use the shield to send and receive data from a web server. In this example you will learn to use the shield with a web Application Programming Interface (API) that displays any city's weather data (i.e. temperature, humidity, etc).

The name of the API we'll use is OpenWeatherMap, when you send the name of a city and country to this website it returns a JSON string with weather information. If you want to display the weather for London UK for example, please refer to the toturial in this link http://openweathermap.org/appid .Starting from 9 Oct 2015, the website requires users to sign up for a API key before visiting the API. Once you have got the API key, you will be able to visit the following URL http://api.openweathermap.org/data/2.5/weather?q=London,uk which would return a JSON string like the following, where the weather data and other information is embedded.

    1
 2
 3
 4
 5
 6
 7
 8
 9
dix
11
12
13
14
{
    "coord":"lon":-0.13,"lat":51.51,
    "sys":"type":3,"id":60992,"message":0.0079,"country":"GB","sunrise":1421395087,"sunset":1421425352,
    "weather":[{[{[["id":802,"main":"Clouds","description":"scattered clouds","icon":"03n"],
    "base":"cmc stations",
    "main":
        "temp":277.25,"humidity":79,"pressure":998.4,
        "temp_min":277.25,"temp_max":277.25
    ,
    "wind":
    "speed":2,"gust":5,"deg":180,
    "rain":"3h":0,"clouds":"all":32,
    "dt":1421372140,"id":2643743,"name":"London","cod":200

Step 1: The URL

Let us go ahead and retrieve the weather JSON string for San Francisco, US. The URL our WiFi shield needs to visit is the following (you may test it in your web browser):

http://api.openweathermap.org/data/2.5/weather?q=San%20Francisco,US

Step 2: The Arduino Code

Section 13 of the WiFly manual teaches you different ways to connect to a web server, but in all cases we need to specify the name of the server (or IP address if the server does not have a domain name), and then the data we wish to send.

The commands we need to send to the WiFi shield to receive the JSON string from the OpenWeatherMap server are the following:

set ip proto 18 //enable html client
set dns name api.openweathermap.org //name of your webserver
set ip address 0 // so WiFly will use DNS
set ip remote 80 // standard webserver port
set com remote 0 // turn off the REMOTE string so it does not interfere with the post
open // to open the connection
GET /data/2.5/weather?q=San%20Francisco,US nn // to send the data

This is the arduino code that will send the commands:

    1
 2
 3
 4
 5
 6
 7
 8
 9
dix
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
#comprendre 
#comprendre "WiFly.h"

#define SSID      "mySSID"
#define KEY       "myPassword"
// check your access point's security mode, mine was WPA20-PSK
// if yours is different you'll need to change the AUTH constant, see the file WiFly.h for avalable security codes
#define AUTH      WIFLY_AUTH_WPA2_PSK

// Pins' connection
// Arduino       WiFly
//  2    <---->    TX
//  3    <---->    RX

SoftwareSerial wiflyUart(2, 3) // create a WiFi shield serial object
WiFly wifly(EtwiflyUart) // pass the wifi siheld serial object to the WiFly class

vide installer()

    wiflyUart.commencer(9600) // start wifi shield uart port
    En série.commencer(9600) // start the arduino serial port
    En série.println("--------- OpenWeatherMap API --------")

    // wait for initilization of wifly
    retard(3000)
    wifly.réinitialiser(); // reset the shield
    En série.println("Join " SSID )
    si (wifly.joindre(SSID, CLÉ, AUTH)) 
        En série.println("D'ACCORD")
     autre 
        En série.println("Failed")
    

    retard(5000)

    wifly.sendCommand("set ip proto 18r") //enable html client
    retard(100)

    wifly.sendCommand("set dns name api.openweathermap.orgr") // name of the webserver we want to connect to
    retard(100)

    wifly.sendCommand("set ip address 0r") // so WiFly will use DNS
    retard(100)

    wifly.sendCommand("set ip remote 80r") /// standard webserver port
    retard(100)

    wifly.sendCommand("set com remote 0r") // turn off the REMOTE string so it does not interfere with the post
    retard(100)

    wifly.sendCommand("openr") // open connection
    retard(100)

    wiflyUart.impression("GET /data/2.5/weather?q=San%20Francisco,US nn")
    retard(1000)



vide boucle()

    //As soon as the data  received from the Internet ,output the data through the UART Port .
    tandis que (wifly.disponible())
    
        En série.écrire(wifly.lis());
    

Step 3: Result

Open the serial monitor window, you should be able to see the same JSON string you saw in the browser.

JSON weather string shown in the Arduino serial monitor window.

Example 8: TCP Communication With Terminal

In this example we'll show you how to send information from the WiFi shield to a PC terminal program. We'll make a simple Arduino console with menus that will give you the option to see the Arduino digital pin's state and toggle them.

Step 1: Download a TCP Terminal

Download and install RealTerm, a utility terminal that will allow us to connect to the WiFi shield.

Étape 2: Code Arduino

Upload the code below to your Arduino board replacing "mySSID", "myPassword", and authentication code with your own access point's information:

        1
  2
  3
  4
  5
  6
  7
  8
  9
 dix
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
#comprendre 
#comprendre "WiFly.h"

#define SSID      "mySSID"
#define KEY       "myPassword"
// check your access point's security mode, mine was WPA20-PSK
// if yours is different you'll need to change the AUTH constant, see the file WiFly.h for avalable security codes
#define AUTH      WIFLY_AUTH_WPA2_PSK

#define FLAG_MAIN_MENU 1
#define FLAG_SUB_MENU_2 2

int drapeau = FLAG_MAIN_MENU;

// Pins' connection
// Arduino       WiFly
//  2    <---->    TX
//  3    <---->    RX

SoftwareSerial wiflyUart(2, 3) // create a WiFi shield serial object
WiFly wifly(EtwiflyUart) // pass the wifi siheld serial object to the WiFly class

vide installer()


    // define the pins we can control
    pinMode(11,OUTPUT)
    digitalWrite(11,FAIBLE)

    pinMode(12,OUTPUT)
    digitalWrite(12,FAIBLE)

    pinMode(13,OUTPUT)
    digitalWrite(13,FAIBLE)

    pinMode(7,OUTPUT)
    digitalWrite(7,FAIBLE)

    wiflyUart.commencer(9600) // start wifi shield uart port

    En série.commencer(9600) // start the arduino serial port
    En série.println("--------- TCP Communication --------")

    // wait for initilization of wifly
    retard(1000)

    wifly.réinitialiser(); // reset the shield
    retard(1000)

    wifly.sendCommand("set ip local 80r") // set the local comm port to 80
    retard(100)

    wifly.sendCommand("set comm remote 0r") // do not send a default string when a connection opens
    retard(100)

    wifly.sendCommand("set comm open *r") // set the string or character that the wifi shield will output when a connection is opened "*"
    retard(100)

    wifly.sendCommand("set ip protocol 2r") // set TCP protocol
    retard(100)

    En série.println("Join " SSID )
    si (wifly.joindre(SSID, CLÉ, AUTH)) 
        En série.println("D'ACCORD")
     autre 
        En série.println("Failed")
    

    retard(5000)

    wifly.sendCommand("get ipr")
    carboniser c;

    tandis que (wifly.recevoir((uint8_t *)Etc, 1, 300) > 0)  // print the response from the get ip command
        En série.impression((carboniser)c)
    

    En série.println("TCP Ready")


vide boucle()


    si(wifly.disponible())
    
        retard(1000) // wait for all the characters to be sent to the WiFi shield
        carboniser val = wiflyUart.lis(); // read the first character

        si(drapeau == FLAG_MAIN_MENU)
        
            commutateur(val)
            
                Cas '*': // search for the new connection string
                printMainMenu();
                Pause;
                Cas '1': // the user typed 1, display the pin states
                printPinStates();
                printMainMenu();
                Pause;
                Cas '2': // the user typed 2, display the sub menu (option to select a particular pin)
                printSubMenu2();
                drapeau = FLAG_SUB_MENU_2; // flag to enter the sub menu
                Pause;
                défaut:
                wiflyUart.impression("INVALID SUBMENU r  n")
                Pause;
            
        
        autre si(drapeau == FLAG_SUB_MENU_2)
        
            int pinNumber = val-48; // get first number i.e. if the pin 13 then the 1st number is 1
            int secondNumber = (wiflyUart.lis()-48)
            si(secondNumber>=0 && secondNumber<=9)
            
                pinNumber*=dix;
                pinNumber + =secondNumber; // get second number, i.e. if the pin number is 13 then the 2nd number is 3, then add to the first number
            

            // Create the "You want to toggle pin x?? OK..." string.
            Chaîne réponse = " r  nYou want to toggle pin ";
            réponse+ =pinNumber;
            réponse+ ="? OK... r  n";

            wiflyUart.impression(réponse)

            digitalWrite(pinNumber, !digitalRead(pinNumber)); // toggle pin

            wiflyUart.impression("Pin Toggled! r  n") // let user know the pin was toggled.
            printMainMenu();
            drapeau = FLAG_MAIN_MENU;
        
    



/ *
* Prints the main menu options
* /
vide printMainMenu()

    wiflyUart.impression(" r  n  r  n")
    wiflyUart.impression("Arduino Console Menu:  r  n")
    wiflyUart.impression("1. Show digital pin states r  n")
    wiflyUart.impression("2. Toggle a digital pin's state r  n")
    wiflyUart.impression(" r  n  r  n")


// displays the pin states
vide printPinStates()


    Chaîne pinState = "Pin 7 is ";
    pinState+ =getPinState(7)
    pinState+ =" r  n";

    pinState + = "Pin 11 is ";
    pinState+ =getPinState(11)
    pinState+ =" r  n";

    pinState + = "Pin 12 is ";
    pinState+ =getPinState(12)
    pinState+ =" r  n";

    pinState + = "Pin 13 is ";
    pinState+ =getPinState(13)
    pinState+ =" r  n";

    wiflyUart.impression(pinState)


// prints the option to enter a pin number
vide printSubMenu2()

    wiflyUart.impression(" r  nEnter the pin number you wish to toggle: ")

?
// get a pin state as a string.
Chaîne getPinState(int pinNumber)

    si(digitalRead(pinNumber)) // check if the pin is ON or OFF
    
        revenir "ON"; // the pin is on
    
    autre
    
        revenir "OFF";  // the pin is off
    

Step 3: Obtain the Shield's IP Address and Port

Open the Arduino serial monitor window to obtain the WiFiShield's IP address and port number, highlighted in the image below.

Arduino serial monitor window output from TCP example, the ip address and port number are highlighted.

In the image above the IP Address and Port would be the following:

Step 4: Configure The TCP Terminal and Connect to The Shield

Open RealTerm and in the "Display" tab enter "30" for "Rows" and select the "Scrollback" option:

RealTerm window: rows = 30, and Scrollback option checked.

In the "Port" tab of the RealTerm program, type your shield's IP address and port e.g. 192.168.0.10:80, then click the "Open" button, the Arduino's hard coded main menu should display in the terminal.

RealTerm window. Port field has WiFi shield's IP address and port number. The Arduino's menu is displayed

In the "Send" tab select one of the options from the menu either "1" or "2", enter it in the text box and press "Send ASCII" to send the value.

For example, to toggle pin 13 enter "2" and press "Send ASCII", then when prompted "Enter the pin number you wish you toggle" enter "13" and click "Send ASCII". The Arduino should reply "Pin Toggled!" and go back to the main menu, now enter "1" and press "Send ASCII" to see the present state of the pins.

RealTerm window. The state of pin 13 was changed from OFF to ON as shown in the yellow text.

Example 9: WiFi Shield and Relay Shield

Now that you know how to send and receive information to and from the WiFi shield you can see how easy it would be to control any kind of device via the web.

If you wish to control high power devices such as your desk lamp, a motor, or a water pump via a webpage or phone application we recommend our Relay Shield V2.0.

The Relay Shield V2.0 uses pins 4, 5, 6, and 7 so it is fully compatible with the code in the examples in this page.

Example 10: Adhoc Mode

To use the shield in Adhoc mode, as an access point, simply connect pin IO9 from the shield to the 3.3V pin in the Arduino, as shown below, and reset the shield if it was on.

Shield connection required for adhoc mode. Pin IO9 of the shield connected to 3.3V.

To obtain the shield's SSID upload the code in Example 1 to your Arduino and open the serial monitor, the shield will respond with it's SSID as in the example below, where in this case WiFly-EZX-1b is the SSID.

AP mode as WiFly-EZX-1b on chan 1

You should now be able to connect to your WiFi shield as an access point, for example the SSID should be visible in your PC's list of WiFi networks available.

To learn more about adhoc mode check out the WiFly RN User Manual section 16 "Adhoc Networking Mode"

FAQ

Q1: How to set a configuration when using WiFi shield with Mega?

A1: Please follow below instructions. More information about Software serial please refer to SoftwareSerial Library.

  • Connect D2 to D10 then D3 to D11 by jumper wires
  • Modify the program: Wifly(2,3); → Wifly(10,11);

Q2: Is Wifi Shield compatible with Arduino Due?

A2: Wifi shield can work with Arduino Due. On hardware, you can connect them via one of the four Serial Ports on Arduino Due(If you use Serial 1-3, you may need to make the connection with jumper wires). The current wifi shield library uses SoftwareSerial, you should modify it to Serial port of Arduino Due.

Q3: How to improve the connectivity between the Wifi Shield and the router?

A3: Do not place plastic or any other dielectric material in touch with the antenna. Any metallic objects in close proximity to the antenna will prevent the antenna from radiating freely.

Ressources

Support technique

Please submit any technical issue into our forum.

Commentaires

Laisser un commentaire

Votre commentaire sera révisé par les administrateurs si besoin.