fbpx
Logo Jules LEOTON

Capteur de recul

par | Capteur de recul

Durant mon année de 1ere, mes professeurs de STI2D nous ont demandé de concevoir un capteur de recul autonome pour un véhicule qui n’en possédait pas.

Le but du projet est de concevoir un capteur de recul en respectant un cahier des charges fixé par nos professeurs qui est le suivant

Pour ce projet nous avons été regroupés en petits groupes pour former une « entreprise ». Chaque entreprise a créé une maquette qu’elle a présenté en fin de projet.

Pour la conception de cette maquette, nous avons décidé d’étudier les différents composants dont nous disposions.

Voici les exigences pour la réalisation de ce projet:

  • Détecter un obstacle avec un capteur de distance à ultra son
  • Avertir l’utilisateur de la distance avec l’obstacle en utilisant un buzzer
  • Contrôler le système avec une carte Arduino
  • Être autonome pour une durée de 240 jours minimum à raison d’une utilisation de 5 min par jour
  • Pouvoir couper et remettre l’alimentation avec un interrupteur
  • Le boîtier du système doit être composé de 2 pièces maximum et avoir un volume totale de 550 cm3.

Certaines contraintes ne sont pas dans le cahier des charges car nos professeurs nous les ont imposé car ils ne disposaient que de ces composants ci.

Nous avons commencé par faire une maquette sur un site WEB (Tinkercad).

Montage simulé sur Tinkercad

Dans cette simulation, qui à pour but de faire un premier essai tout en ne détériorant pas les composants, on retrouve les contraintes principales du cahier des charges.

Dans le simulateur, on peut envoyer un programme dans la carte programmable Arduino.

On retrouve en première partie du code l’initialisation des variables et des PIN utilisés pour les différents éléments du système.

#define Broche_Echo 7     # PIN du capteur ultra son
#define Broche_Trigger 8  # PIN du capteur ultra son
int MesureMaxi = 300;     # Distance maximale en cm du capteur ultra son
int MesureMini = 3;       # Distance minimale en cm du capteur ultra son
int buzzer = 6;           # PIN du buzzer
int time_buzzer_on = 250; # Initialisation de la durée durant la quelle le buzzer est allumé
int time_off = 0;         # Initialisation de la durée durant la quelle le buzzer est éteint
long Duree;               # Initialisation de la variable utilisé pour calculer la distance entre le capteur et l'obstacle
long Distance;            # Initialisation de la variable où est stoker la valeur de la distance

La seconde partie du programme est les boucles setup et loop.

La boucle setup soit void setup permet de configurer les différents capteurs.

La boucle loop soit void loop est la boucle qui est exécutée en permanence.

void setup(){
  pinMode(Broche_Trigger,OUTPUT);  # Configuration du PIN Trigger en mode sortie de donnée
  pinMode(Broche_Echo,INPUT);      # Configuration du PIN Echo en mode entré de donnée
  pinMode(buzzer, OUTPUT);         # Configuration du PIN buzzer en mode sortie de donnée
  Serial.begin(9600);              # Configuration de la vitesse du moniteur série à 9600
}
void loop(){
  capteur();                       # Fait appelle à la boucle nommé capteur
  set_time_off();                  # Fait appelle à la boucle nommé set_time_off
  l_buzzer();                      # Fait appelle à la boucle nommé l_buzzer
}

La troisième partie regroupe les différents sous programmes

le premier sous programme est le capteur qui fonctionne avec le code suivant 

void capteur(){
  
  digitalWrite(Broche_Trigger,LOW);      # Désactivation du capteur ultra son
  delayMicroseconds(2);                  # Attente de 2 micro seconde
  
  digitalWrite(Broche_Trigger,HIGH);     # Activation du capteur ultra son
  delayMicroseconds(10);                 # Attente de 10 micro seconde
  digitalWrite(Broche_Trigger,LOW);      # Désactivation du capteur ultra son
  
  Duree = pulseIn(Broche_Echo, HIGH);    # Stockage de la variable de la durée entre l'envoie de l'ultra son et la réception de l'ultra son
  
  Distance=Duree*0.034/2;                # Calcule de la distance entre le capteur et l'obstacle en utilisant la variable duree défini ci-dessus
  
  if(Distance>=MesureMaxi||Distance<=MesureMini){                         # Si la valeur de la variable Distance est en dehors de la plage de données
    Serial.println("Distance de mesure en dehors de la plage demander");  #       Alors affiché dans le moniteur série "Distance de mesure en dehors de la plage demander"
  }
  else{                                                                   # Si non Affiché la valeur de la mesure.
    Serial.print("Distance mesuree :");
    Serial.print(Distance);
    Serial.println("cm");
  }
  delay(0);
}

Le seconde sous programme est l’intervalle entre chaque sonnerie du buzzer

void set_time_off()
{
  if(Distance>=100 && Distance<=150)     # Si la distance en comprise entre 1,50m et 1m (150cm et 100cm)
  {
    time_off = 3000;                     # Alors mètre la valeur de l'intervalle du buzzer à 3s (3000 milli seconde)
  }
  
  if(Distance>=50 && Distance<=100)      # Si la distance en comprise entre 1m et 0,50m (100cm et 50cm)
  {
    time_off = 2000;                     # Alors mètre la valeur de l'intervalle du buzzer à 2s (2000 milli seconde)
  }
  
  if(Distance>=25 && Distance<=50)       # Si la distance en comprise entre 0,50m et 0,25m (50cm et 25cm)
  {
    time_off = 1000;                     # Alors mètre la valeur de l'intervalle du buzzer à 1s (1000 milli seconde)
  }
  
  if(Distance>=12 && Distance<=25)       # Si la distance en comprise entre 0,25m et 0,12m (25cm et 12cm)
  {
    time_off = 800;                      # Alors mètre la valeur de l'intervalle du buzzer à 0,8s (800 milli seconde)
  }
  
  if(Distance>=5 && Distance<=12)        # Si la distance en comprise entre 0,12m et 0,05m (12cm et 5cm)
  {
    time_off = 500;                      # Alors mètre la valeur de l'intervalle du buzzer à 0,5s (500 milli seconde)
  }
  
  if(Distance>=0 && Distance<=5)         # Si la distance en comprise entre 0,05m et 0m (5cm et 0cm)
  {
    time_off = 0;                        # Alors mètre la valeur de l'intervalle du buzzer à 0s (0 milli seconde)
  }
}

Le troisième sous programme est le buzzer

void l_buzzer(){
  digitalWrite(buzzer, HIGH);  # Allumer le Buzzer
  delay(time_buzzer_on);       # Sonner durant 0,25 seconde
  digitalWrite(buzzer, LOW);   # Éteindre la Buzzer
  delay(time_off);             # Attendre l'intervalle prévue par la boucle ci-dessus
}

Voici le programme complet :

#define Broche_Echo 7
#define Broche_Trigger 8
int MesureMaxi = 300;
int MesureMini = 3; 
int buzzer = 6;
int time_buzzer_on = 250;
int time_off = 0;
long Duree;
long Distance;
void setup(){
  pinMode(Broche_Trigger,OUTPUT);
  pinMode(Broche_Echo,INPUT);
  pinMode(buzzer, OUTPUT);
  Serial.begin(9600);
}
void loop(){
  capteur();
  set_time_off();
  l_buzzer();
}
void capteur(){
  
  digitalWrite(Broche_Trigger,LOW);
  delayMicroseconds(2);
  
  digitalWrite(Broche_Trigger,HIGH);
  delayMicroseconds(10);
  digitalWrite(Broche_Trigger,LOW);
  
  Duree = pulseIn(Broche_Echo, HIGH);
  
  Distance=Duree*0.034/2;
  
  if(Distance>=MesureMaxi||Distance<=MesureMini){
    Serial.println("Distance de mesure en dehors de la plage demander");
  }
  else{
    Serial.print("Distance mesuree :");
    Serial.print(Distance);
    Serial.println("cm");
  }
  delay(0);
}
void set_time_off()
{
  if(Distance>=100 && Distance<=150)
  {
    time_off = 3000;
  }
  
  if(Distance>=50 && Distance<=100)
  {
    time_off = 2000;
  }
  
  if(Distance>=25 && Distance<=50)
  {
    time_off = 1000;
  }
  
  if(Distance>=12 && Distance<=25)
  {
    time_off = 800;
  }
  
  if(Distance>=5 && Distance<=12)
  {
    time_off = 500;
  }
  
  if(Distance>=0 && Distance<=5)
  {
    time_off = 0;
  }
}
void l_buzzer(){
  digitalWrite(buzzer, HIGH);
  delay(time_buzzer_on);
  digitalWrite(buzzer, LOW);
  delay(time_off);
}