Probleme de lecture des valeurs entrantes du HC-05 Bluetooth Modul

Salut a tous

j ’ ai développé une application Android qui me permet de communiquer avec un petit robot via Hc-05 Bluetooth Modul ou est monté un arduino Uno . Le robot peut fonctionner en deux modes (mode manuel , mode automatique)

Le principe est le suivant :

mode automatique :

  • Lorsque le robot reçoit le caractère (char = 7) , le robot doit rouler a une vitesse de 40cm/s

mode contrôle :

  • Lorsque le robot reçoit la valeur (char =0) , le robot doit pouvoir s’ arrêter pour être ensuite diriger selon l’utilisateur .

Mon problème est le suivant :
Comment faire pour que mon Arduino reconnaisse les valeurs entrantes quand il est dans le while loop (mode automatique) ?
Ci-joint egalement une image de mon “serial monitor” .

Merci.

#include "TimerOne.h"


#include <SimpleTimer.h>

#include <SoftwareSerial.h>

SoftwareSerial BTSerial(10, 11); // CONNECT BT RX PIN TO ARDUINO 11 PIN | CONNECT BT TX PIN TO ARDUINO 10 PIN

SimpleTimer timer;

SimpleTimer timercheck;

volatile char check ;
volatile char newx ;
// Left Motor Pin
#define pinIN1 8
#define pinIN2 12
#define pinENA 6 // doit être une pin PWM 

// Right Motor Pin
#define pinIN3 13
#define pinIN4 4
#define pinENB 5  // doit être une pin PWM 

//Ultraschallsensor PIN
#define trigger 9 // Arduino Pin an HC-SR04 Trig 
#define echo  7 // Arduino Pin an HC-SR04 Echo 

// distance
volatile long distance = 30;

// Radius of wheel in cm
const int radius = 3.325  ;

// number of tick in the
const float pas = 20.0 ;

// Interrupt
unsigned volatile int pulse_link = 0; // variable accessible dans la routine interruption externe 0
unsigned volatile int pulse_right = 0;


volatile int PWM_right = 0;
volatile int PWM_left = 0;
volatile  double speed_right ;
volatile  double speed_link ;
volatile  double vit ;
volatile  double erreur;

// reference value
double reference_value = 20.0;//cm/s
double umfang = 20.72;

// init calculs asservissement PID
double lasterror_right = reference_value; // (en cm/s)
double summeerror_right = 0;

// left Motor
double lasterror_left = reference_value; // (en cm/s)
double summeerror_left = 0;
//Definition des constantes du correcteur PID
double kp = 0.2253;           // Coefficient proportionnel  0.2253

double ki = 6.284;              // Coefficient intégrateur 2   6.284
double kd = 0 ;          // Coefficient dérivateur 1

// duree d asservissement
double time_asservissement = 25; // millisseconde

int timerregelung;
int timercontrol;
double dt = time_asservissement / 1000 ; // seconde

double interrupt_check =100;

int speedleft_output;

int speedright_output;

void stop_vehicule();
void pulseright();
void pulseleft();
void ISR_timerone();
void asservissement();
int getdistance();

void forward();
void turn_right();
void back();
void turn_left();
//int checking( );
int checking();

void setup() {
  Serial.begin(9600);
  BTSerial.begin(9600);

  void sendtoapp();


  // declaration of Inputs/outputs
  pinMode(pinIN1, OUTPUT);
  pinMode(pinIN2, OUTPUT);
  pinMode(pinENA, OUTPUT);
  pinMode(pinIN3, OUTPUT);
  pinMode(pinIN4, OUTPUT);
  pinMode(pinENB, OUTPUT);
  pinMode(trigger, OUTPUT);
  digitalWrite(trigger, LOW);
  delayMicroseconds(3);
  pinMode(echo, INPUT);

  Timer1.initialize(1000000);


  attachInterrupt(1, pulseright, RISING);  //speed right
  attachInterrupt(0, pulseleft, RISING);  // Speed Link



  timer.setInterval(time_asservissement, asservissement);

  timercheck.setInterval(interrupt_check, checking);

  

}

void loop() {// put your main code here, to run repeatedly:

  if (BTSerial.available () > 0)
 {   
char data;
data = BTSerial.read();            // lire le caractere entrant
Serial.println(data);

while ((data == '7'))             //   [b]Ici il entre en mode automatique si data =7[/b];
    {
      
  Timer1.detachInterrupt();
  reference_value= 40; 
  distance = getdistance();

  check = BTSerial.read();    [b] // Ici j essaye de voir si une valeur est entrante (Mon soucis est a ce niveau)[/b]
  Serial.println( check);
     
       if (check == '0')          // Dans le cas ou c est 0 j arrête le véhicule
      {
    
    stop_vehicule();
   
   }


  
  if (distance >= 20)
      {
         timer.run();
        
      }

  if (distance<=20)
      {
        stop_vehicule();
      }


  }
   


 

  }


}








/******* Motor Control Start  ********/
void forward() {
  analogWrite(pinENA, 100);
  digitalWrite(pinIN1, false);
  digitalWrite(pinIN2, true);
  analogWrite(pinENB, 100);
  digitalWrite(pinIN3, false);
  digitalWrite(pinIN4, true);
  
}


void stop_vehicule() {

  analogWrite(pinENA, 0);
  digitalWrite(pinIN1, true);
  digitalWrite(pinIN2, false);
  analogWrite(pinENB, 0);
  digitalWrite(pinIN3, true);
  digitalWrite(pinIN4, false);

}

/******* Motor Control End  ********/


/******* Interrupt Function start ********/
void pulseleft() {// la fonction appelée par l'interruption externe n°0
  pulse_link = pulse_link + 1; // Incrémente la variable de comptage

}

void pulseright() {// la fonction appelée par l'interruption externe n°1
  pulse_right = pulse_right + 1; // Incrémente la variable de comptage

}

/******* Interrupt Function end ********/


/******* Distance measure start ********/
int getdistance()
{
  long zeit = 0;
  noInterrupts();

  // Lance une mesure de distance en envoyant une impulsion HIGH de 10µs sur la broche TRIGGER *
  digitalWrite(trigger, HIGH); //Trigger Impuls 10 us
  delayMicroseconds(10);
  digitalWrite(trigger, LOW);


  zeit = pulseIn(echo, HIGH); // Echo-Zeit messen
  interrupts();
  zeit = (zeit / 2); // Zeit halbieren
  distance = zeit / 29.1; // Zeit in Zentimeter umrechnen
  return (distance);
  //interrupts();
}


/******* Motor control speed measure ********/
void ISR_timerone()
{
  Timer1.detachInterrupt();  // Stop the timer

  double rotation_link = ((double)pulse_link / pas) ;     // calculate RPS for Motor 1 tour/s
  int speed_link = ((int)umfang) * ((int)rotation_link);
  double rotation_right = ((double)pulse_right / pas) ;   // calculate RPS for Motor 1 tour/s
  int speed_right = ((int)umfang) * ((int)rotation_right);




  pulse_link = 0; //  reset counter to zero
  pulse_right = 0;

  Timer1.attachInterrupt(ISR_timerone);  // Enable the timer
}



void asservissement() {

  //noInterrupts();
  int left = pulse_link;
  int right = pulse_right;

  noInterrupts();
  // reinitialisation de mon tick de la codeuse
  pulse_link = 0; //  reset counter to zero
  pulse_right = 0;
  interrupts();

  double rotation_link = ((double)left/pas) / dt ; // vitesse du moteur gauche en tour/s
  int speed_link = ((int)umfang)* ((int)rotation_link); // cm /s
  double rotation_right = ((double)right / pas) / dt ; // vitesse du moteur droit en  1 tour/s
  int speed_right = ((int)umfang) * ((int)rotation_right);


if ((speedleft_output != speed_link) || (speedright_output != speed_right))
  {

    //BTSerial.print("#");
    BTSerial.print('#');
    BTSerial.print(' ');
    BTSerial.print(speed_link);
    BTSerial.print(' ');
    BTSerial.print(speed_right);
    BTSerial.print(' ');
    BTSerial.println('~');
}

  speedleft_output = speed_link ;
  speedright_output = speed_right;

  /******* Régulation PID Motor right ********/
  double error_right = reference_value - speed_right;
  summeerror_right = summeerror_right + error_right;
 PWM_right = (kp * error_right  + ki * summeerror_right*dt ) ;

  /******* Régulation PID ********/

  /******* Régulation PID Motor left ********/
  double error_left = reference_value - speed_link;
  summeerror_left = summeerror_left + error_left ;
  PWM_left = (kp * error_left + ki * summeerror_left*dt ) ;

  /******* Régulation PID ********/


  if (PWM_left > 255) {
    PWM_left = 255; // sachant que l'on est branché sur un pont en H L298
  }
  else if (PWM_left < 0) {
    PWM_left = 0;
  }

  if (PWM_right > 255) {
    PWM_right = 255;  // sachant que l'on est branché sur un pont en H L298
  }
  else if (PWM_right < 0) {
    PWM_right = 0;
  }

  // PWM ausgeben
  vorne_right(PWM_right);
  vorne_link(PWM_left);

}

Tu trouveras les bases de ce que tu cherches ici

Bonjour,

Vous avez deux variables pour la réception des données, data et check mais a aucun moment vous avez prévu la sortie du mode automatique, il faudrait faire quelque chose comme ça:

if (check == '0') // Dans le cas ou c est 0 j arrête le véhicule
{

data='\0' ; pour sortir du mode automatique.
stop_vehicule();

}