// — Programme Arduino —
// Trame de code générée par le générateur de code Arduino
// du site www.mon-club-elec.fr

// Auteur du Programme : X. HINAULT – Tous droits réservés
// Programme écrit le : 23/05/2011.

// ——- Licence du code de ce programme —–
//  This program is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License,
//  or any later version.
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//  You should have received a copy of the GNU General Public License
//  along with this program.  If not, see <http://www.gnu.org/licenses/>.

// ////////////////////  PRESENTATION DU PROGRAMME ////////////////////

// ——– Que fait ce programme ? ———
 /* Ce programme réalise un simple serveur wifi (port 5905) à l’aide du shield Arduino wifi RedFly de chez Watterott.

  ce serveur reçoit chaine caractères en provenance client réseau wifi

Deux servomoteurs connectés à la carte Arduino sont contrôlés
à partir du PC (interface Processing

Controle par chaine de la forme : servoPan(000) avec 000 = angle en degrés

*/

// — Fonctionnalités utilisées —

// Utilise la connexion série matérielle vers le PC
// Utilise le stockage des variables en mémoire Flash Programme
// Utilise 2 servomoteurs pour tourelle Pan/Tilt (Panoramique/inclinaison)
// Utilise le shield RedFly pour connexion Wifi (par Watterott)

// ——– Circuit à réaliser ———

// La connexion série matérielle vers le PC utilise les broches 0 et 1 (via le câble USB)
// Module wifi Redfly de chez Watterott connecté broche à broche sur la carte Arduino
// utilise les broches 0 et 1 (communication série matérielle) + broches 3 et 4

// ******* ATTENTION : il est possible de connecter directement 2 ou 3 servomoteurs sur la carte Arduino
// Connecter un servomoteur PAN sur la broche 8
// Connecter un servomoteur TILT sur la broche 9

// /////////////////////////////// 1. Entête déclarative ///////////////////////
// A ce niveau sont déclarées les librairies incluses, les constantes, les variables, les objets utiles…

// — Déclaration des constantes —

// — Inclusion des librairies —

#include <Servo.h> // librairie pour servomoteur

#include <Flash.h> // Inclusion librairie pour stockage en mémoire Flash Programme
// Avant utilisation, il faut installer manuellement cette librairie
// dans le dossier <Libraries> du dossier Arduino
// infos : www.mon-club-elec.fr/pmwiki_reference_arduino/pmwiki.php?n=Main.LibrairieFlashProgramme

#include <RedFly.h> // inclusion de la librairie pour shield Arduino wifi RedFly (watterott)
// Avant utilisation, il faut installer manuellement cette librairie
// dans le dossier <Libraries> du dossier Arduino
// infos : www.mon-club-elec.fr/pmwiki_reference_arduino/pmwiki.php?n=Main.LibrairieRedFly

// — Déclaration des constantes utiles —

//— Constantes utilisées avec le servomoteur
const int ANGLE_MIN=0; // angle position MIN en degrés
const int POS_MIN=550; // largeur impulsion pour position ANGLE_MIN degrés du servomoteur
                  // par exemple POS_MIN=600 pour ANGLE_MIN=10° avec un futaba S3003
                  // ou POS_MIN=550 pour ANGLE_MIN=0 avec un futaba S3003

const int ANGLE_MAX=172; // angle position MAX en degrés
int POS_MAX=2400; // largeur impulsion pour position ANGLE_MAX degrés du servomoteur
                  // POS_MAS=2300 pour ANGLE_MIN=170° pour futaba s3003
                  // ou POS_MAX=2400 pour ANGLE_MAX=172 pour futaba S3003

// pour étalonner un servomoteur, voir la page :
//https://www.mon-club-elec.fr/pmwiki_mon_club_elec/pmwiki.php?n=MAIN.ArduinoExpertSerieDepuisPCPositionServomoteur

// — Déclaration des constantes des broches E/S numériques —

const int broche_servoPan=8; // Constante pour la broche 8
const int broche_servoTilt=9; // Constante pour la broche 8

// — Déclaration des constantes des broches analogiques —

// — Déclaration des variables globales —

//—— variables pour le réseau wifi avec le module RedFly —-
byte ip[]      = { 192,168,  2, 10 }; //tableau contenant adresse ip du shield wifi RedFly (serveur) – 4 octets
byte netmask[] = { 255,255,255,  0 }; // tableau contenant le masque de sous-réseau – 4 octets

byte mac[]= {0,0,0,0,0,0}; //tableau contenant l’adresse mac du module wifi – 6 octets

//unsigned int port=80; // port utilisé pour la connexion
unsigned int port=5905; // port utilisé pour la connexion

byte ligneReseau=0xFF; // identifiant de ligne réseau
int ligneReseau_len=0; // réception len
char ligneReseau_buf[100]; // buffer de réception

//—– debug – tableau de la variable rd où est stocké la valeur renvoyée par la fonction socketRead()
//String mem_rd= » »; // Pour mémoriser les valeurs de la variable rd
char mem_rd[100]; // pour mémoriser les valeurs de la variable rd
int compt_rd=0; // pour comptage nombre valeur de la variable rd

char ssid[32]; // tableau pour stocker ssid (nom du réseau)
byte mode; // variable pour stocker mode du réseau (0=Open, 1=WPA, 2=WPA2, 3=WEP)
byte rssi; // variable pour stocker rssi (la force du signal réseau)

//——— pour la chaine reçue par le réseau —-

String chaineIn=«  »; // déclare un objet String vide pour reception chaine

 int valeur=0; // variable reception valeur port série

int angleServoPan=90; // variable de position du servo  Pan en degrés
int angleServoTilt=90; // variable de position du servo  Tilt en degrés

int angleServoPan0=90; // variable de la dernière position du servo  Pan en degrés
int angleServoTilt0=90; // variable de la dernière position du servo  Tilt en degrés

int vitesse=10; // variable utilisée pour délai entre 2 lecture port Série

// — Déclaration des objets utiles pour les fonctionnalités utilisées —

Servo mon_servoPan;  // crée un objet servo pour contrôler le servomoteur 1
Servo mon_servoTilt;  // crée un objet servo pour contrôler le servomoteur 2

// l’objet RedFly est automatiquement créé lors de l’inclusion de la librairie
// toutes les fonctions de la librairie RedFly s’appliquent à cet objet sous la forme RedFly.fonction()

// ////////////////////////// 2. FONCTION SETUP = Code d’initialisation //////////////////////////
// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme

void setup()   { // debut de la fonction setup()

// — ici instructions à exécuter 1 seule fois au démarrage du programme —

// ——- Initialisation fonctionnalités utilisées ——-  

Serial.begin(9600); // initialise connexion série matérielle à 9600 bauds
// IMPORTANT : régler le terminal côté PC avec la même valeur de transmission
// Module RedFly : la communication série avec le module se fait à 9600 Bauds

delay(100); // delai avant communication avec module wifi

//— Initialisation Servomoteur
mon_servoPan.attach(broche_servoPan);  // attache l’objet servo à la broche de commande du servomoteur Pan
mon_servoTilt.attach(broche_servoTilt);  // attache l’objet servo à la broche de commande du servomoteur Tilt

// ——- Broches en sorties numériques ——-  
 pinMode (broche_servoPan,OUTPUT); // Broche broche_servoPan configurée en sortie
 pinMode (broche_servoTilt,OUTPUT); // Broche broche_servoPan configurée en sortie

// ——- Broches en entrées numériques ——-  

// ——- Activation si besoin du rappel au + (pullup) des broches en entrées numériques ——-  

// ——- Initialisation des variables utilisées ——-  

// ——- Codes d’initialisation utile ——-  

//———— initialisation du module wifi RedFly —-

initialisationRedFly(); // appelle fonction initialisation

//—- positionnement initial servomoteur
mon_servoPan.writeMicroseconds(angle(angleServoPan)); // crée impulsion à partir valeur angle – plus précis que write()
mon_servoTilt.writeMicroseconds(angle(angleServoTilt)); // crée impulsion à partir valeur angle – plus précis que write()

delay(1000);

} // fin de la fonction setup()
// ********************************************************************************

////////////////////////////////// 3. FONCTION LOOP = Boucle sans fin = coeur du programme //////////////////
// la fonction loop() s’exécute sans fin en boucle aussi longtemps que l’Arduino est sous tension

void loop(){ // debut de la fonction loop()

//————— Wifi : gestion des connexions clients entrantes —————–

  //uint8_t sock, buf[32];
  byte sock, buf[32]; // sock = numéro de ligne en écoute – buf = buffer réception

  //uint16_t rd, len;
  int unsigned rd, len; // rd = mémorise retour de socketRead()=taille des données lues ? – len : taille totale des données disponibles

  if(ligneReseau == 0xFF) // si il n’y a pas de ligne réseau ouverte – cf socketListen()

  {

    debugoutln(« Pas de ligne ouverte »); // affiche message
    return; // sort de la fonction

  }

  sock = 0xff; //pour renvoi des données de toutes les lignes réseau
  // paramètre passé à la fonction socketRead()

  rd = RedFly.socketRead(&sock, &len, 0, 0, buf, sizeof(buf));
  // la fonction socketRead renvoie le nombre de données lues = mises dans le buffer destination

  if(sock == ligneReseau) // si la ligne lue est la ligne Réseau obtenue avec SocketListen (port défini)

  {

/*    //——— éviter les messages pendant la lecture des données en réception car çà perturbe la communication entre redfly et Arduino
     //——– affiche message —–
  if (rd!=0) { // si des données ont été lues —
    RedFly.disable();
    Serial.print(« rd = »);
    Serial.println(rd);
    RedFly.enable();
  }

*/

    if((rd != 0) && (rd != 0xffff)) // si la fonction socketRead() n’a pas renvoyé 0 (= des données ont été lues)
    // et n’a pas renvoyé 0xFFFF (= connexion interrompue)
    // il semble que la fonction socketRead() renvoie 1 à chaque passage —

    {

      //———- pour éviter débordement buffer réception ligne réseau ———–

      if((ligneReseau_len+rd) > sizeof(ligneReseau_buf)) // si la longueur données déjà présente dans buffer + taille données lues > taille buffer

      {

        rd = sizeof(ligneReseau_buf)–ligneReseau_len; // la taille données lues est réduite à la place restante dans buffer ligne Reseau

      }

      //——— récupération données reçues par réseau dans buffer réception ligne réseau

      memcpy(&ligneReseau_buf[ligneReseau_len], buf, rd); // copie dans http buffer le contenu de buf longueur rd (?)

      ligneReseau_len += rd; // incrémente longueur données présentes dans http buffer de la quantité données rd

      //— mémorisation valeur rd pour affichage —
      //mem_rd=mem_rd+rd; // ajoute la valeur de rd au String
      //mem_rd[compt_rd]=rd+48; // mémorise valeur ascii de rd
      if (compt_rd<(sizeof(mem_rd)–1)) mem_rd[compt_rd]=rd+48; // mémorise valeur ascii de rd tant que compt_rd < taille tableau mem_rd
      compt_rd ++; // incrémente compt_rd

    } // fin si (rd != 0) && (rd != 0xffff)

    if((rd == 0xffff)  || (len == 0)) // si la connexion est fermée ou si toutes les données sont lues
    // une fois que la chaine est reçue donc…

    {

      //ferme la ligne réseau si connexion fermée – sinon laisse ouvert pour nouvelle réception
      if (rd == 0xffff) {

        debugoutln(« La ligne est fermee »); // affiche message
        RedFly.socketClose(sock); // ferme la ligne

        ecouteLigneReseau(); //————- ré-ouverture de la ligne réseau en écoute ————

      } // fin si ligne fermée

      //affiche le contenu du http buffer
      ligneReseau_buf[sizeof(ligneReseau_buf)–1] = 0; // met 0 dans la dernière case de http buffer (une chaine de caractère se termine par 0)

      //debugoutln(ligneReseau_buf); // affiche le contenu du http buffer – possible une fois communication entre Redfly et Arduino finie

      mem_rd[sizeof(mem_rd)–1]=0; // met 0 dans dernière case du tableau (une chaine de caractère se termine par 0)

      //debugout(« Valeurs rd : « ); // affiche message      
      //debugoutln (mem_rd); // affiche liste valeur des rd

      RedFly.disable();
      //Serial.print(F(« comptage rd : « ));
      //Serial.println(compt_rd);
      RedFly.enable();

//—– une fois que la chaine est reçue

      RedFly.disable(); // désactive le wifi pendant toute la procédure pour messages

      chaineIn=ligneReseau_buf; // met le buffer dans le String…

      analyseChaine(chaineIn); //appel fonction analyse chaine

      RedFly.enable(); // réactive wifi

//————- fin analyse chaine —————
      chaineIn=«  »; //RAZ le String de réception

      //——– réinitialise réception nouvelle chaine par wifi ———–
      compt_rd=0; // RAZ compt_rd

      for (int i=0; i<ligneReseau_len; i++) ligneReseau_buf[i]=‘ ‘; // RAZ des caractères utilisés du buffer ligneReseau

      ligneReseau_len=0; // RAZ ligneReseau_len

    } // fin si len==0

  } // fin si sock == ligneReseau

   //delay(vitesse); // fixe la vitesse de mouvement du servo – entre 2 lecture analogique
  // delay perturbe réception —

} // fin de la fonction loop() – le programme recommence au début de la fonction loop sans fin
// ********************************************************************************

// ////////////////////////// FONCTIONS DE GESTION DES INTERRUPTIONS ////////////////////

// ////////////////////////// AUTRES FONCTIONS DU PROGRAMME ////////////////////

//——— fonctions pour affichage Terminal série avec shield RedFly —
//—- chacune de ces fonctions désactive/active la communication série et utilise fonction Serial.print ou Serial.println
void debugout(char *s)  { RedFly.disable(); Serial.print(s);   RedFly.enable(); }
void debugoutln(char *s){ RedFly.disable(); Serial.println(s); RedFly.enable(); }

//————- fonction calibrage impulsion servomoteur à partir valeur angle en degrés

int angle(int valeur_angle) {

        int impuls=0;
        impuls=map(valeur_angle,ANGLE_MIN,ANGLE_MAX,POS_MIN, POS_MAX);
        return impuls;  

} // fin fonction impulsion servomoteur

//————— initialisation module RedFly ———————-

void initialisationRedFly() {

  byte ret; // variable pour stockage valeur renvoyées par fonctions utilisées

  //initialisation du module wifi intégré sur le shield RedFly
  ret = RedFly.init(HIGH_POWER); // initialise le module wifi avec niveau HAUT série = 5V – valeur renvoyée stockée dans ret
  //valeurs possibles : LOW_POWER MED_POWER HIGH_POWER

  if(ret!=0) { // si la fonction init() n’a pas renvoyé 0  

    debugoutln(« Echec initialisation module wifi »); // affiche message

  } // si échec initialisation module wifi

  else { // si la fonction init a renvoyé 0 càd si initialisation réussie

    debugoutln(« Initialisation module wifi OK »); // affiche message

    //récupération de l’adresse MAC du module wifi
    RedFly.getmac(mac); // récupère l’adresse mac et la met dans le tableau reçu par la fonction

    //———— affiche adresse MAC au format xx:xx:xx:xx:xx:xx
    RedFly.disable(); // désactive communication série avec module wifi avant utilisation Serial.print

    Serial.print(F(« Adresse MAC du module : « )); // affiche message

    for (int i=0; i<6; i++) { // défile les 6 octets

      if (mac[i]<10) Serial.print(0,HEX),Serial.print(mac[i],HEX), Serial.print(« : »); // affiche message
      else Serial.print(mac[i],HEX), Serial.print(« : »);

    } // fin for

    Serial.println(); // saut de ligne
    Serial.println(); // saut de ligne

    RedFly.enable(); // ré-active communication série avec module wifi après utilisation Serial.print

    //————- détection réseau sans fil disponible ———-

    RedFly.disable(),Serial.println(F(« —- recherche reseau wifi disponible —-« )), RedFly.enable(); // affiche message

    //on commence par rechercher un réseau sans fil disponible — à faire avant join()
    //RedFly.scan(); // recherche réseau sans récupérer infos

    //scan(char ssid[], uint8_t *mode, uint8_t *rssi)
    ret=RedFly.scan( ssid, &mode, &rssi); // recherche réseau et récupère infos dans variables reçues par la fonction

    //– affichage des valeurs récupérées —
    RedFly.disable(); // désactivation série module wifi

//    Serial.print(« Valeur renvoyee = « ), Serial.println(int(ret)); // affiche valeur de ret
    Serial.print(F(« Nom reseau detecte : « )), Serial.println(ssid);
    Serial.print(F(« Mode reseau (0=Open, 1=WPA, 2=WPA2, 3=WEP) = « )), Serial.println(int(mode));
    Serial.print(F(« Force du signal = « )), Serial.print(int(rssi)), Serial.println(« % »);
    Serial.println(); // saut de ligne

    RedFly.enable(); // ré-activation série module wifi

    //—- recherche plusieurs réseaux disponibles —
    // — nextscan() semble devoir etre précéde de scan()
/*
    RedFly.disable(), Serial.println(« —- recherche des 5ers reseaux wifi disponibles —-« ), Serial.println(), RedFly.enable(); // affiche message

    for (int i=0; i<5; i++) { // détecte les 5 premiers réseaux trouvés

    ret=RedFly.nextscan( ssid, &mode, &rssi); // recherche réseau et récupère infos dans variables reçues par la fonction

    //– affichage des valeurs récupérées —
    RedFly.disable(); // désactivation série module wifi

//  Serial.print(« Valeur renvoyee = « ), Serial.println(int(ret)); // affiche valeur de ret
    Serial.print(« Nom reseau detecte : « ), Serial.println(ssid);
    Serial.print(« Mode reseau (0=Open, 1=WPA, 2=WPA2, 3=WEP) = « ), Serial.println(int(mode));
    Serial.print(« Force du signal = « ), Serial.print(int(rssi)), Serial.println(« % »);
    Serial.println(); // saut de ligne

    RedFly.enable(); // ré-activation série module wifi

    } // fin for i détection n premiers réseaux trouvés
*/    

    //————- Connexion au réseau détecté —————
    //ret = RedFly.join(« belkin54g », « ADB48F70E9B9B2733C2FA8D90E »,INFRASTRUCTURE); // »wlan » (SSID=nom), « 12345678 » (clé wep ou wap), INFRASTRUCTURE or IBSS_JOINER
    //ret = RedFly.join(« Livebox-f0c2 », « FAD994A61922743DA3DC1933F5″,INFRASTRUCTURE); // »wlan » (SSID=nom), « 12345678 » (clé wep ou wap), INFRASTRUCTURE or IBSS_JOINER
    //ret = RedFly.join(« NETGEAR », «  »,INFRASTRUCTURE); // »wlan » (SSID=nom), « 12345678 » (clé wep ou wap), INFRASTRUCTURE or IBSS_JOINER
    ret = RedFly.join(« NETGEAR »); // »wlan » (SSID=nom) – connexino sur réseau non sécurisé par clé wep = le plus simple

    if(ret!=0) { // si valeur renvoyée par join n’est pas nulle = erreur de connexion

      debugoutln(« Erreur de connexion au reseau wifi ! »);

    } // fin if

    else { // si valeur renvoyée par join nulle = connexion au réseau wifi réussie

       debugoutln(« Connexion au reseau wifi : OK ! »);

      //configuration de l’adresse IP du module wifi
      ret = RedFly.begin(); //attribution automatique – avec un routeur en mode DHCP – le plus simple

      //ret = RedFly.begin(ip);
      //ret = RedFly.begin(ip, gateway);
      //ret = RedFly.begin(ip, gateway, netmask);
      //ret = RedFly.begin(ip, 0, netmask);

        if(ret!=0) { // si la valeur renvoyée par la fonction begin n’est pas nulle = en cas d’erreur de configuration

          debugoutln(« Erreur de configuration initiale parametres reseau »);
          RedFly.disconnect();
          debugoutln(« Deconnexion du reseau wifi »);

        }// fin if

        else {

          debugoutln(« Configuration initiale parametres reseau : OK ! »);

          ecouteLigneReseau(); //————- ouverture de la ligne réseau en écoute – voir fonction ————

        } // fin else

    } // fin else

  } // fin si Initialisation module OK

} // ——– fin initialisation module wifi Redfly ————-

//————- fonction ouverture de la ligne réseau RedFly en écoute ————

void ecouteLigneReseau (void) {  

  ligneReseau = RedFly.socketListen(PROTO_TCP, port); //lance écoute sur le port  en utilisant le protocole TCP = serveur sur port défini
          // socketListen renvoie 0xFF si erreur… sinon, renvoie le numéro de la ligne en écoute

          if(ligneReseau == 0xFF) { // la fonction socketListen renvoie 0xFF si erreur… sinon, renvoie le numéro de la ligne en écoute

            debugoutln(« Erreur de connexion ligne reseau »);

              RedFly.disconnect();
              debugoutln(« Deconnexion du reseau wifi »);

            }// fin if

          else { // si pas d’erreur

            //debugoutln(« Ecoute ligne reseau TCP sur port 80 : OK ! »);

            RedFly.disable();
            Serial.print(F(« Ecoute ligne reseau TCP sur port « ));
            Serial.print(port);
            Serial.println(F( » : OK ! »));
            RedFly.enable();

          }// fin else ligne reseau

} // fin fonction ouverture de la ligne réseau RedFly en écoute ————

//———————- fonction analyse chaine ——————-

void analyseChaine (String chaineReception) {

 // —- analyse de la chaine recue sur le port Série —-
chaineReception=chaineReception.trim(); // enlève les espaces

//—– gestion servomoteur PAN —-
if (chaineReception.substring(0,9)==« servoPan(« ) { // si reçoit l’instruction servoPan(000)
// nb substring : dernier caractere exclu

  //Serial.print(F(« Arduino va executer : « ));

  //Serial.print(F(« servoPan(« )); // affiche

  //————- extraction valeur angle servomoteur  —— 3 chiffres

    //—- extraction 1er chiffre
    valeur=chaineReception.charAt(9); // extrait valeur ASCII du caractere
    valeur=valeur–48; // extrait valeur numérique du caractere
    angleServoPan=valeur;

     //—- extraction 2ème chiffre
    valeur=chaineReception.charAt(10); // extrait valeur ASCII du caractere
    valeur=valeur–48; // extrait valeur numérique du caractere
    angleServoPan=angleServoPan*10+valeur;

    //—- extraction 3ème chiffre
    valeur=chaineReception.charAt(11); // extrait valeur ASCII du caractere
    valeur=valeur–48; // extrait valeur numérique du caractere
    angleServoPan=angleServoPan*10+valeur;

  //Serial.print(angleServoPan); // affiche

  if (chaineReception.substring(12,13)==« ) ») { // si fermeture parenthèse = instruction valide

    //Serial.println(F(« ) »)); // affiche
    //Serial.println(F(« Instruction valide ! »)); // affiche

    //—– positionnement du servomoteur —-

    angleServoPan=constrain(angleServoPan,ANGLE_MIN,ANGLE_MAX); // oblige valeur angle Servo
    mon_servoPan.writeMicroseconds(angle(angleServoPan)); // crée impulsion à partir valeur angle – plus précis que write()
    //angleServoPan0=angleServoPan; // mémorise dernière valeur angle prise en compte

    //delay(1000); // laisse temps positionnement

    //Serial.println(F(« Servomoteur mis en position »)); // affiche

  } // fin si fermeture parenthèse  

} // — fin si reçoit instruction servoPan(000)

//——————— gestion servomoteur Tilt ——————————-

//—– gestion servomoteur TILT —-
if (chaineReception.substring(0,10)==« servoTilt(« ) { // si reçoit l’instruction servoPan(000)
// nb substring : dernier caractere exclu

  //Serial.print(F(« Arduino va executer : « ));

  //Serial.print(F(« servoTilt(« )); // affiche

  //————- extraction valeur angle servomoteur  —— 3 chiffres

    //—- extraction 1er chiffre
    valeur=chaineReception.charAt(10); // extrait valeur ASCII du caractere
    valeur=valeur–48; // extrait valeur numérique du caractere
    angleServoTilt=valeur;

     //—- extraction 2ème chiffre
    valeur=chaineReception.charAt(11); // extrait valeur ASCII du caractere
    valeur=valeur–48; // extrait valeur numérique du caractere
    angleServoTilt=angleServoTilt*10+valeur;

    //—- extraction 3ème chiffre
    valeur=chaineReception.charAt(12); // extrait valeur ASCII du caractere
    valeur=valeur–48; // extrait valeur numérique du caractere
    angleServoTilt=angleServoTilt*10+valeur;

  //Serial.print(angleServoTilt); // affiche

  if (chaineReception.substring(13,14)==« ) ») { // si fermeture parenthèse = instruction valide

    //Serial.println(F(« ) »)); // affiche
    //Serial.println(F(« Instruction valide ! »)); // affiche

    //—– positionnement du servomoteur —-

    angleServoTilt=constrain(angleServoTilt,ANGLE_MIN,ANGLE_MAX); // oblige valeur angle Servo
    mon_servoTilt.writeMicroseconds(angle(angleServoTilt)); // crée impulsion à partir valeur angle – plus précis que write()
    //angleServoTilt0=angleServoTilt; // mémorise dernière valeur angle prise en compte

    //delay(1000); // laisse temps positionnement

    //Serial.println(F(« Servomoteur mis en position »)); // affiche

  } // fin si fermeture parenthèse  

} // — fin si reçoit instruction servoTilt(000)

//—————- gestion vitesse ————————

//—– gestion servomoteur Vitesse —-
if (chaineReception.substring(0,8)==« Vitesse(« ) { // si reçoit l’instruction Vitesse
// nb substring : dernier caractere exclu

  //Serial.print(F(« Arduino va executer : « ));

  //Serial.print(F(« Vitesse(« )); // affiche

  //————- extraction valeur angle servomoteur  —— 3 chiffres

    //—- extraction 1er chiffre
    valeur=chaineReception.charAt(8); // extrait valeur ASCII du caractere
    valeur=valeur–48; // extrait valeur numérique du caractere
    vitesse=valeur;

     //—- extraction 2ème chiffre
    valeur=chaineReception.charAt(9); // extrait valeur ASCII du caractere
    valeur=valeur–48; // extrait valeur numérique du caractere
    vitesse=vitesse*10+valeur;

    //—- extraction 3ème chiffre
    valeur=chaineReception.charAt(10); // extrait valeur ASCII du caractere
    valeur=valeur–48; // extrait valeur numérique du caractere
    vitesse=vitesse*10+valeur;

  Serial.print(vitesse); // affiche

  if (chaineReception.substring(11,12)==« ) ») { // si fermeture parenthèse = instruction valide

    //Serial.println(F(« ) »)); // affiche
    //Serial.println(F(« Instruction valide ! »)); // affiche

  } // fin si fermeture parenthèse  

} // — fin si reçoit instruction Vitesse(000)

} //————- fin analyse chaine —————