int nombre_mesure=100; // nombre de mesure à réaliser pour le moyennage
int cumul=0; // variable pour cumul des mesures
int moyenne; // variable calcul de la moyenne

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
 

float anglef=0.0; // variable angle tracé rayon courant
float rayonf=80.0; // rayon du cercle
int xo=87; // abscisse point référence
int yo=20; // ordonnée point référence

float xf=0.0; // abscisse point calculé à virgule
float yf=0.0; // ordonnée point calculé à virgule

int x=0; // abscisse point calculé
int y=0; // ordonnée point calculé

int couleur=vert; // variable couleur tracé
 

// test de l’afficheur
lcd.clear(RGB(255,0,0)); // efface ecran en rouge
delay (1000); // pause
lcd.clear(RGB(0,255,0)); // efface ecran en vert
delay (1000); // pause
lcd.clear(RGB(0,0,255)); // efface ecran en bleu
delay (1000); // pause
lcd.clear(noir); // efface ecran en noir
 

//  Code sous licence GNU GPL :
//  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/>.
//  

// — Que fait ce programme ? —
/* radar de détection d’objet présent entre 10 et 80cm
à l’aide d’un capteur GP2D12 monté sur un servomoteur
avec affichage sur écran couleur S65 */

// — Fonctionnalités utilisées —
// Utilise un afficheur TFT 65536 couleurs Graphique 132×176 type S65
// Utilise la conversion analogique numérique 10bits sur les voies analogiques  analog 0,
// Utilise un ou plusieurs servomoteurs

// — Circuit à réaliser —
// Le module S65 Shield est à enficher directement broche à broche  
// sur la carte Arduino réalisant ainsi les connexions suivantes :
// Ecran graphique S65 TFT contrôlé par 5 broches :
//      > broche S65_DAT du module sur la broche 11 de la carte Arduino
//      > broche S65_CLK du module sur la broche 13 de la carte Arduino
//      > broche S65_RS du module sur la broche 4 de la carte Arduino
//      > broche S65_RST du module sur la broche 17 de la carte Arduino
//      > broche S65_CS du module sur la broche 16 de la carte Arduino

// Broche Analog 0 (=broche 14) en entrée Analogique  : connecter la sortie analogique du capteur de distance GP2D12
// Connecter  sur la broche 15 (configurée en sortie) la broche de commande du servomoteur

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

// — Inclusion des librairies utilisées —

#include <S65Display.h> // Inclusion de la librairie pour afficheur TFT couleur S65

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

// — Déclaration des constantes —

//——— constantes pour le servomteur ———-
const int POS_MIN=500; // largeur impulsion pour position 0° servomoteur
                       // POS_MIN=550 pour futaba S3003
const int POS_MAX=2400; // largeur impulsion pour position 180° servomoteur
                                                 // POS_MAS=2330 pour futaba s3003

// — constantes des broches —

const int GP2D12=0; //declaration constante de broche analogique
const int SERVO_GP2D12=15; //declaration constante de broche

// — Déclaration des variables globales —

//——- variables globales pour le capteur distance ——-
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 nombre_mesure=100; // nombre de mesure à réaliser pour le moyennage
int cumul=0; // variable pour cumul des mesures
int moyenne; // variable calcul de la moyenne

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

//——— variables globales servomoteur ————–

int angle_servo=0; // variable pour angle du servomoteur

//——— variables globales tracé radar ————-

float anglef=0.0; // variable angle tracé rayon courant
float rayonf=80.0; // rayon du cercle
int xo=87; // abscisse point référence
int yo=20; // ordonnée point référence

float xf=0.0; // abscisse point calculé à virgule
float yf=0.0; // ordonnée point calculé à virgule

int x=0; // abscisse point calculé
int y=0; // ordonnée point calculé

int couleur=vert; // variable couleur tracé

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

S65Display lcd; // Création d’un objet afficheur S65 appelé lcd

Servo mon_servo;  // crée un objet servo pour contrôler le servomoteur

//**************** 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 au démarrage —

lcd.init(4); // initialise l’afficheur TFT couleur S65 avec communication SPI à Fosc/4 = 4 Mhz

// test de l’afficheur
lcd.clear(RGB(255,0,0)); // efface ecran en rouge
delay (1000); // pause
lcd.clear(RGB(0,255,0)); // efface ecran en vert
delay (1000); // pause
lcd.clear(RGB(0,0,255)); // efface ecran en bleu
delay (1000); // pause
lcd.clear(noir); // efface ecran en noir

// ——- Broches en sortie ——-  

// attache l’objet servo à la broche de commande du servomoteur
mon_servo.attach(SERVO_GP2D12, POS_MIN, POS_MAX);  

// ——- Broches en entrée ——-  

// ——- Activation du rappel au + interne des broches en entrée si nécessaire ——-  

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

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

//—- initialise position du servomteur  et efface écran ——-
  lcd.clear(noir); // efface ecran en noir
  mon_servo.write(0); // positionne le servo à la position 0
  delay(1000); // temps suffisant pour retour

//——- défilement des angles et mesure distance + tracé ——-
  for (angle_servo=0; angle_servo<=180;angle_servo++) { //défilement des degrés

    //— positionnement servomoteur
    mon_servo.write(angle_servo); // positionne le servo à l’angle voulu

    delay(10);

//—– mesure de la distance ——–

  //—– calcul d’une moyenne de plusieurs mesures ——-
  for (int i=0; i<nombre_mesure; i++) // répète la mesure
  {
    mesure_brute=analogRead(GP2D12);
    cumul=cumul+mesure_brute;
  }

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

  // calcul moyenne des mesures
  moyenne=cumul/nombre_mesure;
  cumul=0; //RAZ cumul…
  //Serial.print(« moyenne= »), Serial.println(moyenne);

  // mesure tension correspondante en mV
  mesuref=float(moyenne);
  mesuref=mesuref*5000.0;
  mesuref=mesuref/1023.0;

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

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

  //distance=0; // RAZ distance

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

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

  } // fin boucle test calibrage

  //—– prise en compte du résultat ——–

  rayonf=float(distance);

//—– tracé rayon sur écran couleur —    

  // calcul de l’angle en radians
    anglef = float(angle_servo);
    anglef=anglef*3.14159;
    anglef=anglef/180.0;

    //— calcul x
    xf= cos(anglef);
    xf=rayonf*xf;
    x=int(xf);

    //— calcul y
    yf= sin(anglef);
    yf=rayonf*yf;
    y=int(yf);

    lcd.drawLine(xo,131–yo, xo+x, 131–yo–y, couleur); // trace la ligne du rayon pour angle courant

} //—- fin boucle angle —

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

//*************** Autres Fonctions du programme *************

// — Fin programme —