Arduino et Ethernet : serveur" d' @Eskimon

#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 20, 4); // set the LCD address to 0x27 for a 20 chars and 4 line display
LiquidCrystal_I2C lcd1(0x23, 16, 2); // set the LCD address to 0x27 for a 16 chars and 2 line display

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

// -------------------- Definition 74HC595 --------------------------------
int SER_Pin = 9;   //pin 14 on the 75HC595
int RCLK_Pin = 3;  //pin 12 on the 75HC595
int SRCLK_Pin = 2; //pin 11 on the 75HC595
#define number_of_74hc595s 3
//do not touch
#define numOfRegisterPins number_of_74hc595s * 8

boolean registers[numOfRegisterPins];

//How many of the shift registers - change this
#define number_of_74hc595s 3

//do not touch
#define numOfRegisterPins number_of_74hc595s * 8
void clearRegisters()
{
  for (int i = numOfRegisterPins - 1; i >=  0; i--) {
    registers[i] = LOW;
  }
}

//Set and display registers
//Only call AFTER all values are set how you would like (slow otherwise)

void writeRegisters()
{
  digitalWrite(RCLK_Pin, LOW);
  for (int i = numOfRegisterPins - 1; i >=  0; i--)
  {
    digitalWrite(SRCLK_Pin, LOW);
    int val = registers[i];
    digitalWrite(SER_Pin, val);
    digitalWrite(SRCLK_Pin, HIGH);
  }
  digitalWrite(RCLK_Pin, HIGH);
}

//set an individual pin HIGH or LOW

void setRegisterPin(int index, int value)
{
  registers[index] = value;
}
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()
{
  pinMode(SER_Pin, OUTPUT);
  pinMode(RCLK_Pin, OUTPUT);
  pinMode(SRCLK_Pin, OUTPUT);
  clearRegisters();
  writeRegisters();

  lcd.init();// initialize the lcd
  //lcd.init();
  lcd.clear();
  lcd.backlight();
  lcd1.init();
  lcd1.clear();
  lcd1.backlight();

  // On démarre la voie série pour déboguer
  // Serial.begin(9600);
  Ethernet.init(8);
  Ethernet.begin(mac);
  delay(1000);
  // On lance le serveur
  serveur.begin();
  lcd1.setCursor(0, 0);
  lcd1.print("IP: ");
  lcd1.print(Ethernet.localIP());

  pinMode(4, OUTPUT); digitalWrite(4, LOW);
  pinMode(5, OUTPUT); digitalWrite(5, LOW);
  pinMode(6, OUTPUT); analogWrite(6, 0);

}

void loop()
{
  // Regarde si un client est connecté et attend une réponse
  EthernetClient client = serveur.available();
  if (client)
  { // Un client est là ?
    lcd1.setCursor(0, 1);
    lcd1.print("CNX");
    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 == true)
          {
            // 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();
    lcd1.setCursor(0, 1);
    lcd1.print("               ");
    //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
  lcd.setCursor(0, 1);
  lcd.print("REPONDRE");
  //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 !
      lcd.setCursor(0, 0);
      lcd.print("PB rech 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()
{
  lcd.setCursor(4, 0);
  lcd.print("ACTION");
  // On met à jour nos broches
  digitalWrite(3, etats[0]);
  digitalWrite(4, etats[1]);
  digitalWrite(5, etats[2]);
  // Et la PWM
  analogWrite(6, pwm);
  EthernetClient client;
  repondre(client);
}

<!DOCTYPE html>
<html lang="fr"> 

  <head>

    <meta charset="utf-8">
    <title>Interface de pilotage Arduino</title>
	
  </head> 
  <script type="text/javascript">
var broches = []; // Tableau de broches
var etats = []; // Tableau d'etat des broches
var pwm;
var a0;
var millis;
var adresse = "http://90.113.171.59:4200/"; // L'url+port de votre shield

document.addEventListener('DOMContentLoaded', setup, false);

function setup()
{
    // fonction qui va lier les variables à leur conteneur HTML
    broches[3] = document.getElementById("broche3");
    broches[4] = document.getElementById("broche4");
    broches[5] = document.getElementById("broche5");
    etats[3] = document.getElementById("etat3");
    etats[4] = document.getElementById("etat4");
    etats[5] = document.getElementById("etat5");
    pwm = document.getElementById("pwm");
    a0 = document.getElementById("a0");
    millis = document.getElementById("millis");
    
    // La fonction concernant le bouton
    var bouton = document.getElementById("envoyer");
    bouton.addEventListener('click', executer, false);
}




function executer()
{
    // Fonction qui va créer l'url avec les paramètres puis
    // envoyer la requête
    var requete = new XMLHttpRequest(); // créer un objet de requête
    var url = adresse;
    url += "?b=";
    for(i=3; i <= 5; i++) { // Pour les broches 3 à 5 de notre tableau
        if(broches[i].checked) // si la case est cochée
            url += i + ",";
    }
    // enlève la dernière virgule si elle existe
    if(url[url.length-1] === ',')
        url = url.substring(0, url.length-1);
    // Puis on ajoute la pwm
    url += "&p=" + pwm.value;
    console.log(url) // Pour debugguer l'url formée   
		//alert(url);
    requete.open("GET", url, true); // On construit la requête
    requete.send(null); // On envoie !
    requete.onreadystatechange = function()
	{ // on attend le retour
        if (requete.readyState == 4)
			{ // Revenu !
            if (requete.status == 200)
			{// Retour s'est bien passé !
                // fonction d'affichage (ci-dessous)
				console.log(requete.responseText);
				alert("on y est");
                afficher(requete.responseText);				
            }
			else
			{ // Retour s'est mal passé :(
                alert("faux");
				//alert(requete.status, requete.statusText);
            }
        }
    }
}

function afficher(json)
 {
    alert("afficher");
	alert(json);
	
	// Affiche l'état des broches/pwm/millis revenu en json
    donnees = JSON.parse(json);
    console.log(donnees);
    
    for(i=3; i <= 5; i++) { // Pour les broches 3 à 5 de notre tableau
        etats[i].checked = donnees["broches"][i];
    }
    pwm.value = parseInt(donnees["pwm"]);
    a0.value = parseInt(donnees["A0"]);
    millis.textContent = donnees["uptime"];
}

</script>

  <body>
    <div class="main">
      <p>
        Adresse publique du shield : <br />
        http://<input type="text" id="ip" value="90.113.171.59" size="15"/>
        : <input type="text" id="port" value="4200" size="5"/>
      </p>
      <hr />
      <p>
        <input type="checkbox" id="broche3" name="broche3" />
        <label for="broche3">Activer Broche 3.</label>
        Etat : <input type="radio" id="etat3" disabled />
      </p>
      <p>
        <input type="checkbox" id="broche4" name="broche4" />
        <label for="broche4">Activer Broche 4.</label>
        Etat : <input type="radio" id="etat4" disabled />
      </p>
      <p>
        <input type="checkbox" id="broche5" name="broche5" />
        <label for="broche5">Activer Broche 5.</label>
        Etat : <input type="radio" id="etat5" disabled />
      </p>
      <p>
        PWM : 0<input type="range" min="0" max="255" id="pwm" />255
      </p>
      <p>
        A0 : <meter min="0" max="1023" id="a0" />
      </p>
      <button id="envoyer">Executer !</button>
      <p>
        Millis : <span id="millis">0</span> ms
      </p>
    </div>
  </body>
</html>