// Auteur du Programme : X. HINAULT – Tous droits réservés
// Programme écrit le : 17/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 ? ———
 /* Programme pour le EeePC-Bot
 Réalise annonce vocale sur le EeePC de la distance mesurée
 par envoie chaine sur le port série.
 */

// — Fonctionnalités utilisées —

// Utilise la connexion série matérielle vers le PC
// Utilise la conversion analogique numérique 10 bits
// 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 Gauche sur la broche 4
// Connecter broche de vitesse du moteur Gauche sur la broche 5
// Connecter broche de sens du moteur Droit sur la broche 7
// Connecter broche de vitesse du moteur Droit sur la broche 6
// Broche 14 : Sortie analogique capteur GP2D12

// /////////////////////////////// 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
const int MAXI=255; // constante vitesse moteur
const int MEDIUM=127; // constante vitesse moteur

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

const int sensMoteurGauche=4; // Constante pour la broche 4
const int vitesseMoteurGauche=5; // Constante pour la broche 5
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 —

const int GP2D12=0; // Constante pour la broche analogique 0

// — Déclaration des variables globales —

int mesure_brute=0;// Variable pour acquisition résultat brut de conversion analogique numérique
float mesuref=0.0;// Variable pour calcul résultat décimal de conversion analogique numérique

int distance; // distance référence

//— tableau de valeurs en millivolts pour distance de 5 en 5cm de 10 à 80 cm pour le capteur GP2D12
// 1ère valeur a l’index 0
int calibrage[]={
2370, // 10 cm – index 0
1700, // 15 cm – index 1
1300, // 20 cm – index 2
1100, // 25 cm – index 3
950, // 30 cm – index 4
830, // 35 cm – index 5
720, // 40 cm – index 6
650, // 45 cm – index 7
580, // 50 cm – index 8
540, // 55 cm – index 9
500, // 60 cm – index 10
480, // 65 cm – index 11
450, // 70 cm – index 12
430, // 75 cm – index 13
410, // 80 cm – index 14
400, // au delà 80cm – index 15
}; // fin du tableau

// — 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 (sensMoteurGauche,OUTPUT); // Broche sensMoteurGauche configurée en sortie
 pinMode (vitesseMoteurGauche,OUTPUT); // Broche vitesseMoteurGauche configurée en sortie
 pinMode (vitesseMoteurDroit,OUTPUT); // Broche vitesseMoteurDroit configurée en sortie
 pinMode (sensMoteurDroit,OUTPUT); // Broche sensMoteurDroit configurée en sortie

//——— désactive broche 2 au cas où servomoteur connecté ——–
pinMode (2,OUTPUT); // Broche sensMoteurDroit configurée en sortie
digitalWrite(2,HIGH); // Broche au niveau bas

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

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

//mesure_brute= analogRead(broche_analogique) ; // acquisition conversion analogique numérique (100µs env.) sur broche analogique indiquée

//joueSon(« freesound_FromE.wav », true); // joue fichier son
joueSon(« freesound_Sonar_pings.ogg », true); // joue fichier son

mesuref=moyenneMesure(30, GP2D12); // réalise moyenne de 30 mesures analogiques sur voie GP2D12

distance=distanceGP2D12(mesuref); // renvoie la valeur de la distance correspondante à la valeur tension

//—– affichage du résultat ——–

if (distance==0) {// si valeur ne correspond pas au calibrage
  Serial.println(« Distance hors plage de mesure »);

  //parleSon(« Distance hors plage de mesure », false); // parle message sans attendre fin message
  parleSon(« Aucun objet détecté », true); // parle message +/- attendre fin message

}
else { // si valeur distance calculée

  Serial.print(« Distance comprise entre « ), Serial.print(distance), Serial.print( » cm et « );
  Serial.print(distance+5),Serial.println( » cm. »);

  //parleSon (« Distance comprise entre « , true), parleSon(distance,true), parleSon ( » centimètres et « , true);
  //parleSon (distance+5, true), parleSon( » centimètres. », true);

  String message;
  message=« Distance comprise entre «  + String(distance) +  » et «  + String(distance+5) +  » centimètres. »;
  parleSon(message, true); // parle message +/- attendre fin message

}

delay (1000); // entre 2 mesures

//— Code type DFRduino 1A – DFRobot 2A
//analogWrite(vitesseMoteur1,255); // génère une impulsion PWM sur la broche de vitesse du moteur
//digitalWrite(sensMoteur1,AVANT); // Marche avant
//analogWrite(vitesseMoteurGauche,255); // génère une impulsion PWM sur la broche de vitesse du moteur
//digitalWrite(sensMoteurGauche,AVANT); // Marche avant

//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 réalisant une moyenne de n mesures analogiques sur voie analogique

float moyenneMesure(int nombreMesure, int voie) { // — fonction réalisant une moyenne de n mesures analogiques

  //—- variables locales —
  int mesure_can=0;
  long cumul_can=0;
  int moyenne_can=0;
  float mesure_canf=0;

  //—– calcul d’une moyenne de plusieurs mesures ——-
 for (int i=0; i<nombreMesure; i++) // répète la mesure n fois
 {
   mesure_can=analogRead(voie);
   cumul_can=cumul_can+mesure_can;
  }

  Serial.print(« cumul= »), Serial.println(cumul_can);

  // calcul moyenne
  moyenne_can=cumul_can/nombreMesure;
  cumul_can=0; //RAZ cumul…
  Serial.print(« moyenne= »), Serial.println(moyenne_can);

  // mesure tension correspondante en mV
  mesure_canf=float(moyenne_can);
  mesure_canf=mesure_canf*5000.0;
  mesure_canf=mesure_canf/1023.0;

  Serial.print(« tension= »), Serial.println(mesure_canf);

  return (mesure_canf); // valeur renvoyée par la fonction

} // — fin fonction moyenneMesure

//————- fonction renvoyant la distance en fonction de la mesure analogique GP2D12 —-
// cette fonction est nécessaire car la sortie analogique du GP2D12 n’est pas linéaire

int distanceGP2D12(float mesure_float) {

  int dist=0; // RAZ variable locale distance

  // ——- détermination de la distance à partir du tableau de reference

  for (int j=0; j<=14; j++) { // teste les valeurs de calibrage

   if ((int(mesure_float)<=calibrage[j]) && (int(mesure_float)>calibrage[j+1])) { // si la mesure comprise entre 2 valeurs
      dist=10+(j*5); // calcule de la distance en cm à partir de l’index courant
    }
  } // fin boucle test calibrage

  return (dist); // valeur renvoyée par la fonction

} // ———– fin fonction analyse distanceGP2D12 —-

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

//—————- fonction joueSon() à partir fichier sons —-
void joueSon(String fichierSon, boolean retour) { // fonction joue son à partir nom fichier – si retour=true, attend caractère H fin son

  String envoi=« mplayer= »+fichierSon+« = »; // chaine comprise entre 2 =
  Serial.println(envoi);  //—– 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

//————- 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
} //– fin moteurDroit —

//— 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
} // — fin moteurGauche —

//— 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
} // — fin arret

//—- fonction tourne à Droite
void tourneDroite (int vitesse) {
  moteurGauche(AVANT, vitesse);
  moteurDroit(ARRIERE, vitesse);
} // fin tourneDroite

//—- fonction tourne à Gauche
void tourneGauche (int vitesse) {
  moteurGauche(ARRIERE, vitesse);
  moteurDroit(AVANT, vitesse);
} // fin tourneGauche

//—- fonction en arriere
void enArriere (int vitesse) {
  moteurGauche(ARRIERE, vitesse);
  moteurDroit(ARRIERE, vitesse);
} // fin enArriere

//—- fonction en avant
void enAvant (int vitesse) {
  moteurGauche(AVANT, vitesse);
  moteurDroit(AVANT, vitesse);
} // fin enAvant

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

// ////////////////////////// Fin du programme ////////////////////

// ////////////////////////// Mémo instructions ////////////////////
// ////////////////////////// Fin Mémo instructions ////////////////////