ESP32 HC12 avion rc pas de transmission delay<1200ms

International Français
1

Bonjour à toutes et tous,

Je me suis lancé dans le projet de faire la partie commande d'un avion télécommandé avec 2 esp32, 2 HC-12, des servo et un moteur.

Je suis bloqué à la transmission. je n'arrive pas à transmettre des données si ma boucle de mon transmetteur est inférieur à 1200ms.
J'ai tout essayé (je crois), j'ai changé de FU, changé mes baud (9600, 19200, 57600), j'ai rajouté plusieurs condensateur a mon alim (100,220,440), alimenté avec 5v.
Je ne sais vraiment plus quoi faire. (mon firewire ne prend pas en charge le AT+PTO)
A savoir que à 1200ms mon code marche à merveille mais bon 1.2s de latence avec de l'aéromodélisme me semble pas viable.

le code de mon emetteur

#include <Arduino.h>
#include <HardwareSerial.h>

const int HC12_TX = 17;
const int HC12_RX = 16;
const int VRY_PIN = 12;  // Joystick axe Y
const int MIN_JOYSTICK = 1880;  
const int MAX_JOYSTICK = 4095;  

HardwareSerial hc12(1);

void setup() {
  Serial.begin(115200);
  hc12.begin(57600, SERIAL_8N1, HC12_RX, HC12_TX);
  pinMode(VRY_PIN, INPUT);
}

void loop() {
  int joystickValue = analogRead(VRY_PIN);
  joystickValue = constrain(joystickValue, MIN_JOYSTICK, MAX_JOYSTICK);//donne un mini et max en valeur valide
  int data = joystickValue;   
  hc12.println(data);// Envoie la valeur sur HC-12
  Serial.print("Envoyé : ");
  Serial.println(data);
  
  delay(1200);
}

le code de mon recepteur

#include <Arduino.h>
#include <ESP32Servo.h>
#include <HardwareSerial.h>

const int HC12_TX = 17;
const int HC12_RX = 16;
const int ESC_PIN = 26;  
const int MIN_THROTTLE = 1000;  //moteur éteins 
const int MAX_THROTTLE = 2000;  //moteur plein régime

HardwareSerial hc12(1);
Servo esc;

void setup() {
  Serial.begin(115200);
  Serial2.begin(57600, SERIAL_8N1, HC12_RX, HC12_TX);
  
  esc.setPeriodHertz(50);  
  esc.attach(ESC_PIN, MIN_THROTTLE, MAX_THROTTLE);

  // **Séquence d'armement**
  Serial.println("Arming ESC...");
  esc.writeMicroseconds(MIN_THROTTLE);
  delay(2000);  // Attendre que l'ESC s'arme correctement
}

void loop() {
  static int lastValidThrottle = MIN_THROTTLE;  // Dernière valeur valide

  if (Serial2.available()) {
    String received = Serial2.readString();
    Serial.println(received);
    int throttleValue = received.toInt();

   if (throttleValue >= 1880 && throttleValue <= 4095) {
     lastValidThrottle = map(throttleValue, 1880, 4095, MIN_THROTTLE, MAX_THROTTLE);
    }

    esc.writeMicroseconds(lastValidThrottle);

    Serial.print("Reçu : ");
    Serial.print(throttleValue);
    Serial.print(" -> ESC : ");
    Serial.println(lastValidThrottle);
  }
}

Si quelqu'un d'entre vous à déjà eu ce soucis ou à des idées je suis preneur

Merci d'avance
Un Bouquetin

2

Serial.readString() reads characters from the serial buffer into a String. The function terminates if it times out

Le fauteur de trouble c'est le timeout qui par défaut est de 1s.

Comme à l'émission tu fais

hc12.println(data);// Envoie la valeur sur HC-12

il y a un symbole de fin de ligne.
En réception au lieu d'utiliser readString() tu ferais mieux d'utiliser readStringUntil() en spécifiant comme caractère de fin le retour chariot (0x0D). Comme ça, il n'y aura plus d'attente.

3

Bonsoir un_bouquetin
Comme tu envoies ainsi:

Tu peux lire ainsi:

String received = Serial2.readStringUntil('\n');
received.trim();

readStringUntil
trim()

Cordialement
jpbbricole

4

@fdufnews @jpbbricole
Super effectivement c'était à cause du timeout de Serial.readString
Merci énormément
Désormais le code continu :confetti_ball:

Bonne journée

5

Super !
Bonne continuation !

6

Ce n'est pas le cas ici mais attention aussi à l'accumulation de print de debug

Tout dépend bien sûr (dans votre cas particulier) à quelle fréquence vous recevez une communication mais print() devient bloquant si le buffer de sortie est plein, donc si vous imprimez trop souvent le débit de Serial (115200 bauds ici) peut devenir un facteur limitant.

C'est un point à conserver en tête quand on a des blocages que l'on ne comprend pas où qu'on pense qu'un code devrait tourner plus vite qu'il ne le fait.