Besoin désespéré d'aide pour connection Arduino - TelAndroid

Bonsoir,

Je me manifeste aujourd’hui car je suis en grand besoin d’aide sur mon projet de Sciences de l’Ingénieur de Terminale S.
Le projet est le suivant : une canne pour aveugle intelligente.
Celle-ci fonctionne grâce à des capteurs à ultrasons qui envoient des distances à l’Arduino qui ensuite sont interprétées pour envoyer des valeurs dans un vibreur.
En gros plus un obstacle est proche plus le vibreur vibre fort.
Il y a 3 télémètres à ultrasons et 3 vibreurs associés (gauche, droite, centre).
Toute cette partie fonctionne à peu près.
La deuxième fonctionnalité de cette canne est une connexion de la canne à un téléphone Android via le module bluetooth de l’arduino (HC-06) et l’application est crée via MIT App Inventor.
Cette application est basique, un menu de connexion bluetooth (“Se Connecter”) un bouton de déco (“Se Déconnecter”) un texte de statut de connexion et enfin un gros bouton.
Ce gros bouton est censé envoyer un “1” à la carte Arduino pour être associé à la variable “variable_tel” qui va ensuite faire sonner une alarme.
L’objectif est donc de faire sonner l’alarme grâce au téléphone pour retrouver sa canne facilement.

Voilà le problème : je n’arrive pas à faire lire la valeur envoyée par l’application à la carte Arduino.
J’ai réalisé de nombreux test et aucun ne donne quelque chose. J’ai d’ailleurs ajouté un “vérifieur” au code pour savoir d’où vient le problème, de la variable envoyée par le tel ou le “if” pour faire sonner l’alarme. Je constate donc que le problème vient de la variable envoyée par le Tel.

Je vous envois mon code ci-joint, la partie concernée est intitulée “BLUETOOTH” et “EXECUTION DE L’ALARME

//IMPORTATIONS

#include <SoftwareSerial.h>
#include <NewPing.h>
#define RxD 2
#define TxD 1
SoftwareSerial HC06(RxD,TxD);

//DECLARATIONS

const unsigned long Mesure_time = 25000UL;
const float Sound_Speed = 340.0 / 1000;
int trigc = 12; // entree module telemetre centre
int echoc = 11; // retour module telemetre centre
int trigd = 10; // entree module telemetre droite
int echod = 9; // retour module telemetre droite
int trigg = 8; // entree module telemetre gauche
int echog = 7; // retour module telemetre gauche
long lecture_echoc; // temps aller/retour 1 
long lecture_echod; // temps aller/retour 2
long lecture_echog; // temps aller/retour 3
long cmc; // distance obstacle/telemetre 1
long cmd; // distance obstacle/telemetre 2
long cmg; // distance obstacle/telemetre 3
int icviber = 6; // vibreur centre
int idviber = 5; // vibreur droite
int igviber = 3; // vibreur gauche
int vibrationc = 0; // vitesse de vibration centre
int vibrationg = 0; // vitesse de vibration gauche
int vibrationd = 0; // vitesse de vibration droite
int alarme = 13; // alarme
int alarme_state = 0; // état de l'alarme (1 = allumé / 0 = éteint)
int valeur_tel;

//CONFIGURATION INITIALE

void setup() {
  Serial.begin(115200);
  
  pinMode(trigc, OUTPUT); 
  digitalWrite(trigc, LOW); 
  pinMode(echoc, INPUT); 
  
  pinMode(trigd, OUTPUT); 
  digitalWrite(trigd, LOW); 
  pinMode(echod, INPUT);
  
  pinMode(trigg, OUTPUT); 
  digitalWrite(trigg, LOW); 
  pinMode(echog, INPUT);

  pinMode(alarme,OUTPUT);
}

//COEUR DU PROGRAMME

void loop() {

  //CALCUL DE DISTANCE PAR TELEMETRE
  
  digitalWrite(trigc, HIGH); //envoie du signal par le télémètre
  delayMicroseconds(10); 
  digitalWrite(trigc, LOW); //arret du signal par le télémètre
  lecture_echoc = pulseIn(echoc, HIGH, Mesure_time); //lecture du temps d'écart du signal par le télémètre
  float cmc = lecture_echoc / 2.0 * Sound_Speed; //calcul de la distance en millimètre du signal du telemetre
  
  digitalWrite(trigd, HIGH); //envoie du signal par le télémètre
  delayMicroseconds(10); 
  digitalWrite(trigd, LOW); //arret du signal par le télémètre
  lecture_echod = pulseIn(echod, HIGH, Mesure_time); //lecture du temps d'écart du signal par le télémètre
  float cmd = lecture_echod / 2.0 * Sound_Speed; //calcul de la distance en millimètre du signal du telemetre
   
  digitalWrite(trigg, HIGH); //envoie du signal par le télémètre
  delayMicroseconds(10); 
  digitalWrite(trigg, LOW); //arret du signal par le télémètre
  lecture_echog = pulseIn(echog, HIGH, Mesure_time); //lecture du temps d'écart du signal par le télémètre
  float cmg = lecture_echog / 2.0 * Sound_Speed; //calcul de la distance en millimètre du signal du telemetre

  //VARIABLE DE LA VITESSE DES VIBREURS
  
  if (10 < cmc < 2000)
  { 
    if (cmc < 1000)
    {
      if (cmc < 500)
      {
        vibrationc = 100 ;
      }
      else
      {
        vibrationc = 80 ;
      }
    }
    else
    {
      vibrationc = 60 ;
    }
  }
  else
  {
    vibrationc = 0 ;
  }

  if (10 < cmd < 2000)
  { 
    if (cmd < 1000)
    {
      if (cmd < 500)
      {
        vibrationd = 100 ;
      }
      else
      {
        vibrationd = 80 ;
      }
    }
    else
    {
      vibrationd = 60 ;
    }
  }
  else
  {
    vibrationd = 0 ;
  }
  
  if (10 < cmg < 2000)
  { 
    if (cmg < 1000)
    {
      if (cmg < 500)
      {
        vibrationg = 100 ;
      }
      else
      {
        vibrationg = 80 ;
      }
    }
    else
    {
      vibrationg = 60 ;
    }
  }
    else
  {
    vibrationg = 0 ;
  }

  //EXECUTION DES VIBREURS
  
  analogWrite(icviber , vibrationc);
  analogWrite(igviber , vibrationg);
  analogWrite(idviber , vibrationd);
  delay(100);
  analogWrite(icviber , 0);
  analogWrite(igviber , 0);
  analogWrite(idviber , 0);

  //*BLUETOOTH*

  if(Serial.available()>0)
  {
    valeur_tel = Serial.read();
    Serial.println("Valeur Tel = "); //voilà le test pour vérifier d'où viens l'erreur, si dans le moniteur je vois "valeur tel = X" cela veut dire que le if est passé, or il ne s'affiche pas...
    Serial.println(valeur_tel);
  }

  //*EXECUTION DE L'ALARME*

  if (alarme_state == 0 && valeur_tel == '1')
  {
    digitalWrite(alarme,HIGH);
 
    alarme_state=1;
    valeur_tel=1;  
  }
  if (alarme_state ==1 && valeur_tel == '1')
  {
    digitalWrite(alarme,LOW);
    alarme_state=0;
    valeur_tel=0;
  }
  
  //AFFICHAGE MONITEUR SERIE
  
  Serial.println("centre :");
  Serial.println(cmc/1000);
  Serial.println("droite :");
  Serial.println(cmd/1000);
  Serial.println("gauche :");
  Serial.println(cmg/1000);
  Serial.println(" ");

  delay(100);

}

J’ai aussi ajouté le fichier en pièce jointe.

Voilà maintenant l’application:

et le code:

Voilà je vous remercie de m’avoir lu jusqu’au bout (ouf!) et j’éspère que vous pourriez me dire ce qui ne va pas dans mon code. A savoir que nous sommes deux à l’avoir écrit et aussi que j’ai découvert la programmation arduino en même temps que j’ai débuté ce projet.

Merci :slight_smile:

PPE_prgm_version_finale_BT.ino (4.43 KB)

hello
vous utilisez la lib softwareserial

regardez dans "fichiers", "exemples", "softwareserial",et ouvrez"softwareserialexemple"
vous verrez la façon dont on utilise une liaison serie avec cette lib
vous utilisez pour cette liaison les pinoches 1 et 2
ce n'est pas judicieux car vous ne pouvez plus utiliser la liaison habituelle pour visualiser sur le moniteur.
ensuite, vous appelez votre softwareserial "HC06"
il faut donc un begin pour cette liaison serie: HC06.begin(9600) je ne suis pas sur que 115200 soit bien pour une liaison bluetooth

et enfin dans votre boucle inserez:
if(HC06.available() > 0) {
char valeur_tel = HC06.read();
}

je ne peux que vous encourager à regarder les deux exemples de la librairie softwareserial

à vous de faire vos essais

euh…

  if(Serial.available()>0)
  {
    valeur_tel = Serial.read();
    Serial.println("Valeur Tel = "); //voilà le test pour vérifier d'où viens l'erreur, si dans le moniteur je vois "valeur tel = X" cela veut dire que le if est passé, or il ne s'affiche pas...
    Serial.println(valeur_tel);
  }

vous utilisez Serial et pas votre Software Serial HC06… Outre la remarque pertinente sur les pins utilisées pour le Software Serial, ce que vous écoutez là c’est la console arduino

Attention quand ça marchera vous envoyez le nombre entier (sous forme d’octet) 1 et pas le caractère ‘1’, faudra en tenir compte dans votre test

Notez aussi que ce genre test ne fait pas ce que vous croyez…  if (10 < cmc < 2000)…je vous laisse chercher pourquoi

Merci pour vos conseils!

Je suis actuellement en train de modifier le programme en conséquence je vous tiens au courant des résultats.

J-M-L:
Notez aussi que ce genre test ne fait pas ce que vous croyez…  if (10 < cmc < 2000)…je vous laisse chercher pourquoi

est ce qu’au lieu d’écrire " if (10 < cmc < 2000)" je devrais plutôt écrire “if (cmc >10 && cmc < 2000)” ?

Ça fonctionne!!!
Merci pour vos conseils!

voilà le nouveau code:

//IMPORTATIONS

#include <SoftwareSerial.h>
#include <NewPing.h>
#define RxD 2
#define TxD 1
SoftwareSerial HC06(RxD,TxD);

//DECLARATIONS

const unsigned long Mesure_time = 25000UL;
const float Sound_Speed = 340.0 / 1000;
int trigc = 12; // entree module telemetre centre
int echoc = 11; // retour module telemetre centre
int trigd = 10; // entree module telemetre droite
int echod = 9; // retour module telemetre droite
int trigg = 8; // entree module telemetre gauche
int echog = 7; // retour module telemetre gauche
long lecture_echoc; // temps aller/retour 1 
long lecture_echod; // temps aller/retour 2
long lecture_echog; // temps aller/retour 3
long cmc; // distance obstacle/telemetre 1
long cmd; // distance obstacle/telemetre 2
long cmg; // distance obstacle/telemetre 3
int icviber = 6; // vibreur centre
int idviber = 5; // vibreur droite
int igviber = 3; // vibreur gauche
int vibrationc = 0; // vitesse de vibration centre
int vibrationg = 0; // vitesse de vibration gauche
int vibrationd = 0; // vitesse de vibration droite
int alarme = 13; // alarme
int alarme_state = 0; // état de l'alarme (1 = allumé / 0 = éteint)
int valeur_tel;

//CONFIGURATION INITIALE

void setup() {
  Serial.begin(115200);
  HC06.begin(9600);
  
  pinMode(trigc, OUTPUT); 
  digitalWrite(trigc, LOW); 
  pinMode(echoc, INPUT); 
  
  pinMode(trigd, OUTPUT); 
  digitalWrite(trigd, LOW); 
  pinMode(echod, INPUT);
  
  pinMode(trigg, OUTPUT); 
  digitalWrite(trigg, LOW); 
  pinMode(echog, INPUT);

  pinMode(alarme,OUTPUT);
}

//COEUR DU PROGRAMME

void loop() {

  //CALCUL DE DISTANCE PAR TELEMETRE
  
  digitalWrite(trigc, HIGH); //envoie du signal par le télémètre
  delayMicroseconds(10); 
  digitalWrite(trigc, LOW); //arret du signal par le télémètre
  lecture_echoc = pulseIn(echoc, HIGH, Mesure_time); //lecture du temps d'écart du signal par le télémètre
  float cmc = lecture_echoc / 2.0 * Sound_Speed; //calcul de la distance en millimètre du signal du telemetre
  
  digitalWrite(trigd, HIGH); //envoie du signal par le télémètre
  delayMicroseconds(10); 
  digitalWrite(trigd, LOW); //arret du signal par le télémètre
  lecture_echod = pulseIn(echod, HIGH, Mesure_time); //lecture du temps d'écart du signal par le télémètre
  float cmd = lecture_echod / 2.0 * Sound_Speed; //calcul de la distance en millimètre du signal du telemetre
   
  digitalWrite(trigg, HIGH); //envoie du signal par le télémètre
  delayMicroseconds(10); 
  digitalWrite(trigg, LOW); //arret du signal par le télémètre
  lecture_echog = pulseIn(echog, HIGH, Mesure_time); //lecture du temps d'écart du signal par le télémètre
  float cmg = lecture_echog / 2.0 * Sound_Speed; //calcul de la distance en millimètre du signal du telemetre

  //VARIABLE DE LA VITESSE DES VIBREURS
  
  if (10 < cmc < 2000)
  { 
    if (cmc < 1000)
    {
      if (cmc < 500)
      {
        vibrationc = 100 ;
      }
      else
      {
        vibrationc = 80 ;
      }
    }
    else
    {
      vibrationc = 60 ;
    }
  }
  else
  {
    vibrationc = 0 ;
  }

  if (10 < cmd < 2000)
  { 
    if (cmd < 1000)
    {
      if (cmd < 500)
      {
        vibrationd = 100 ;
      }
      else
      {
        vibrationd = 80 ;
      }
    }
    else
    {
      vibrationd = 60 ;
    }
  }
  else
  {
    vibrationd = 0 ;
  }
  
  if (10 < cmg < 2000)
  { 
    if (cmg < 1000)
    {
      if (cmg < 500)
      {
        vibrationg = 100 ;
      }
      else
      {
        vibrationg = 80 ;
      }
    }
    else
    {
      vibrationg = 60 ;
    }
  }
    else
  {
    vibrationg = 0 ;
  }

  //EXECUTION DES VIBREURS
  
  analogWrite(icviber , vibrationc);
  analogWrite(igviber , vibrationg);
  analogWrite(idviber , vibrationd);
  delay(100);
  analogWrite(icviber , 0);
  analogWrite(igviber , 0);
  analogWrite(idviber , 0);

  //BLUETOOTH

  if(HC06.available()>0)
  {
    valeur_tel = HC06.read();
  }

  //EXECUTION DE L'ALARME

  if (alarme_state == 0 && valeur_tel == '1')
  {
    digitalWrite(alarme,HIGH);
    delay(500);
    digitalWrite(alarme,LOW);
    delay(500);
    digitalWrite(alarme,HIGH);
    delay(500);
    digitalWrite(alarme,LOW);
    delay(500);
    digitalWrite(alarme,HIGH);
    delay(500);
    digitalWrite(alarme,LOW);

    alarme_state=1;
    valeur_tel=1;  
  }
  if (alarme_state ==1 && valeur_tel == '1')
  {
    digitalWrite(alarme,LOW);
    alarme_state=0;
    valeur_tel=0;
  }
  
  //AFFICHAGE MONITEUR SERIE
  
  Serial.println("centre :");
  Serial.println(cmc/1000);
  Serial.println("droite :");
  Serial.println(cmd/1000);
  Serial.println("gauche :");
  Serial.println(cmg/1000);
  Serial.println(" ");

  delay(100);

}

je suis en train de voir pour l’encadrement de cmc

Attention aussi à la double utilisation du pin 1 pour Serial(pin 0 et 1) et SoftwareSerial (pin 2 et 1).

Dans ton cas, le pin 1 est utilisé pour transmettre sur les 2 liaisons séries.

merci! mais je ne vois pas comment faire, je vais voir avec mon groupe sur cette double utilisation des pin

voilà le code final

/////////////////////////IMPORTATION////////////////////////

#include <SoftwareSerial.h>
#include <NewPing.h>
#define RxD 2
#define TxD 1
SoftwareSerial HC06(RxD,TxD);

/////////////////////////DECLARATION////////////////////////

const unsigned long Mesure_time = 25000UL;
const float Sound_Speed = 340.0 / 1000;
int trig_c = 12; // entree module telemetre centre
int echo_c = 11; // retour module telemetre centre
int trig_d = 10; // entree module telemetre droite
int echo_d = 9; // retour module telemetre droite
int trig_g = 8; // entree module telemetre gauche
int echo_g = 7; // retour module telemetre gauche
long lecture_echo_c; // temps aller/retour 1 
long lecture_echo_d; // temps aller/retour 2
long lecture_echo_g; // temps aller/retour 3
long cm_c; // distance obstacle/telemetre 1
long cm_d; // distance obstacle/telemetre 2
long cm_g; // distance obstacle/telemetre 3
int viber_c = 6; // vibreur centre
int viber_d = 5; // vibreur droite
int viber_g = 3; // vibreur gauche
int vibration_c = 0; // vitesse de vibration centre
int vibration_g = 0; // vitesse de vibration gauche
int vibration_d = 0; // vitesse de vibration droite
int alarme = 13; // alarme
int alarme_state = 0; // état de l'alarme (1 = allumé / 0 = éteint)
int valeur_tel;

///////////////////CONFIGURATION INITIALE///////////////////

void setup() {
  Serial.begin(115200);
  HC06.begin(9600); // le bluetooth est plus efficace sur du 9600 que sur du 115200

  ////////////////INITIALISATION DES TELEMTRES////////////////
  
  pinMode(trig_c, OUTPUT); 
  digitalWrite(trig_c, LOW); 
  pinMode(echo_c, INPUT); 
  
  pinMode(trig_d, OUTPUT); 
  digitalWrite(trig_d, LOW); 
  pinMode(echo_d, INPUT);
  
  pinMode(trig_g, OUTPUT); 
  digitalWrite(trig_g, LOW); 
  pinMode(echo_g, INPUT);

  pinMode(alarme,OUTPUT);
}

/////////////////////COEUR DU PROGRAMME/////////////////////

void loop() {

  ///////////////CALCUL DE DISTANCE PAR TELEMETRIE/////////////
  
  digitalWrite(trig_c, HIGH); //envoie du signal par le télémètre
  delayMicroseconds(10); 
  digitalWrite(trig_c, LOW); //arret du signal par le télémètre
  lecture_echo_c = pulseIn(echo_c, HIGH, Mesure_time); //lecture du temps d'écart du signal par le télémètre
  float cm_c = lecture_echo_c / 2.0 * Sound_Speed; //calcul de la distance en millimètre du signal du telemetre
  
  digitalWrite(trig_d, HIGH); //envoie du signal par le télémètre
  delayMicroseconds(10); 
  digitalWrite(trig_d, LOW); //arret du signal par le télémètre
  lecture_echo_d = pulseIn(echo_d, HIGH, Mesure_time); //lecture du temps d'écart du signal par le télémètre
  float cm_d = lecture_echo_d / 2.0 * Sound_Speed; //calcul de la distance en millimètre du signal du telemetre
   
  digitalWrite(trig_g, HIGH); //envoie du signal par le télémètre
  delayMicroseconds(10); 
  digitalWrite(trig_g, LOW); //arret du signal par le télémètre
  lecture_echo_g = pulseIn(echo_g, HIGH, Mesure_time); //lecture du temps d'écart du signal par le télémètre
  float cm_g = lecture_echo_g / 2.0 * Sound_Speed; //calcul de la distance en millimètre du signal du telemetre

  /////////////VARIABLE DE LA VITESSE DES VIBREURS////////////
  // les vibreurs tournent à des intensité définies selon des intervalles en fonction de la distance
  
  if (cm_c > 50 && cm_c < 2000) // test de distance telemetre centre
  { 
    if (cm_c < 1000)
    {
      if (cm_c < 500)
      {
        vibration_c = 100 ; //obstacle à proche distance
      }
      else
      {
        vibration_c = 80 ; // obstacle à moyenne distance
      }
    }
    else
    {
      vibration_c = 20 ; // obstacle à forte distance
    }
  }
  else
  {
    vibration_c = 0 ;
  }

  if (cm_d > 50 && cm_d < 2000) // test de distance telemetre droite
  { 
    if (cm_d < 1000)
    {
      if (cm_d < 500)
      {
        vibration_d = 100 ; //obstacle à proche distance
      }
      else
      {
        vibration_d = 80 ; // obstacle à moyenne distance
      }
    }
    else
    {
      vibration_d = 20 ; // obstacle à forte distance
    }
  }
  else
  {
    vibration_d = 0 ;
  }
  
  if (cm_g > 50 && cm_g < 2000) // test de distance telemetre gauche
  { 
    if (cm_g < 1000)
    {
      if (cm_g < 500)
      {
        vibration_g = 100 ; //obstacle à proche distance
      }
      else
      {
        vibration_g = 80 ; // obstacle à moyenne distance
      }
    }
    else
    {
      vibration_g = 20 ; // obstacle à forte distance
    }
  }
    else
  {
    vibration_g = 0 ;
  }

  ///////////////////EXECUTION DES VIBREURS///////////////////
  // on fait tourner les vibreurs à l'intensité définie précedemment
  analogWrite(viber_c , vibration_c);
  analogWrite(viber_g , vibration_g);
  analogWrite(viber_d , vibration_d);
  delay(100);
  analogWrite(viber_c , 0);
  analogWrite(viber_g , 0);
  analogWrite(viber_d , 0);

  //////////////////////////BLUETOOTH/////////////////////////

  if(HC06.available()>0) // HC06 renvoie au module Bluetooth, cette ligne lit la dernière valeur envoyée par Bluetooth et si celle-ci est supérieure à 0 la condition est remplie
  {
    valeur_tel = HC06.read(); // on associe la valeur envoyée par le téléphone à cette variable pour ensuite passer à la partie suivante
  }

  ////////////////////EXECUTION DE L'ALARME///////////////////

  if (alarme_state == 0 && valeur_tel == '1') // activation de l'alarme si condition remplie
  {
    digitalWrite(alarme,HIGH); // sonnerie de l'alarme : elle sonne 3 fois, les vibreurs s'arretent lorsque l'alarme sonne
    delay(500);
    digitalWrite(alarme,LOW);
    delay(500);
    digitalWrite(alarme,HIGH);
    delay(500);
    digitalWrite(alarme,LOW);
    delay(500);
    digitalWrite(alarme,HIGH);
    delay(500);
    digitalWrite(alarme,LOW);

    alarme_state=1;
    valeur_tel=1;  
  }
  if (alarme_state ==1 && valeur_tel == '1') // désactivation de l'alarme si condition remplie
  {
    digitalWrite(alarme,LOW);
    alarme_state=0;
    valeur_tel=0;
  }
  
  //////////////////AFFICHAGE MONITEUR SERIE//////////////////
  
  Serial.println("centre :");
  Serial.println(cm_c/1000);
  Serial.println("droite :");
  Serial.println(cm_d/1000);
  Serial.println("gauche :");
  Serial.println(cm_g/1000);
  Serial.println(" ");

  delay(100);

}

Garder 0 et 1 pour Serial
Utiliser 2 et 3 pour SoftwareSerial