View  Edit  Attributes  History  Attach  Print  Search

ACCUEIL | ARDUINO > S'INSTALLER > DEBUTER > APPROFONDIR | PROCESSING | MECATRONIQUE | MATERIEL | OUTILS | TESTS | Plus...|
Python > Shell > ATELIERS Python + Qt > PyQt apps > PyQt+Arduino | Mes Robots | RepRap | Mes lib'Arduino | Mes shields Arduino | Mes distros | Les Mini-PC |
ATELIERS ARDUINO| VIDEOS | COMPRENDRE | REFERENCES | CODER | TECHNIQUE | GNU/LINUX | LIENS | Rien à voir |

"Radar" de distance à capteur GP2D12 monté sur servomoteur et affichage sur écran couleur S65

ARDUINO - SERVOMOTEUR - CAN
Par X. HINAULT - Créé le 02/05/2010

1.  Présentation

Ce programme réalise un 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 TFT 132x176 pixels (module S65 shield). Le servomoteur parcourt successivement les positions entre 0° et 180° : pour chaque angle, une mesure de distance est effectuée grâce au capteur GP2D12 et le résultat est affiché sous forme graphique sur l'écran couleur d'un module S65 shield.

Ce programme utilise les fonctionnalités suivantes :

  • Utilise un afficheur TFT 65536 couleurs Graphique 132x176 type S65
  • la conversion analogique numérique 10bits sur les voies analogiques analog 0,
  • un ou plusieurs servomoteurs

2.  Matériel Nécessaire

2.1  L'espace de développement Arduino

  • ... pour éditer, compiler le programme et programmer la carte Arduino.

2.2  Le matériel suivant pour réaliser le montage associé

  • des straps,
  • un servomoteur type S3003 de Futaba ou équivalent
  • un module avec afficheur couleur TFT 176x132

Acheté ici ( 35 Euros TTC seulement !) : http://www.watterott.com/en/Arduino-S65-Shield
Documentation ici : Module d'affichage à écran couleur Arduino S65 shield
Librairie pour afficheur TFT couleur S65

  • un kit de dédoublement des broches de la carte Arduino avec borniers à vis

Acheté ici (8 Euros TTC env.) : http://www.watterott.com/en/Arduino-Screw-Shield

  • un capteur de distance analogique GP2D12

3.  Instructions de montage

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

4.  Le schéma théorique du montage


Le schéma théorique du montage

5.  Le circuit du montage


Le schéma du montage à réaliser

6.  Explication du programme

6.1  Structure globale du programme

Ce programme simple comprend :

  • une entête déclarative
  • une partie « configuration » qui ne sera exécutée qu'une fois (fonction setup( ) )
  • une partie constituée d'une boucle sans fin que le programme répètera à l'infini ( fonction loop( ) ) : c'est le coeur du programme.

6.2  Déroulement du programme

Le programme se déroule de la façon suivante :

  • Après avoir pris en compte les instructions de la partie déclarative,
  • puis après avoir exécuté la partie configuration ( fonction setup( ) ),
  • le programme bouclera sans fin ( fonction loop ( ) ), exécutant de façon répétée le code compris dans la boucle sans fin.

Le déroulement du programme

7.  Au niveau de la partie déclarative :

Inclusion des librairies utilisées

  • On inclut les librairies des fonctionnalités utilisées :
    • Inclusion de la librairie pour l'afficheur TFT couleur S65 :
#include <S65Display.h> // Inclusion de la librairie pour afficheur TFT couleur S65
  • Inclusion de la librairie pour les servomoteurs :
#include <Servo.h> // librairie pour servomoteur

Déclaration de constantes utiles

  • On déclare les constantes utiles dans le programme :
    • Déclaration des constantes utiles pour les servomoteurs :
const int POS_MIN=550; // largeur impulsion pour position 0° servomoteur
                       // POS_MIN=550 pour futaba S3003
const int POS_MAX=2330; // largeur impulsion pour position 180° servomoteur
                                                 // POS_MAS=2330 pour futaba s3003

Déclaration des constantes de broches

  • Déclaration des constantes pour les broches utilisées dans le programme :
const int GP2D12=0; //declaration constante de broche analogique
const int SERVO_GP2D12=15; //declaration constante de broche

Déclaration des variables globales

  • Déclaration des variables globales utiles pour le capteur GP2D12 :
//------- 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
 
  • Déclaration des variables globales utiles pour le servomoteur :
int angle_servo=0; // variable pour angle du servomoteur
  • Déclaration des variables globales utiles pour le tracé graphique :

//--------- 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éclarations des objets utiles pour les fonctionnalités utilisées

  • Déclaration des objets utiles pour les fonctionnalités utilisées :
    • Déclaration d'un objet afficheur TFT couleur S65 :

S65Display lcd; // Création d'un objet afficheur S65 appelé lcd
 
  • Déclaration d'un objet servomoteur

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

8.  Au niveau de la fonction d'initialisation setup( ) :

Initialisation des fonctionnalités utilisées :

  • On initialise les différentes fonctionnalités utilisées :
    • Initialisation de l'afficheur TFT couleur S65
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
 
  • Initialisation du servomoteur
// attache l'objet servo à la broche de commande du servomoteur
mon_servo.attach(SERVO_GP2D12, POS_MIN, POS_MAX);

9.  Au niveau de la boucle principale, la fonction loop ( ) :

  • Au sein d'une boucle principale, on assure le défilement des angles de 0° à 180°
  • Pour chaque angle, on réalise une mesure de la distance en moyennant 100 mesures successives
  • On affiche pour l'angle courant le résultat sous forme graphique : la longueur du rayon tracé est proportionnel à la distance mesurée.
  • Le programme recommence en boucle les instructions de la fonction loop( ).

Se reporter aux commentaires présents dans le programme pour plus de détails.

10.  Mise en oeuvre du programme

10.1  Préparation du montage et programmation de la carte Arduino :

  • Commencer par réaliser le montage indiqué sur plaque d'expérimentation
  • Ensuite, programmer la carte Arduino avec ce programme (en bas de page) selon la procédure habituelle

10.2  Fonctionnement

  • Le servomoteur positionne le capteur GP2D12 successivement dans les positions allant de 0° à 180°.
  • L'écran affiche un demi-cercle coloré correspondant à ce que le capteur de distance "voit" réalisant un mini-radar de distance.

11.  Le programme complet en langage Arduino - version 1 :

A copier/coller directement dans l'éditeur Arduino


 // --- Programme Arduino ---
// Copyright X. HINAULT - Créé le 02/05/2010
// www.mon-club-elec.fr

//  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 132x176 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 ---