Oui c’est vrai et avec 20 trames par secondes c’est effectivement un peu risqué
Pour le code dans ce cas c’est bon
Assurez vous que tous les GND soient connectés et que tous les appareils sont en 5V (j’imagine que l’arduino est un MEGA)
Tout est correct, j'ai verifier avec la console série [au moins le branchement read du capteur ] et jai les memes data que sur le Uno
Exact
Je ne connaissais pas le concept... mais je pense qu'on pourait hacker sur ce principe... en faisant un programme qui incremente le baud rate sur serial1 et 2 et l'affiche sur la console serie => quand le dispositif hôte reconais la trame et affiche des donnée cest que que le rate affiché est le bon.
Il faudrait des delais d'au moins quelques seconde pour que ce soit lissible...
Ca peut prendre beaucoup de temps surtout si on est sur une vitesse pas standard [que j'ai deja tester] !
Est-ce fonctionnel avec l’arduino entre les deux ? Ça voudrait dire effectivement que 9600 est le bon débit
Sinon il existe de technique pour l’auto baud mais ici on peut se contenter de passer en revue (avec un begin et un end) différentes configs et écouter pour voir si on reçoit le préambule de 2 octest et un checksum fonctionnel. Si oui on a le bon débit.
Si le capteur marche directement quand il est branché sur l’appareil c’est que les 2 sont configurés des manière identique
Non justement l'hote ne percoit pas le signal.
Faut essayer en changeant les bauds
Essaye ça
On visualise les échanges sur Serial
On peut changer le débit avec + et -
? permet de faire afficher le débit en cours
long baudrate[]={1200, 2400, 4800, 9600, 19200, 38400, 57600, 115200};
int8_t baudIndex = 3;
uint8_t nbBaud = sizeof(baudrate)/ sizeof(long);
void setup() {
Serial1.begin(9600); //9600 selon doc
Serial2.begin(9600);
Serial.begin(115200);
}
void loop() {
uint8_t data;
if (Serial1.available()) {
data = Serial1.read();
Serial2.write(data);
Serial.print("(1)");Serial.println(data, HEX);
}
if (Serial2.available()) {
data = Serial2.read();
Serial1.write(data);
Serial.print("(2)");Serial.println(data, HEX);
}
if (Serial.available()){
data = Serial.read();
switch(data){
case '+':
baudIndex++;
if (baudIndex >= nbBaud) baudIndex = 0;
Serial1.begin(baudrate[baudIndex]);
Serial2.begin(baudrate[baudIndex]);
Serial.print(baudrate[baudIndex]);Serial.println( "bauds/s");
break;
case '-':
baudIndex++;
if (baudIndex < 0) baudIndex = nbBaud - 1;
Serial1.begin(baudrate[baudIndex]);
Serial2.begin(baudrate[baudIndex]);
Serial.print(baudrate[baudIndex]);Serial.println( "bauds/s");
break;
case '?':
Serial.print(baudrate[baudIndex]);Serial.println( "bauds/s");
break;
}
}
}
Code non testé je n'ai rien sous la main pour faire l'essai
éventuellement rajouter un
Serial.flush(); // vide le buffer de sortie
Serial1.end(); // vide le buffer d'entrée sur Serial1
Serial2.end(); // vide le buffer d'entrée sur Serial2
avant de refaire les begin() avec le nouveau débit. ça vide les buffers.
et un petit
default: break;
dans le switch ne gâcherait rien
et les baud rates devraient être des unsigned long (c'est ce qu'attend begin) et un index dans un tableau devrait être unsigned donc plutôt uint8_t baudIndex = 3; mais ça mettrait le bazar dans la soustraction mais comme le code n'est pas bon.. au lieu de
case '-':
baudIndex++;
if (baudIndex < 0) baudIndex = nbBaud - 1;
il faut
case '-':
if (baudIndex == 0) baudIndex = nbBaud - 1;
else baudIndex--;
juste pour la forme
Je suis d'accord sur le reste mais pas sur ce point
Bon évidemment la doc de référence ne colle pas avec les déclarations de la librairie HardwareSerial.
A la réflexion, il ne faut changer la vitesse que sur Serial1 qui est l'inconnue pas sur Serial2.
si quand on connecte directement le capteur à l'hôte ça fonctionne, c'est que les deux sont réglés sur le même débit ou que l'hôte fait de l'auto-bauding donc on peut les conserver synchronisés
ce qui serait intéressant à voir aussi c'est s'il y a une séquence de handshake. est-ce que l'hôte envoie un message au capteur pour l'activer ou le configurer par exemple ?
capturer le trafic sur Rx et Tx avec un sniffer adéquat serait sans doute la prochaine étape utile
Un petit anayseur logique ferait l'affaire, utilsé avec , comme logiciel, Logic de Saleae ou Pulseview/Sigrok et leurs décodeurs
oui c'est à cela que je pensais
sinon à tester aussi en connectant le capteur sur Serial1
le code imprime le flux de données et attend 21 octets dans une trame qui commence par 0x55AA et vérifie le cksum.
si aucune trame ne s'affiche c'est que 0x55AA n'est jamais reçu.
changer le débit en modifiant à la main le débit et recompilation + upload
constexpr unsigned long debit = 9600; // essayez 2400, 4800, 9600, 14400, 19200, 38400, 57600, 115200
si après avoir testé l'ensemble des débits il n'y a rien qui semble donner 0x55AA et un cksum correct, alors retourner à 9600 bauds et regarder s'il y a deux octets successifs qui ont l'air de revenir souvent et tester avec ceux là comme marqueurs de débit de trame....
(non testé)
// ------------
// A CONFIGURER
// ------------
#define RS232 Serial1
constexpr unsigned long debit = 9600; // essayez 2400, 4800, 9600, 14400, 19200, 38400, 57600, 115200
constexpr uint8_t longueurTrame = 21; // au total avec les 2 marqueurs de début de trame et le checksum final
constexpr uint8_t flag1 = 0x55;
constexpr uint8_t flag2 = 0xAA;
// ------------
uint8_t frame[longueurTrame - 2]; // on ne conserve pas les 2 marqueurs de début de trame (flag1 et flag2)
uint8_t checkSum(const uint8_t trame[], size_t n) {
uint8_t cksum = 0;
for (size_t index = 0; index < n; index++) cksum += trame[index];
return ~cksum + 1;
}
void printByteInfo(const byte b, bool ascii = false) {
Serial.print(F("0x"));
if (b < 0x10) Serial.write('0');
Serial.print(b, HEX);
if (ascii && isprint(b)) {
Serial.print(F("('"));
Serial.write(b);
Serial.print(F("')"));
}
}
void printFrame(const uint8_t trame[], size_t n) {
Serial.print(F("\n\nTrame reçue : "));
for (uint8_t index = 0; index < n; index++) {
if (index % 8 == 0) Serial.print(F("\n\t"));
printByteInfo(trame[index]);
Serial.write(' ');
}
Serial.println();
uint8_t ck = checkSum(trame, n);
Serial.print(F("\n->Le CKSUM calculé est"));
printByteInfo(ck);
Serial.print(F(" --> il est "));
Serial.println((ck == trame[n - 1]) ? F("correct") : F("incorrect"));
}
bool frameRecue() {
static enum : uint8_t {F1, F2, TRAME} etape = F1;
bool receptionOK = false;
static uint8_t compteur = 0;
static uint8_t nouvelleLigne = 0;
if (RS232.available() == 0) return false; // rien à lire
uint8_t recu = RS232.read();
// on passe à la ligne tous les 8 octets
if ( (nouvelleLigne++ % 8) == 0) Serial.println();
printByteInfo(recu);
switch (etape) {
case F1:
if (recu == flag1) etape = F2;
break;
case F2:
if (recu == flag2) {
compteur = 0;
etape = TRAME;
} else if (recu != flag1) {
etape = F1;
}
break;
case TRAME:
frame[compteur++] = recu;
receptionOK = (compteur >= sizeof frame);
if (receptionOK) etape = F1; // on se prépare à recevoir la prochaine trame
}
return receptionOK;
}
void setup() {
Serial.begin(115200);
RS232.begin(debit);
Serial.println(F("\nPrêt à recevoir des trames"));
}
void loop() {
if (frameRecue()) {
printFrame(frame, sizeof frame);
}
}
Merci pour le code, mais avant ca j'avait tester tout les débits simplement avec :
void setup() {
Serial1.begin(9600); //j'ai testé avec 1200,2400, 4800, 9600, 14400, 19200, 38400, 57600, 115200 ++
Serial2.begin(9600); //j'ai testé avec 1200,2400, 4800, 9600, 14400, 19200, 38400, 57600, 115200 ++
Serial.begin(9600); // pour vérifier
Serial3.begin(9600); // pour vérifier
}
void loop() {
static uint32_t n = 0;
if (Serial1.available()) { // pour faire une simple lecture/ecriture entre mon capteur et Serial2
Serial2.write(Serial1.read());
}
// uniquement pour vérifier les branchements et que ca passe vers l'hote
if (Serial3.available()) { // vérifier en plugant Serial2 tx, sur Serial3 rx que j'ai bien une trame qui s'affiche
uint8_t recu = Serial3.read();
if ((n++ % 10) == 0) Serial.println();
Serial.print(F("0x"));
if (recu < 0x10) Serial.write('0');
Serial.print(recu, HEX);
Serial.write(' ');
}
}
Je suis sure qu'il n'y a pas de
1 la doc le précise , 2 quand je connecte juste le Tx du capteur l'hote le reconnais instantanément
La méthode que j'ai utilisé :
- je branche la pin TX du capteur à Rx de l'hôte => le capteur est détecté une valeur s'affiche
- je branche la pin Tx du capteur à Rx Serial1 => l'hôte affiche Capteur CO2 inopérant
- je branche Tx 2 sur la Rx de l'hôte => l'hôte affiche Capteur CO2 inopérant
- je vérifie en branchant momentanément Tx2/Rx hôte sur Rx3 que j'ai bien un signal qui passe => une trame s'affiche sur le moniteur série // juste pour l'angoisse de pas led qui clignote
- Je change le baud rate de S1 et S2 et je pousse pour revérifier si le message Capteur CO2 inopérant disparait ( il disparait instantanément quand je rebranche en direct le Tx capteur à l'hote et une valeur s'affiche)
seule chose à faire, essayer les snifer ? J'ai pu oublier autre chose ?
Comme on ne peut pas avoir la doc du mystérieux capteur on ne peut faire que des suppositions mais quand je vois répéter plusieurs fois dans le fichier RS232 moi, ça fini par faire tilt.
Rassures-nous, ton capteur il ne sort pas en RS232 mais bien en TTL.
ce n'est pas précisé dans la doc TTL ou RS232, pour moi RS232 c'est juste le standard du connecteur, mais si c'était RS232... mon moniteur série n'afficherait rien ?
j'ai tester la tension en sortie de mon capteur....... du coup j'ai du -1 V 
Commandé a l'instant ou je me suis rendu compte que j'etais un boulet 
Saison 2 la semaine prochaine du coup.
vous aurez de la chance si vous n'avez pas grillé votre Arduino ou les pins Rx...
Un niveau logique "0" est représenté par une tension de +3 V à +25 V et un niveau logique "1" par une tension de −3 V à −25 V (codage NRZ). D'ordinaire, des niveaux de +12 V et −12 V sont utilisés.
La norme V.28 indique qu'un 1 est reconnu si la tension est inférieure à −3 V, et un 0 est reconnu si la tension est supérieure à +3 V.
Ya peu de risque, le capteur etait alimenté en 5V par l'Arduino.... enfaite comme l'alimentation est en 5v j'ai pris un raccourci bêtement !
OK - suite au prochain épisode alors