1
2
3
4
5
6
7
8
9
10
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
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
| // Ces deux bibliothèques sont indispensables pour le shield
#include <SPI.h>
#include <Ethernet.h>
byte mac[] = { 0x00, 0xAA, 0xBB, 0xCC, 0xDE, 0x02 };
IPAddress ip(192,168,1,16);
// Initialise notre serveur
EthernetServer serveur(5011);
// L'url reçu à stocker
char *url = (char *)malloc(100);
// index indiquant où l'on est dans la chaîne
char index = 0;
boolean etats[3] = {LOW, LOW, LOW}; // états broches 3,4 et 5
unsigned char pwm = 0;
void setup()
{
// Configure et initialise les broches
pinMode(3, OUTPUT); digitalWrite(3, LOW);
pinMode(4, OUTPUT); digitalWrite(4, LOW);
pinMode(5, OUTPUT); digitalWrite(5, LOW);
pinMode(6, OUTPUT); analogWrite (6, 0);
Ethernet.begin(mac, ip);
// Donne une seconde au shield pour s'initialiser
delay(1000);
serveur.begin();
}
void loop()
{
// Regarde si un client est connecté et attend une réponse
EthernetClient client = serveur.available();
if (client)
{
//Serial.println("Ping !");
url = "";
index = 0;
while(client.connected())
{ // Tant que le client est connecté
if(client.available())
{ // A-t-il des choses à dire ?
// traitement des infos du client
// on lit ce qu'il raconte
char carlu = client.read();
if(carlu != '\n')
{ // On est en fin de chaîne ?
// non ! alors on stocke le caractère
// Serial.print(carlu);
url[index] = carlu;
index++;
}
else
{
// on a fini de lire ce qui nous intéresse
// on marque la fin de l'url (caractère de fin de chaîne)
url[index] = '\0';
// essaie d'interpréter la chaîne
boolean ok = interpreter();
if(ok)
{
// tout s'est bien passé alors on met à jour les broches
action();
}
// et dans tous les cas on répond au client
repondre(client);
// on quitte le while
break;
}
}
}
}
// Donne le temps au client de prendre les données
delay(1);
// Ferme la connexion avec le client
client.stop();
}
void rafraichir()
{
// Rafraichit l'etat des broches / PWM
digitalWrite(3, etats[0]);
digitalWrite(4, etats[1]);
digitalWrite(5, etats[2]);
analogWrite (6, pwm);
}
void repondre(EthernetClient myclient)
{
myclient.println("HTTP/1.1 200 OK");
myclient.println("Content-Type: text/html");
// On envoie une ligne vide pour signaler la fin du header
myclient.println();
//page MINIMALISTE CAR J'AI TROP D'ERREURS ICI !!
myclient.println(F("<!DOCTYPE HTML>\r\n<html>\r\n<head>\r\n"));
myclient.println(F("\r\n</head>\r\n<body>BOOOOOF\r\n<br /><br />\r\n"));
myclient.println(F("</body>\r\n</html>"));
}
boolean interpreter()
{ // elle fonctionne très bien...
// On commence par mettre à zéro tous les états
etats[0] = LOW;
etats[1] = LOW;
etats[2] = LOW;
pwm = 0;
// Puis maintenant on va chercher les caractères/marqueurs un par un.
// Index pour se promener dans la chaîne (commence à 4 pour enlever "GET "
index = 0;
while(url[index-1] != 'b' && url[index] != '=')
{ // On commence par chercher le "b="
// Passe au caractère suivant
index++;
if(index == 100)
{
// On est rendu trop loin !
//Serial.println("Oups, probleme dans la recherche de 'b='");
return false;
}
}
// Puis on lit jusqu’à trouver le '&' séparant les broches de p = ....
while(url[index] != '&')
{
if(url[index] >= '3' && url[index] <= '5')
{
// On a trouvé un chiffre identifiant une broche
// On ramène ça au format décimal
char broche = url[index]-'0';
// Puis on met la broche dans un futur état haut
etats[broche-3] = HIGH;
}
index++; // Passe au caractère suivant
if(index == 100)
{
// On est rendu trop loin !
//Serial.println("Oups, probleme dans la lecture des broches");
return false;
}
// NOTE : Les virgules séparatrices sont ignorées
}
// On a les broches, reste plus que la valeur de la PWM
// On cherche le "p="
while(url[index-1] != 'p' && url[index] != '=' && index<100)
{
// Passe au caractère suivant
index++;
if(index == 100)
{
// On est rendu trop loin !
//Serial.println("Oups, probleme dans la recherche de 'p='");
return false;
}
}
// Maintenant, on va fouiller jusqu'a trouver un espace
while(url[index] != ' ')
{ // On cherche le ' ' final
if(url[index] >= '0' && url[index] <= '9')
{
// On a trouve un chiffre !
// On ramene ca au format decimal
char val = url[index]-'0';
// On stocke dans la pwm
pwm = (pwm*10) + val;
}
index++; // Passe au caractère suivant
if(index == 100)
{
// On est rendu trop loin !
//Serial.println("Oups, probleme dans la lecture de la pwm");
return false;
}
// NOTE : Les virgules séparatrices sont ignorées
}
// on a trouvé toutes les informations utiles !
return true;
}
void action()
{
// On met à jour nos broches
digitalWrite(3, etats[0]);
digitalWrite(4, etats[1]);
digitalWrite(5, etats[2]);
// Et la PWM
analogWrite(6, pwm);
} |
