// — 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 : 11/4/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 ? ———
 /*
 Contrôle des moteurs et des différents mouvements (avant, arriere, stop, tourne droite, etc…)
 à partir d’une chaîne de caractères reçue sur le port série.

 Déclenche des messages vocaux en synthèse vocale
 Déclenche des bruitages sonores par lecture de fichier son

 */

// — Fonctionnalités utilisées —

// Utilise la connexion série matérielle vers le PC
// Utilise / fonctionne avec une interface Processing coté PC
// Utilise une carte d’interface moteurs CC DFRobot 2A

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

// La connexion série matérielle vers le PC utilise les broches 0 et 1 (via le câble USB)

// Connexion de l’interface DFRobot 2A Moteur CC sur les broches de la carte Arduino :
// Connecter broche de sens du moteur 1 sur la broche 4
// Connecter broche de vitesse du moteur 1 sur la broche 5
// Connecter broche de sens du moteur 2 sur la broche 7
// Connecter broche de vitesse du moteur 2 sur la broche 6

// /////////////////////////////// 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 —

// — Déclaration des constantes utiles —

const int AVANT=1; // constante sens moteur
const int ARRIERE=0; // constante sens moteur
const int STOP=0; // constante vitesse moteur

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

//— moteur 1 est le moteur Gauche
const int sensMoteur1=4; // Constante pour la broche 4
const int vitesseMoteur1=5; // Constante pour la broche 5

const int sensMoteurGauche=4; // Constante pour la broche 4
const int vitesseMoteurGauche=5; // Constante pour la broche 5

//—- moteur 2 est le moteur droit
const int vitesseMoteur2=6; // Constante pour la broche 6
const int sensMoteur2=7; // Constante pour la broche 7

const int vitesseMoteurDroit=6; // Constante pour la broche 6
const int sensMoteurDroit=7; // Constante pour la broche 7

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

// — Déclaration des variables globales —

 int octetReception=0; // variable de stockage des valeurs reçues sur le port Série
 String chaineReception=«  »; // déclare un objet String vide pour reception chaine
 String chaineTest=«  »; // déclare un objet String pour opération sur la chaine recue

int valeur=0; // variable utile
long param=0; // paramètre transmis

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

// ////////////////////////// 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(115200); // initialise connexion série matérielle à 115200 bauds
// IMPORTANT : régler le terminal côté PC avec la même valeur de transmission

// ——- Broches en sorties numériques ——-  
 pinMode (sensMoteur1,OUTPUT); // Broche sensMoteur1 configurée en sortie
 pinMode (vitesseMoteur1,OUTPUT); // Broche vitesseMoteur1 configurée en sortie
 pinMode (vitesseMoteur2,OUTPUT); // Broche vitesseMoteur2 configurée en sortie
 pinMode (sensMoteur2,OUTPUT); // Broche sensMoteur2 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 ——-  

} // 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()

//— fichiers sons espeaker disponibles :
// test_des_moteurs.wav
// stop_moteur.wav
// moteur_gauche_en_marche_avant.wav
// moteur_droit_en_marche_avant.wav
// moteur_gauche_en_marche_arriere.wav
// moteur_droit_en_marche_arriere.wav
// je_tourne_a_droite.wav
// je_recule.wav
// j_avance.wav

// — ici instructions à exécuter par le programme principal —

//—- code type réception chaine sur le port série —
while (Serial.available()>0) { // tant qu’un octet en réception
        octetReception=Serial.read(); // Lit le 1er octet reçu et le met dans la variable

        if (octetReception==10) { // si Octet reçu est le saut de ligne
                Serial.println (« Chaine recue= »+chaineReception); // affiche la chaine recue

                analyseChaine(chaineReception); // appelle la fonction d’analyse de la chaine en réception

                chaineReception=«  »; //RAZ le String de réception
                break; // sort de la boucle while
        }
        else { // si le caractère reçu n’est pas un saut de ligne
                chaineReception=chaineReception+char(octetReception); // ajoute le caratère au String
        }

} // fin tant que  octet réception

//—– une fois que le saut de ligne est reçu, on sort du While et on se positionne ici

//chaineReception= » »;

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

//while(1); // stop loop

} // 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 ////////////////////

//————- fonction d’analyse de la chaine reçue sur le port série —-

//————— testInstruction : test si instruction de la forme instruction(xxx) ————

boolean testInstruction(String chaineTest) { // reçoit chaine et renvoie true si instruction valide

  long posRef=chaineTest.length();// position de référence pour analyse (xxx)

  if (chaineReception.substring(0,posRef)==chaineTest) { // si reçoit l’instruction chaineTest(000)
  // nb substring : dernier caractere exclu

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

    Serial.print(chaineTest); // affiche

    param=stringToLong(chaineReception.substring(posRef,posRef+3)); // extraction valeur 3 chiffres à partir caractères
    Serial.print(param); // affiche

    if (chaineReception.substring(posRef+3,posRef+4)==« ) ») { // si fermeture parenthèse = instruction valide

      Serial.println(« ) »); // affiche
      Serial.println(« Instruction valide ! »); // affiche
      return(true); // renvoie true si instruction valide

    } // fin si fermeture parenthèse

    else {

      Serial.println(« Instruction invalide ! »); // affiche
      return(false); // renvoie false si instruction invalide

    } // fin else

  } // fin si reçoit l’instruction chaineTest(000)

} // fin fonction testInstruction  

//——————- fin test instruction ————

//———— analyseChaine —————
void analyseChaine(String chaineRecue) { // fonction d’analyse de la chaine recue

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

  //xxxxxxxxxxxxxxxxxxx instructions sans paramètres xxxxxxxxxxxx
  if (chaineReception==« arret() ») { // si instruction reçue
    arret(); // exécute instruction si valide
    joueSon(« r2d2_1.mp3 »,true); // joue son et attend fin son
    parleSon(« Arret des moteurs », true); //synthèse vocale de la chaine et attend fin son
  }

  //xxxxxxxxxxxxxxxxxxxx instructions avec paramètres xxxxxxxxxxxxxxx

  //————– test instruction enAvant ———–
  if (testInstruction(« enAvant(« )==true) { // si instruction reçue valide
    joueSon(« r2d2_3.mp3 »,true); // joue son et attend fin son
    parleSon(« J’avance – vitesse à « + String(int(100*param/255))+ » pour cent », true); //synthèse vocale de la chaine et attend fin son
    enAvant(param); // exécute instruction
  } // fin test enAvant(xxx)

  //————– test instruction enArriere ———–
  if (testInstruction(« enArriere(« )==true) { // si instruction reçue valide
    joueSon(« r2d2_3.mp3 »,true); // joue son et attend fin son
    parleSon(« Je recule – vitesse à « +String(int(100*param/255))+ » pour cent », true); //synthèse vocale de la chaine et attend fin son
    enArriere(param); // exécute instruction
  } // fin test enArriere(xxx)

  //————– test instruction tourne Droite ———–
  if (testInstruction(« tourneDroite(« )==true) { // si instruction reçue valide
    joueSon(« r2d2_4.mp3 »,true); // joue son et attend fin son
    parleSon(« Je tourne à droite – vitesse à « +String(int(100*param/255))+ » pour cent », true); //synthèse vocale de la chaine et attend fin son
    tourneDroite(param); // exécute instruction
  } // fin test tourneDroite(xxx)

  //————– test instruction tourne Gauche ———–
  if (testInstruction(« tourneGauche(« )==true) { // si instruction reçue valide
    joueSon(« r2d2_4.mp3 »,true); // joue son et attend fin son
    parleSon(« Je tourne à gauche – vitesse à « +String(int(100*param/255))+ » pour cent », true); //synthèse vocale de la chaine et attend fin son
    tourneGauche(param); // exécute instruction
  } // fin test tourneDroite(xxx)

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

// ———- fonction de conversion d’un String numérique en long

long stringToLong(String chaineLong) { // fonction conversion valeur numérique String en int

    long nombreLong=0; // variable locale
    int valeurInt=0; // variable locale

    for (int i=0; i<chaineLong.length(); i++) { // défile caractères de la chaine numérique

      valeurInt=chaineLong.charAt(i); // extrait le caractère ASCII à la position voulue – index 0 est le 1er caractère
      valeurInt=valeurInt–48; // obtient la valeur décimale à partir de la valeur ASCII  

     if (valeurInt>=0 && valeurInt<=9) { // si caractère est entre 0 et 9
       nombreLong=(nombreLong*10)+valeurInt;
     } // fin si caractère est entre 0 et 9

    } // fin for défile caractères

 return (nombreLong); // renvoie valeur numérique

} // ———- fin stringToLong ————

//———— fonction déclenche lecture fichier coté PC ——–
void joueSon(String fichierSon, boolean retour) { // fonction joue son à partir nom fichier – si retour=true, attend caractère H fin son

  Serial.println(fichierSon);  //—– Message série pour message sonore dans Processing

  if (retour==true) { // si doit attendre fin son
    while (Serial.available()==0); // attend arrivée d’une réponse
    while(Serial.read()!=‘H’); // attend un H renvoyé par Processing à la fin son
  } // fin if retour==true

} // —————- fin joueSon ————–

//————- fonction parleSon() pour synthèse vocale ——-
void parleSon(String texte, boolean retour) { // envoie chaine pour synthese vocale sur le port Série – si retour=true, attend caractère H fin son

  String envoi=« espeak= »+texte+« = »; // chaine comprise entre 2 =
  Serial.println(envoi);

  if (retour==true) { // si doit attendre fin son
    while (Serial.available()==0); // attend arrivée d’une réponse
    while(Serial.read()!=‘H’); // attend un H renvoyé par Processing à la fin son
  } // fin if retour==true

} // fin parle son

//————- fonctions gestion moteurs robot —————

//— fonction controle moteur Droit
void moteurDroit(int sens, int vitesse) { // sens = 0 en arriere, sens = 1 en avant,

  analogWrite(vitesseMoteurDroit,vitesse); // génère une impulsion PWM sur la broche de vitesse du moteur
  digitalWrite(sensMoteurDroit,sens); // Marche arriere

}

//— fonction controle moteur Gauche
void moteurGauche(int sens, int vitesse) { // sens = 0 en arriere, sens = 1 en avant,

  analogWrite(vitesseMoteurGauche,vitesse); // génère une impulsion PWM sur la broche de vitesse du moteur
  digitalWrite(sensMoteurGauche,sens); // Marche arriere

}

//— fonction stop = arret complet
void arret() {

  analogWrite(vitesseMoteurGauche,STOP); // génère une impulsion PWM sur la broche de vitesse du moteur
  analogWrite(vitesseMoteurDroit,STOP); // génère une impulsion PWM sur la broche de vitesse du moteur

}

//—- fonction tourne à Droite
void tourneDroite (int vitesse) {

  moteurGauche(AVANT, vitesse);
  moteurDroit(ARRIERE, vitesse);

}

//—- fonction tourne à Gauche
void tourneGauche (int vitesse) {

  moteurGauche(ARRIERE, vitesse);
  moteurDroit(AVANT, vitesse);

}

//—- fonction en arriere
void enArriere (int vitesse) {

  moteurGauche(ARRIERE, vitesse);
  moteurDroit(ARRIERE, vitesse);

}

//—- fonction en avant
void enAvant (int vitesse) {

  moteurGauche(AVANT, vitesse);
  moteurDroit(AVANT, vitesse);

}

//—- vitesse
void vitesse (int vitesse) { // modifie la vitesse sans modifier le sens

   analogWrite(vitesseMoteurGauche,vitesse); // génère une impulsion PWM sur la broche de vitesse du moteur
   analogWrite(vitesseMoteurDroit,vitesse); // génère une impulsion PWM sur la broche de vitesse du moteur
}
// ////////////////////////// Fin du programme ////////////////////