HC-05: RX-TX LEVEL 3.3v: résistance?

Vous m'avez bien fait flipper hier. Un truc qui marche pas, personne sur mon post, et hop, maintenant c'est le bar du coin ^^
Alors plutôt que de chercher partout les versions de Linux, je pense ouvrir un post, peut-être plutôt dans le bar, ça m'évitera un kick ^^
Ouais tiens, je lance un sujet au bar: LINUX: à vos souhaits? (pas trouvé mieux j'ai mal dormi)

NON en fait ça marche pas...
Si je lui dis de récupérer la variable en int, ce petit malin récupère la valeur ASCII

#include<SoftwareSerial.h>

#define TxD 3
#define RxD 2
#define LED_PIN 13

SoftwareSerial bluetoothSerial(TxD, RxD);

int c;//hmmm ya un truc qui cloche, notez qu'un partie du code est entre /* */

void setup() {
  bluetoothSerial.begin(9600);
  Serial.begin(9600);
  pinMode(LED_PIN, OUTPUT);
  }

void loop() {
  if(bluetoothSerial.available()){
    c = bluetoothSerial.read();
    Serial.println(c);
    /*if(c=='1'){
      digitalWrite(LED_PIN, HIGH);          
    }
    if(c=='0'){
      digitalWrite(LED_PIN, LOW);
    }*/
    for (int i=0; i<c; i++) {
      digitalWrite(LED_PIN, HIGH); 
      delay(50);
      digitalWrite(LED_PIN, LOW);
      delay(150);}
    }
  }

Et voici ce qu'affiche le moniteur quand j'envoie '3' depuis mon smartphone:

51
13
10

51, ok, c'est l'ASCII... le reste je sais pas.

Est-il possible de récupérer autre chose que de l'ASCII?

Oui, 51 c'est le code ASCII de 3 (en décimal) :
Apprends cette table par coeur, ça t'aidera pour plus tard !
13 c'est CR et 10 LF : ça correspond à '\n'

Donc tu fais :
c = bluetoothSerial.read() - '0';et tu obtiendras bien un 3 dans ton float.

Et c'est parfait !
Merci

Ci-jointe la preuve

Trop mignon !
Tu mettras des feuilles d'eucalyptus à côté des olives au prochain apéro ?

lesept:
Trop mignon !
Tu mettras des feuilles d'eucalyptus à côté des olives au prochain apéro ?

Bien arrosé, tout passe!

Pour que ça fonctionne avec un float, il faut ruser.
Si on envoie 6.4, il prend 6 puis 4, avec virgule ou point.
Suffit de virer l'entier et de décaler les décimales, ça va...

Je reviens de loin, merci encore à tous,
Je pense même faire un tuto, parce que c'est pas compliqué, mais quand ça marche pas c'est chiant...

Oui, le tuto c'est une bonne idée, car la gestion des communication série est un peu complexe, et il y a plein de cas différents.

Notez qu'il y a déjà des tutos côté anglais :

kammo:
Pour que ça fonctionne avec un float, il faut ruser.
Si on envoie 6.4, il prend 6 puis 4, avec virgule ou point.
Suffit de virer l'entier et de décaler les décimales, ça va...

Il y a aussi parseFloat :

Serial.parseFloat() returns the first valid floating point number from the Serial buffer. 
Characters that are not digits (or the minus sign) are skipped. 
parseFloat() is terminated by the first character that is not a floating point number.

Tu peux tester ?

Je pige pas ce que c'est, ni à quoi ça sert.
Ca me fait Ultrasonic robot head - Tête de robot ultrasons - YouTube

C'est mignon, avec des oreilles il ressemblerait presque à un koala...

parseFloat va faire comme parseInt mais avec un float : il va écouter la liaison série et te fournir le premier truc qui ressemble à un float, automatiquement.

Hmmm j'avais pas compris

Allez, dernier épisode?

J'ai ajouté une commande depuis mon smartphone en bluetooth pour changer la variable VitMax.

J'ai ajouté des gros delay() pour voir ce que dit le moniteur série:

110 <- ca c'est VitMax avant la commande bluetooth
110
110
110
110
110
BlueData = 11 <----- en effet j'envoie bien '11' avec mon telephone
BlueData = 00 <---- ça je sais pas
BlueData = -35221 <-- ça non plus et il met un peu de temps à le construire
BlueData = -38218 <-- la même
218 <----on retrouve la variable VitMax qui devrait faire 11
218
218

Je joins le code:
Comme c'est en développement, il y a encore des petits bouts que je n'ai pas supprimés, ça permet de revenir en arrière si un problème survient:

//Bluetooth
#include<SoftwareSerial.h>
#define TxD 3
#define RxD 2
int BlueData;
SoftwareSerial bluetoothSerial(TxD, RxD);

//L293d, définition des pins
#define E1 9     // PWM 1  /noir
#define E2 10    // PWM 2  /blanc
#define I1 12    // 1 a    /vert
#define I2 4     // 1 b    /bleu
#define I3 7     // 2 a    /mauve
#define I4 8     // 2 b    /gris

//Variables moteurs
byte VitMax = 110;   // bride PWM 0-255
byte Vitmin = 0;
byte VitG = 70;     // vitesse au départ moteur gauche <VitMax
byte VitD = 70;     // vitesse au départ moteur droit  <VitMax


//Définition des pins de capteurs IR GG-GC-CC-CD-DD
#define IR0 15  // capteur IR GG sur A0
#define IR1 16  // capteur IR GC sur A1
#define IR2 17  // capteur IR CC sur A2
#define IR3 18  // capteur IR CD sur A3
#define IR4 19  // capteur IR DD sur A4

int LastDir; //stocke la dernière direction lue valide -1/0/1
int B=0; //switcher


//************************************************

void setup() {
  bluetoothSerial.begin(9600);

  Serial.begin(9600);

  //Mode des pins du L293d
  pinMode(E1, OUTPUT);
  pinMode(E2, OUTPUT);
  pinMode(I1, OUTPUT);
  pinMode(I2, OUTPUT);
  pinMode(I3, OUTPUT);
  pinMode(I4, OUTPUT);



}//fin de setup
//************************************************


void loop() {
  
//bluetooth
if(bluetoothSerial.available()){
BlueData = bluetoothSerial.read() - '0';
Serial.print("BlueData = ");
Serial.print(BlueData);
VitMax = BlueData;
delay(1500);
}
delay(1000);

  Serial.println(VitMax);
  
  CreerB();
  Switcher();
  MarcheAvant();
}
//************************************************


int CreerB() {//change Err en fonction des capteurs
  boolean b0, b1, b2, b3, b4;
  //Construire un bit avec les booléens du tableau
  b0 = (digitalRead(IR0) == HIGH);
  b1 = (digitalRead(IR1) == HIGH);
  b2 = (digitalRead(IR2) == HIGH);
  b3 = (digitalRead(IR3) == HIGH);
  b4 = (digitalRead(IR4) == HIGH);
  B = 0;

  B = (b4 ? B10000 : B0) | (b3 ? B1000 : B0) | (b2 ? B100 : B0) | (b1 ? B10 : B0) | (b0 ? B1 : B0) ;
}

void Switcher() {

  // Retranscrire sous la forme B00000
  //Serial.print(F("B"));
  //for (int8_t aBit = 4; aBit >= 0; aBit--)
  // Serial.print(bitRead(B, aBit) == 0 ? F("0") : F("1"); //

  switch (B) {
    case 27://11011
      VitD = VitMax;
      VitG = VitMax;
      LastDir = 0;
      break;
    //vers la gauche
    case 25://11001
      VitD = VitMax;
      VitG = VitMax * 0.85;
      //LastDir = -1;
      break;
    case 29://11101
      VitD = VitMax;
      VitG = VitMax * 0.5;
      LastDir = -1;
      break;
    case 28://11100
      VitD = VitMax * 0.75;
      VitG = VitMax * 0.25;
      LastDir = -1;
      break;
    case 30://11110
      VitD = VitMax * 0.5;
      VitG = 0;
      LastDir = -1;
      break;
    //vers la droite
    case 19:
      VitD = VitMax * 0.85;
      VitG = VitMax;
      //LastDir = 1;
      break;
    case 23:
      VitD = VitMax * 0.5;
      VitG = VitMax;
      LastDir = 1;
    case 7:
      VitD = Vitmin * 0.25;
      VitG = VitMax * 0.75;
      LastDir = 1;
      break;
    case 15:
      VitD = 0;
      VitG = VitMax * 0.5;
      LastDir = 1;
      break;

    case 3: //angle droit à D
      VitD = 0;
      VitG = VitMax * 0.25;
      LastDir = 1;
      break;

    case 24: //angle droit à G
      VitD = VitMax * 0.25;
      VitG = 0;
      LastDir = -1;
      break;

    case 31: //tout blanc
      ImLost(LastDir);
      break;

  }//fin de switch
}//fin de Switcher()


//************************************************

void MarcheAvant() {
  //marche avant
  digitalWrite(I1, HIGH);  //Av D
  digitalWrite(I2, LOW);   //Ar D
  digitalWrite(I3, HIGH);  //Av G
  digitalWrite(I4, LOW);   //Ar G}

  digitalWrite(E1, VitD);
  digitalWrite(E2, VitG);

 }//fin de MarcheAvant
//************************************************

void ImLost(int dir) {
  digitalWrite(E2, 0);
  digitalWrite(E1, 0);

  switch (dir) {
    case -1: //pivoter gauche

      digitalWrite(E1, 60);
      break;
    case 1:

      digitalWrite(E2, 60);
      break;
    case 0:
      digitalWrite(I1, LOW);  //Av D
      digitalWrite(I2, HIGH);   //Ar D
      digitalWrite(I3, HIGH);  //Av G
      digitalWrite(I4, LOW);   //Ar G
      digitalWrite(E2, 60);
      digitalWrite(E1, 60);
      break;
  }
  while (B==31){
    CreerB();
    Serial.println(B);
  }
}

Donc ma question est: mais qu'est-ce qu'il fout? C'est quoi ces deux nombres étranges qui apparaissent, et qu'est-ce qui s'ajoute à ma variable???

Je pense que c'est les delay qui foutent le boxon. Qu'est ce qui t'assure qu'il n'y a pas de données qui arrivent pendant le temps où le microcontrôleur attend ?

lesept:
Qu'est ce qui t'assure qu'il n'y a pas de données qui arrivent pendant le temps où le microcontrôleur attend ?

Moi m'sieur, je n'envoie qu'une donnée, d'où viennent les autres?
J'ai mis des delay pour pouvoir lire tout ça sur moniteur, ça défilait vraiment trop vite, mais le problème est antérieur aux delay()

Je t'ai mis un lien vers un tuto écrit par un membre du forum quelque part. Lis le (je n'ai pas un full accès à internet ici donc je ne peux pas t'aider beaucoup) il indique de mettre des caractères supplémentaires avant et après tes données, genre a11b pour dire
a = attention je vais envoyer une donnée, tu es prêt ?
11
b = fin des données, tu peux traiter.
Avec ça, le parseFloat devrait être à l'aise

Bon
J'ai pas trouvé ce tuto
C'est pas normal de devoir rajouter des trucs et des machins
J'ai trouvé un autre tuto
sensé piloter un servo via bluetooth

Bien entendu, dans la video ça marche...
J'ai pas installé l'appli MIT, j'ai tenté de piloter en direct avec l'appli que j'ai sur smartphone, et ca marche juste carrément pas du tout.
Le servo tourne une fois et reste bloqué à forcer comme un crétin
J'ai essayé avec l'appli du gars, ça marche nickel.

Je soupçonne:
-soit le hc05 d'être sacrément de la merde
-soit mon appli d'envoyer des séries de bêtises au lieu d'envoyer une valeur

Comme ça fait trois jours que ça me prend la tête, je suis tenté d'aller acheter une cartouche de gaz et faire tout ça au chalumeau...

https://forum.arduino.cc/index.php?topic=396450.0

C'est en lisant ce tuto que j'ai réussi à faire marcher une liaison BT entre un téléphone et un nano équipé d'un module HC05. J'ai posté mes codes dans la section projets terminés, sujet horloge infinie.

C'est le seul cas de communication BT que j'ai réalisé.

Bon. Il est bien ce tuto pour qui sait de quoi il parle.

L'air de rien, je ne trouve aucune info sur ce qu'il veut faire. Apparemment, il fait communiquer le moniteur d'IDE avec un module bluetooth. Chapeau, sans montage ni définition de pins.

Sur la méthode de décodage, c'est fortiche, mais pas possible pour un débutant comme moi de claquer son code dans une carte arduino et de lancer quoique ce soit.

Encore une fois, il n'explique rien sur l'apairage. Chez moi, winmerde définit deux ports com: 6 et 7.
L'un servant à recevoir, l'autre à émettre. Donc pas possible de faire les deux à la fois.

Wincrétin me dit qu'il est couplé mais le module clignote à toute blinde: il ne l'est pas.

Soyons clairs:
-le hc05 ne marche PAS sous windows, à moins de maîtriser à donf, c'est pas mon cas
-ça marche avec des appli android toutes faites mais aucune idée de ce qu'elles envoient réellement.

DONC:
Je vais devoir décortiquer son code et l'implanter dans le mien qui utilise une bibliothèque.
Ca va me prendre la journée, c'est sûr. Je suis obligé de passer par des applis sans la moindre idée de comment elles sont faites. J'ai bien essayé le truc du MIT, mais on peut même pas le démarrer, faut créer des comptes et entrer des codes. Si ça marche pas, je laisse tomber.

Je reviens dès que j'ai un truc qui marche........ on peut rêver, c'est pas cher.