"Arduino et Ethernet : serveur"

L'auteur de ce sujet a trouvé une solution à son problème.
Auteur du sujet

Bonsoir, J'ai un petit problème lorsque je teste le code du tutoriel "[ Arduino 803 ] Arduino et Ethernet : serveur" d' @Eskimon , en effet, j'ai cette erreur lors de la compilation du code complet de la séquence "Agir sur une requête plus précise" ; Image utilisateur

[ http://www.noelshack.com/2015-51-1450469527-captuvdd-bvdre.png ]

Message d'erreur avec d'autre erreurs :/ :

ARDUINOETHERNETTEST:68: error: empty character constant

C:\Users****\Desktop\ARDUINOETHERNETTEST\ARDUINOETHERNETTEST.ino: In function 'void loop()':

C:\Users***\Desktop\ARDUINOETHERNETTEST\ARDUINOETHERNETTEST.ino:54:9: warning: deprecated conversion from string constant to 'char' [-Wwrite-strings]

ARDUINOETHERNETTEST:72: error: 'action' was not declared in this scope

C:\Users****\Desktop\ARDUINOETHERNETTEST\ARDUINOETHERNETTEST.ino: In function 'boolean interpreter()':

ARDUINOETHERNETTEST:180: error: lvalue required as left operand of assignment

C:\Users****\Desktop\ARDUINOETHERNETTEST\ARDUINOETHERNETTEST.ino: At global scope:

ARDUINOETHERNETTEST:194: error: expected unqualified-id before 'return'

ARDUINOETHERNETTEST:195: error: expected declaration before '}' token

exit status 1 empty character constant

Édité par TheLumMys

+0 -0

Salut,

Plutôt que de mettre une capture d'écran du code, copie et colle les lignes de codes qui posent problème directement ici.

En ce qui concerne la ligne surlignée en rouge, l'erreur correspondante semble être error: empty character constant : tu ne peux pas assigner une variable de type char avec un caractère vide. C'est une erreur tout à fait normale en langage C/C++. Je connais trop peu Arduino pour savoir pour quelle raison ce code fonctionne dans le tutoriel d'Eskimon.

En regardant également les autres erreurs et le code du tutoriel, j'en déduis que tu n'utilise pas le même langage/compilateur qu'Eskimon.

Édité par Olybri

+0 -0
Auteur du sujet

Ah, j'ai toujours pris exemple sur le blogue, Ici, si je le copie colle directement dans le compilateur, j’obtiens cette erreur :

sketch_dec23a:70: error: empty character constant

1
2
3
       url[index] = '';

                    ^

sketch_dec23a:478: error: empty character constant

1
2
3
       url[index] = '';

                    ^

C:\Users***\AppData\Local\Temp\arduino_af5509eff45753fa41e46bc9d36b6d1f\sketch_dec23a.ino: In function 'void loop()':

C:\Users**\AppData\Local\Temp\arduino_af5509eff45753fa41e46bc9d36b6d1f\sketch_dec23a.ino:56:9: warning: deprecated conversion from string constant to 'char' [-Wwrite-strings]

1
2
3
 url = ""; // on remet à zéro notre chaîne tampon

     ^

sketch_dec23a:74: error: 'action' was not declared in this scope

1
2
3
         action();

                ^

C:\Users***\AppData\Local\Temp\arduino_af5509eff45753fa41e46bc9d36b6d1f\sketch_dec23a.ino: In function 'boolean interpreter()':

sketch_dec23a:182: error: lvalue required as left operand of assignment

while(url[index-1] != 'p' && url[index] != '=' && index= '0' && url[index] <= '9') {

1
                                                      ^

C:\Users***\AppData\Local\Temp\arduino_af5509eff45753fa41e46bc9d36b6d1f\sketch_dec23a.ino: At global scope:

sketch_dec23a:196: error: expected unqualified-id before 'return'

return true;

^

sketch_dec23a:197: error: expected declaration before '}' token

}

^

exit status 1 empty character constant

// Ces deux bibliothèques sont indispensables pour le shield

include <SPI.h>

include <Ethernet.h>

// L'adresse MAC du shield byte mac[] = { 0x90, 0xA2, 0xDA, 0x0E, 0xA5, 0x7E }; // L'adresse IP que prendra le shield IPAddress ip(192,168,0,143);

// Initialise notre serveur // Ce dernier écoutera sur le port 4200 EthernetServer serveur(4200);

char url = (char )malloc(100); // L'url recu à stocker //char url[100]; char index = 0; // index indiquant où l'on est rendu dans la chaîne boolean etats[3] = {LOW, LOW, LOW}; // L'état des 3 sorties unsigned char pwm = 0; // La valeur de la pwm

void setup() { // On démarre la voie série pour déboguer Serial.begin(9600);

// 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);

char erreur = 0; // On démarre le shield Ethernet SANS adresse ip (donc donnée via DHCP) erreur = Ethernet.begin(mac);

if (erreur == 0) { Serial.println("Parametrage avec ip fixe…"); // si une erreur a eu lieu cela signifie que l'attribution DHCP // ne fonctionne pas. On initialise donc en forçant une IP Ethernet.begin(mac, ip); } Serial.println("Init…"); // Donne une seconde au shield pour s'initialiser delay(1000); // On lance le serveur serveur.begin(); Serial.println("Pret !"); }

void loop() { // Regarde si un client est connecté et attend une réponse EthernetClient client = serveur.available(); if (client) { // Un client est là ? Serial.println("Ping !"); url = ""; // on remet à zéro notre chaîne tampon 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 char carlu = client.read(); //on lit ce qu'il raconte 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 interesse // on marque la fin de l'url (caractère de fin de chaîne) url[index] = ''; boolean ok = interpreter(); // essaie d'interpreter la chaîne if(ok) { // tout s'est bien passé = on met à jour les broches action(); } // et dans tout 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(10); // Ferme la connexion avec le client client.stop(); Serial.println("Pong !"); } }

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 client) { // La fonction prend un client en argument

Serial.println("\nRepondre"); // debug // On fait notre en-tête // Tout d'abord le code de réponse 200 = réussite client.println("HTTP/1.1 200 OK"); // Puis le type mime du contenu renvoyé, du json client.println("Content-Type: application/json"); // Autorise le cross origin client.println("Access-Control-Allow-Origin: *"); // Et c'est tout ! // On envoi une ligne vide pour signaler la fin du header client.println();

// Puis on commence notre JSON par une accolade ouvrante client.println("{"); // On envoie la première clé : "uptime" client.print("\t"uptime": "); // Puis la valeur de l'uptime client.print(millis()); //Une petite virgule pour séparer les deux clés client.println(","); // Et on envoie la seconde nommée "analog 0" client.print("\t"A0": "); client.print(analogRead(A0)); client.println(","); // Puis la valeur de la PWM sur la broche 6 client.print("\t"pwm": "); client.print(pwm, DEC); client.println(","); // Dernières valeurs, les broches (elles mêmes dans un tableau) client.println("\t"broches": {"); // La broche 3 client.print("\t\t"3": "); client.print(digitalRead(3)); client.println(","); // La broche 4 client.print("\t\t"4": "); client.print(digitalRead(4)); client.println(","); // La broche 5 client.print("\t\t"5": "); client.println(digitalRead(5)); client.println("\t}"); // Et enfin on termine notre JSON par une accolade fermante client.println("}"); }

boolean interpreter() { // 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 = 0; // Index pour se promener dans la chaîne (commence à 4 pour enlever "GET " while(url[index-1] != 'b' && url[index] != '=') { // On commence par chercher le "b=" index++; // Passe au caractère suivant 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 pwm while(url[index] != '&') { // On cherche le '&' if(url[index] >= '3' && url[index] <= '5') { // On a trouvé un chiffre identifiant une broche char broche = url[index]-'0'; // On ramène ça au format décimal etats[broche-3] = HIGH; // Puis on met la broche dans un futur état haut } 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= '0' && url[index] <= '9') { // On a trouvé un chiffre ! char val = url[index]-'0'; // On ramène ça au format décimal pwm = (pwm*10) + val; // On stocke dans la pwm } 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 } // Rendu ici, 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); }

et quand je contourne la 1er erreur( url[index] = '\0'; ), j'en ai encore une autre (avec action(); ) et quand la contourne encore, j'en ai encore une autre etc …

Édité par TheLumMys

+0 -0

Cette réponse a aidé l'auteur du sujet

Et voilà le code complet

  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
// Ces deux bibliothèques sont indispensables pour le shield
#include <SPI.h>
#include <Ethernet.h>

// L'adresse MAC du shield
byte mac[] = { 0x90, 0xA2, 0xDA, 0x0E, 0xA5, 0x7E };
// L'adresse IP que prendra le shield
IPAddress ip(192,168,0,143);

// Initialise notre serveur
// Ce dernier écoutera sur le port 4200
EthernetServer serveur(4200);

char *url = (char *)malloc(100); // L'url recu à stocker
//char url[100];
char index = 0; // index indiquant où l'on est rendu dans la chaîne
boolean etats[3] = {LOW, LOW, LOW}; // L'état des 3 sorties
unsigned char pwm = 0; // La valeur de la pwm

void setup()
{
  // On démarre la voie série pour déboguer
  Serial.begin(9600);

  // 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);

  char erreur = 0;
  // On démarre le shield Ethernet SANS adresse ip (donc donnée via DHCP)
  erreur = Ethernet.begin(mac);

  if (erreur == 0) {
    Serial.println("Parametrage avec ip fixe...");
    // si une erreur a eu lieu cela signifie que l'attribution DHCP
    // ne fonctionne pas. On initialise donc en forçant une IP
    Ethernet.begin(mac, ip);
  }
  Serial.println("Init...");
  // Donne une seconde au shield pour s'initialiser
  delay(1000);
  // On lance le serveur
  serveur.begin();
  Serial.println("Pret !");
}

void loop() {
  // Regarde si un client est connecté et attend une réponse
  EthernetClient client = serveur.available();
  if (client) { // Un client est là ?
    Serial.println("Ping !");
    url = ""; // on remet à zéro notre chaîne tampon
    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
        char carlu = client.read(); //on lit ce qu'il raconte
        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';
          boolean ok = interpreter(); // essaie d'interpréter la chaîne
          if(ok) {
            // tout s'est bien passé = on met à jour les broches
            action();
          }
          // et dans tout 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(10);
    // Ferme la connexion avec le client
    client.stop();
    Serial.println("Pong !");
  }
}

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 client) {
  // La fonction prend un client en argument

  Serial.println("\nRepondre"); // debug
  // On fait notre en-tête
  // Tout d'abord le code de réponse 200 = réussite
  client.println("HTTP/1.1 200 OK");
  // Puis le type mime du contenu renvoyé, du json
  client.println("Content-Type: application/json");
  // Autorise le cross origin
  client.println("Access-Control-Allow-Origin: *");
  // Et c'est tout !
  // On envoi une ligne vide pour signaler la fin du header
  client.println();

  // Puis on commence notre JSON par une accolade ouvrante
  client.println("{");
  // On envoie la première clé : "uptime"
  client.print("\t\"uptime\": ");
  // Puis la valeur de l'uptime
  client.print(millis());
  //Une petite virgule pour séparer les deux clés
  client.println(",");
  // Et on envoie la seconde nommée "analog 0"
  client.print("\t\"A0\": ");
  client.print(analogRead(A0));
  client.println(",");
  // Puis la valeur de la PWM sur la broche 6
  client.print("\t\"pwm\": ");
  client.print(pwm, DEC);
  client.println(",");
  // Dernières valeurs, les broches (elles mêmes dans un tableau)
  client.println("\t\"broches\": {");
  // La broche 3
  client.print("\t\t\"3\": ");
  client.print(digitalRead(3));
  client.println(",");
  // La broche 4
  client.print("\t\t\"4\": ");
  client.print(digitalRead(4));
  client.println(",");
  // La broche 5
  client.print("\t\t\"5\": ");
  client.println(digitalRead(5));
  client.println("\t}");
  // Et enfin on termine notre JSON par une accolade fermante
  client.println("}");
}

boolean interpreter() {
  // 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 = 0; // Index pour se promener dans la chaîne (commence à 4 pour enlever "GET "
  while(url[index-1] != 'b' && url[index] != '=') { // On commence par chercher le "b="
    index++; // Passe au caractère suivant
    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 pwm
  while(url[index] != '&') { // On cherche le '&'
    if(url[index] >= '3' && url[index] <= '5') {
      // On a trouvé un chiffre identifiant une broche
      char broche = url[index]-'0'; // On ramène ça au format décimal
      etats[broche-3] = HIGH; // Puis on met la broche dans un futur état haut
    }
    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) {
    index++; // Passe au caractère suivant
    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 !
      char val = url[index]-'0'; // On ramene ca au format decimal
      pwm = (pwm*10) + val; // On stocke dans la pwm
    }
    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
  }
  // Rendu ici, 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);
}

ZdS, le best du Zeste ! Tuto Arduino, blog, etc

+0 -0
Vous devez être connecté pour pouvoir poster un message.
Connexion

Pas encore inscrit ?

Créez un compte en une minute pour profiter pleinement de toutes les fonctionnalités de Zeste de Savoir. Ici, tout est gratuit et sans publicité.
Créer un compte