Les commandes de bases

Aprs avoir branch le shield sur la carte, il est tant de sintresser la bibliothque Wifi
officielle. Celle-ci est relativement simple dutilisation, si vous avez dj utilis le shield Ethernet,
alors vous constaterez de grandes similitudes.

Dans un tout premier temps, il faut inclure deux librairies, la SPI, pour communiquer avec le
shield et le wifi pour faciliter cette communication.

#include <SPI.h>
#include <WiFi.h>

Ensuite, pour dmarrer la liaison wifi, il existe une fonction trs simple : begin. En fonction type
de connexion (sans mot de passe, WPA, WEP), il vous faudra soit seulement le nom du rseau,
soit son nom et le mot de passe, et dans le cas du WEP rajouter son KeyIndex. Cela nous donne
les lignes suivantes :

char ssid[] = "monreseau";

char pass[] = "motdepasse";

int keyIndex = 0;

int status = WL_IDLE_STATUS;

void setup() {

status = WiFi.begin(ssid); // reseau sans mot de passe

status = WiFi.begin(ssid, pass); // connection WPA (le plus courant)

status = WiFi.begin(ssid, keyIndex, pass); //connection WEP

Vous remarquerez que jai rcuprer le retour de la fonction begin dans la variable status, cela
me permet de vrifier le statut du shield (connect, absent), cela nous permet de rajouter
quelques scurits, comme celle-ci qui vrifie que le shield est bien prsent (notez bien que
dans ce cas ce nest pas la variable status mais une fonction de la librairie, car on na pas encore
appel la fonction begin) et que lon est bien connect :

char ssid[] = "monreseau";

char pass[] = "motdepasse";

int keyIndex = 0;

int status = WL_IDLE_STATUS;

void setup() {
Serial.begin(9600);
if (WiFi.status() == WL_NO_SHIELD) {
Serial.println("WiFi shield non connecte");
// don't continue:
while(true);
}
status = WiFi.begin(ssid); // reseau sans mot de passe

status = WiFi.begin(ssid, pass); // connection WPA (le plus courant)

status = WiFi.begin(ssid, keyIndex, pass); //connection WEP

delay(10000);
if ( status != WL_CONNECTED) {
Serial.println("Erreur de connexion");
while(true);
}
else {
Serial.println("Shield connecte au reseau!");
}

Mais il existe une manire plus intelligente de tester si lon est connect, en effet, on peut faire
une boucle que tourne en boucle tant que lon est pas connect, cela ressemble ce bout de
code :

while (status != WL_CONNECTED) {

Serial.print("Tentative de connexion au reseau: ");
Serial.println(ssid);
status = WiFi.begin(ssid, pass);
// wait 10 seconds for connection:
delay(10000);
}
Serial.println("Connecte au wifi");

Ensuite, il peut tre utilise dafficher les diffrents paramtres du shield une fois connect, pour
retrouver son IP local par exemple, pour cela, la documentation dArduino nous fournit une
fonction toute faite :

void printWifiStatus() {
// print the SSID of the network you're attached to:
Serial.print("SSID: ");
Serial.println(WiFi.SSID());

// print your WiFi shield's IP address:

IPAddress ip = WiFi.localIP();
Serial.print("IP Address: ");
Serial.println(ip);
 // print the received signal strength:
long rssi = WiFi.RSSI();
Serial.print("signal strength (RSSI):");
Serial.print(rssi);
Serial.println(" dBm");
}

Voila, il me semble que vous tes bon au niveau des rglages! Nous allons ensuite passer aux
deux fonctions du shield : le serveur et le client.

Le mode serveur

Voila un exemple de la documentation officielle Arduino, qui affiche une page web contenant la
valeur de 6 potentiomtres relis lArduino. Nous allons dcortiquer le code ensemble :

/*
WiFi Web Server

A simple web server that shows the value of the analog input pins.
using a WiFi shield.

This example is written for a network using WPA encryption. For

WEP or WPA, change the Wifi.begin() call accordingly.

Circuit:
* WiFi shield attached
* Analog inputs attached to pins A0 through A5 (optional)

created 13 July 2010

by dlf (Metodo2 srl)
modified 31 May 2012
by Tom Igoe

*/

#include <SPI.h>
#include <WiFi.h>

char ssid[] = "yourNetwork"; // your network SSID (name)

char pass[] = "secretPassword"; // your network password
int keyIndex = 0; // your network key Index number (needed only
for WEP)

int status = WL_IDLE_STATUS;

WiFiServer server(80);

void setup() {
 //Initialize serial and wait for port to open:
Serial.begin(9600);
while (!Serial) {
; // wait for serial port to connect. Needed for Leonardo only
}

// check for the presence of the shield:

if (WiFi.status() == WL_NO_SHIELD) {
Serial.println("WiFi shield not present");
// don't continue:
while(true);
}

// attempt to connect to Wifi network:

while ( status != WL_CONNECTED) {
Serial.print("Attempting to connect to SSID: ");
Serial.println(ssid);
// Connect to WPA/WPA2 network. Change this line if using open or WEP
network:
status = WiFi.begin(ssid, pass);

// wait 10 seconds for connection:

delay(10000);
}
server.begin();
// you're connected now, so print out the status:
printWifiStatus();
}

void loop() {
// listen for incoming clients
WiFiClient client = server.available();
if (client) {
Serial.println("new client");
// an http request ends with a blank line
boolean currentLineIsBlank = true;
while (client.connected()) {
if (client.available()) {
char c = client.read();
Serial.write(c);
// if you've gotten to the end of the line (received a newline
// character) and the line is blank, the http request has ended,
// so you can send a reply
if (c == '\n' && currentLineIsBlank) {
// send a standard http response header
client.println("HTTP/1.1 200 OK");
client.println("Content-Type: text/html");
client.println("Connection: close"); // the connection will be
closed after completion of the response
client.println("Refresh: 5"); // refresh the page automatically
every 5 sec
client.println();
client.println("<!DOCTYPE HTML>");
 client.println("<html>");
// output the value of each analog input pin
for (int analogChannel = 0; analogChannel < 6; analogChannel++) {
int sensorReading = analogRead(analogChannel);
client.print("analog input ");
client.print(analogChannel);
client.print(" is ");
client.print(sensorReading);
client.println("<br />");
}
client.println("</html>");
break;
}
if (c == '\n') {
// you're starting a new line
currentLineIsBlank = true;
}
else if (c != '\r') {
// you've gotten a character on the current line
currentLineIsBlank = false;
}
}
}
// give the web browser time to receive the data
delay(1);

// close the connection:

client.stop();
Serial.println("client disonnected");
}
}

void printWifiStatus() {
// print the SSID of the network you're attached to:
Serial.print("SSID: ");
Serial.println(WiFi.SSID());

// print your WiFi shield's IP address:

IPAddress ip = WiFi.localIP();
Serial.print("IP Address: ");
Serial.println(ip);

// print the received signal strength:

long rssi = WiFi.RSSI();
Serial.print("signal strength (RSSI):");
Serial.print(rssi);
Serial.println(" dBm");
}

En tte de ce programme, on retrouve une nouvelle variable : WiFiServer server(80); La variable

server est en fait la variable dont on va se servir pour utiliser notre serveur, que ce soit pour
rcuprer les clients, leur envoyer des donns ou en recevoir. Quand au nombre 80, il indique le
port sur lequel le serveur va couter , il faut savoir que lon peut se connecter un serveur
sur diffrents ports, en fonction de lorganisation de celui-ci, par exemple le port 22 est en
gnral pour le FTP. Le port par defaut des requetes HTTP, cest dirre le port par defaut de
votre navigateur web est le port 80, cest pourquoi on met ici 80 comme port. Si vous changez
ce nombre, il faut dans votre navigateur rajouter le port de connexion de cette facon :
VOTREIP:PORT (ex -> 192.168.0.21:8080).

Ensuite vient tout la partie dinitialisation que lon a dj vu ensemble. Mais on remarque aussi
le server.begin () qui comme son nom lindique dmarre le serveur.

Puis vient la partie intressante. Dans la fonction loop() de notre programme on regarde si un
client essaye de se connecter notre serveur de cette faon :

WiFiClient client = server.available();

if (client) {
Serial.println( nouveau client );

Le server.available renvoie une variable de type client si un client essaye de se connecter, on

rcupre cette variable et on regarde si elle vaut quelque chose grce au if. Si elle vaut quelque
chose alors on va pouvoir faire des manipulations avec.

Ces manipulations sont un peu plus complexes comprendre mais rien de bien inquitant. Tout
dabord, on peut rcuprer les caractre que nous envoie le client laide de client.read(); qui
marche comme pour la liaison srie en quelque sorte. On sait aussi quune requte HTTP finie
par une ligne blanche, autrement dit, lorsque lon trouvera deux /n la requte sera termine et
on pourra crire notre rponse. On peut donc maintenant comprendre le code suivant :

if (client) {
Serial.println("new client");
boolean currentLineIsBlank = true;
while (client.connected()) {
if (client.available()) {
char c = client.read();
Serial.write(c);

if (c == '\n' && currentLineIsBlank) {

// le requete est finie, on peut donner notre reponse.

// pour ecrire vos propres reponses, renseignez vous sur le protocol HTTP,
voila une reponse classique
client.println("HTTP/1.1 200 OK");
client.println("Content-Type: text/html");
client.println("Connection: close");
client.println("Refresh: 5");
client.println();
// maintenant place au code HTML
client.println("<!DOCTYPE HTML>");
client.println("<html>");
for (int analogChannel = 0; analogChannel < 6; analogChannel++) {
int sensorReading = analogRead(analogChannel);
client.print("analog input ");
client.print(analogChannel);
client.print(" is ");
client.print(sensorReading);
client.println("<br />");
}
client.println("</html>");
break;
}
if (c == '\n') {
// On commence une nouvelle ligne
currentLineIsBlank = true;
}
else if (c != '\r') {
currentLineIsBlank = false;
}
}
}
delay(1);
client.stop();
Serial.println("client deconnecte");
}

Comme vous laurez vu, ds que le client se dconnecte, on appelle la fonction client.stop() pour
stopper la connexion de notre cot aussi.

Voila, vous savez maintenant programmer un serveur web avec votre Arduino, notez bien que
vous ntes pas obligs de suivre le protocole HTTP mais que vous pouvez aussi inventer les
vtres si vous avez des besoins spcifiques.

Le mode client

Voila maintenant un code, pris de la documentation officielle encore une fois, qui envoie par
liaison srie la rponse HTML de google sur la recherche de tutoarduino , nous allons de la
mme faon dcortiquer ce code :

/*
Web client

This sketch connects to a website (http://www.google.com)

using a WiFi shield.

This example is written for a network using WPA encryption. For

WEP or WPA, change the Wifi.begin() call accordingly.
 This example is written for a network using WPA encryption. For
WEP or WPA, change the Wifi.begin() call accordingly.

Circuit:
* WiFi shield attached

created 13 July 2010

by dlf (Metodo2 srl)
modified 31 May 2012
by Tom Igoe
*/

#include <SPI.h>
#include <WiFi.h>

char ssid[] = "yourNetwork"; // your network SSID (name)

char pass[] = "secretPassword"; // your network password (use for WPA, or
use as key for WEP)
int keyIndex = 0; // your network key Index number (needed only for
WEP)

int status = WL_IDLE_STATUS;

// if you don't want to use DNS (and reduce your sketch size)
// use the numeric IP instead of the name for the server:
//IPAddress server(74,125,232,128); // numeric IP for Google (no DNS)
char server[] = "www.google.com"; // name address for Google (using DNS)

// Initialize the Ethernet client library

// with the IP address and port of the server
// that you want to connect to (port 80 is default for HTTP):
WiFiClient client;

void setup() {
//Initialize serial and wait for port to open:
Serial.begin(9600);
while (!Serial) {
; // wait for serial port to connect. Needed for Leonardo only
}

// check for the presence of the shield:

if (WiFi.status() == WL_NO_SHIELD) {
Serial.println("WiFi shield not present");
// don't continue:
while(true);
}

// attempt to connect to Wifi network:

while (status != WL_CONNECTED) {
Serial.print("Attempting to connect to SSID: ");
Serial.println(ssid);
// Connect to WPA/WPA2 network. Change this line if using open or WEP
network:
 status = WiFi.begin(ssid, pass);

// wait 10 seconds for connection:

delay(10000);
}
Serial.println("Connected to wifi");
printWifiStatus();

Serial.println("\nStarting connection to server...");

// if you get a connection, report back via serial:
if (client.connect(server, 80)) {
Serial.println("connected to server");
// Make a HTTP request:
client.println("GET /search?q=arduino HTTP/1.1");
client.println("Host: www.google.com");
client.println("Connection: close");
client.println();
}
}

void loop() {
// if there are incoming bytes available
// from the server, read them and print them:
while (client.available()) {
char c = client.read();
Serial.write(c);
}

// if the server's disconnected, stop the client:

if (!client.connected()) {
Serial.println();
Serial.println("disconnecting from server.");
client.stop();

// do nothing forevermore:
while(true);
}
}

void printWifiStatus() {
// print the SSID of the network you're attached to:
Serial.print("SSID: ");
Serial.println(WiFi.SSID());

// print your WiFi shield's IP address:

IPAddress ip = WiFi.localIP();
Serial.print("IP Address: ");
Serial.println(ip);

// print the received signal strength:

long rssi = WiFi.RSSI();
Serial.print("signal strength (RSSI):");
Serial.print(rssi);
 Serial.println(" dBm");
}

Dans ce code, on retrouve deux nouvelles variables, une chane de caractre server qui contient
lURL du serveur auquel on veut se connecter, cela peut aussi tre une IP. Et une variable de
type WifiClient que lon a dj rencontr auparavant, qui va nous servir interagir avec le
serveur de google.

Ensuite on retrouve le bout de code concernant la connexion. On utilise la fonction

connect(URL, PORT) pour ce connecter au serveur en question, cette fonction renvoie true ou
false, ce qui nous permet de tester son succs. Ensuite, on trouve dans cette mme partie
lenvoi de la requete HTTP, pour plus de renseignement sur ce protocole, je vous conseille cette
page qui est une bonne introduction. Vous pouvez maintenant comprendre le code suivant :

if (client.connect(server, 80)) {
Serial.println("connected to server");
// Make a HTTP request:
client.println("GET /search?q=arduino HTTP/1.1");
client.println("Host: www.google.com");
client.println("Connection: close");
client.println();
}

Ensuite, on peut agir dans la fonction loop() comme en quelque sorte avec une liaison srie, on
utilise la fonction read() pour lire les caractres envoys, et on peut dans cet exemple les
envoyer par liaison srie, ce qui nous donne ce code :

while (client.available()) {
char c = client.read();
Serial.write(c);
}

Enfin, il faut penser vrifier que lon est toujours connect au serveur, pour pouvoir fermer la
connexion au besoin, pour cela, il existe la fonction connected() qui renvoie true ou false, on
arrive donc ce bout de code :

if (!client.connected()) {
Serial.println();
Serial.println("deconnecte du server");
client.stop();

// on arrete le programme
while(true);
}
Et voila, ce tutoriel touche sa fin ,normalement vous tes capables de manipuler votre shield
comme vous le souhaitez. Pour plus de dtails sur des fonctions plus techniques, pensez vous
rendre sur la documentation officielle ou poser une question en commentaire ou sur notre
forum, rponse rapide assure!!