Synchro pour une réception série

Bonjour tous le monde,
J’utilise une liaison série ente un Uno et Un mega.
J’arrive à envoyer ou recevoir des messages, mais les cartes ne sont pas synchro, je me suis donc dit et si j’utilisé les interruptions? et encore mieux et si mon Rx SoftSerial était raccordé sur une de ces pin?
Je me suis donc lancé mais la seul chose que j’arrive à faire, c’est recréer ‘SerialAviable’. Je voudrai que dans la routine il lise les données en réception.

Ce code fonctionne:

#include <SoftwareSerial.h>
SoftwareSerial Serial1(2, 3);
int i;
String write;
String read;
bool requette=0;

//--------------------------------------------------------------------
void setup() {
  Serial.begin(9600);
  while (!Serial);
  Serial1.begin(9600);
  while (!Serial1);
  Serial.println("Setup Complete!");     // Prét
}

void loop()
{
  Serial.println(requette);
      attachInterrupt(0, Requette, RISING); //Broche2,Fonction ,Front montant
      if (requette==1)
      {
      read = Serial1.readStringUntil(']');
      Serial.println(read);
  requette=0;
      }
      delay(10000);
}


//--------------------------------------------------------------------
void Requette()
{
  requette=1;
}

Ce code ne fonctionne pas:

#include <SoftwareSerial.h>
SoftwareSerial Serial1(2, 3)
int i;
String write;
String read;
bool requette = 0;

//--------------------------------------------------------------------
void setup() {
  Serial.begin(9600);
  while (!Serial);
  Serial1.begin(9600);
  while (!Serial1);
  Serial.println("Setup Complete!");     // Prét
}

void loop()
{
  Serial.println(requette);
  attachInterrupt(0, Requette, RISING); //Broche2,Fonction ,Front montant
  if (requette == 1)
  {
    requette = 0;
  }
  delay(10000);
}


//--------------------------------------------------------------------
void Requette()
{
  requette = 1;
  read = Serial1.readStringUntil(']');
  Serial.println(read);
}

il ne faut pas mettre Serial.println ou Serial1.readStringUntil dans une interruption

ça ne va pas marcher car une interruption par défaut n'est pas interruptible, millis ne fonctionne pas par exemple et readStringUntil dépend de millis pour le timeout

votre ISR ne devrait que lever un drapeau et vous traiter ensuite cela dans la boucle.

(mais je ne comprends pas pourquoi vous avez besoin d'interruption pour lire le port série.. il y a un buffer automatique pour cela au niveau matériel et quand votre boucle revient au début, il suffit de regarder s'il y a quelque chose de dispo avec Serial.available(). Faut juste que la boucle ne bloque pas trop longtemps.

C’est là le problème la boucle doit mettre trop longtemps parce que régulièrement je trouve le buffer vide ou alors je trouve plusieurs messages.
Autre chose les deux codes ne sont pas synchronisés c’est un peu mon idée avec les interruption de faire une synchronisation.
Comme ça j’écoute uniquement quand j’envoie.

à mon avis c'est votre loop qui est mal fichue :slight_smile:

avez vous des delay() dans le code?

Pour le code test,
J’ai mis de delay (simulation charge du code final) du coup, je ne suis plus synchro, le buffer se charge et les réponses sont inattendue. Je cherche à faire une synchro non bloquante.

postez votre code si vous voulez de l'aide... là c'est trop théorique

Voici mes 2 code:

#include <SoftwareSerial.h>                           
SoftwareSerial Serial1(2, 3);                         

String read; 
String buffer;
String write;

void setup() {
  Serial.begin(9600); 
  while (!Serial);
  Serial1.begin(9600);
  while (!Serial1);
}

void loop() {
if (!Receve())
  {
    read = "";
    //Serial.println("DEFAUT LIAISON !");
  }
  else
  {
    Serial.println("Recu -> " + read);
  }
  //delay(4000);
}

boolean Receve() {
  read = "";
  if (Serial1.available())
  {
    read = Serial1.readStringUntil(']');
    Serial1.print(read + "]");
    return (true);
  }
  else
  {
    return (false);
  }
}
#include <SoftwareSerial.h>                           
SoftwareSerial Serial1(2, 3);                         

String read;
String buffer;
String write;

byte i;

void setup() {

  Serial.begin(9600);
  while (!Serial);
  Serial1.begin(9600);
  while (!Serial1);
}

void loop() {
  i++;
  write = "Salut! ";
  write = write + i;
  if (!Send())
  {
    read = "";
    //Serial.println("DEFAUT LIAISON !");
  }
  else
  {
    Serial.println("Envoie -> " + write);
  }
  delay(1000);
}


boolean Send() {
  Serial1.print(write + "]");
  while (!TestRecep() )
  {
    return (false); 
  }
  //else
  {
    TestRecep();
    return (true);
  }
}

//--------------------------------------------------------------------------
//
boolean TestRecep() {
  read = ""; 
  if (Serial1.available()) 
  {
    read = Serial1.readStringUntil(']');
    if (read == write) {
      return (true); 
    }
  }
  return (false);
}

le MEGA c'est lequel? Sur une MEGA Serial1 existe, c'est un port série hardware, autant l'utiliser Plutôt que software serial

Vous êtes un peu agressif avec votre timing; ce n'est pas parce que la première fois que vous appelez receve() (en anglais ça s'écrit receive si vous voulez être correct) et qu'il n'y a rien dans le buffer que ça veut dire que ça ne marche pas. Vous avez mis la liaison à 9600 bauds, moins de 1000 caractere par seconde, votre arduino va passer plusieurs centaines de fois dans la boucle en attendant un caractere tellement il va plus vite que votre port série

S'il n'y a rien en attente, pas grave, revenez voir plus tard

Sinon vaut mieux la classe String et gérer vous même des buffers (tableau de caracteres)

Bonsoir,
J'ai toujours eu des différents avec l'orthographe mais je le vie bien... :wink: (humour)
En fait sur le MEGA, j'utilise bien le Serial1. Je n'ai peut être pas bien expliqué, mais je construit une centrale d'alarme et un digicode. Les 2 communiquent via ce port série (bidirectionnel). Les 2 fonctions sont donc identique dans les 2 arduino. Ce que je voudrai, c'est que le dialogue ne soit plus anarchique mais synchronisé entre les 2 de sorte d'une part être certain que le message soit reçu, d'autre part déceler au plus vite une perte de liaison pour appeler la cavalerie.

Pour les buffers, je trouvais que j'avais trop de ligne de code.