Arduino et alimentationn externe

[log_drakon]

Salut à tous, je dévelloppe mon programme et j'utilise principalement Serial Software pour piloter un écran Nextion, et la librairie EEPROM pour enregistrer les paramètres. Quand j'utilise mon cable USB tout fonctionne normalement, a ceci près que l'envoi des données lues dans l'EEPROM sur l'écran a tendance a bugger et qu'il me faut changer de port USB pour que ca revienne a la normale (ducoup je sais pas si c'est le port USB qu'est défaillant ou autre chose), cependant comme quand j'utilise mon alimentation externe 5V 40W rien ne marche, aussi bien les boutons sur l'écran, que les boutons physiques. Mon arduino est un arduino UNO R4 WIFI, et j'utilise l'IDE Arduino 2.2.1. Voici mon programme car je sais plus ou pourais se situé la panne. Merci d'avance pour vos retours.

#include <RingBuffer.h>
#include <SoftwareSerial.h>
#include <EEPROM.h>

// /!\ Variables à ne pas modifier /!\
  
  String GREEN = "2016";
  String ORANGE = "64908";
  String RED = "63488";

  SoftwareSerial Nex(2,3);

  String mList[40] = {};
  char Hex[3] = {};
  String rm = "";

  bool test1pass = false;
  bool fuite = false;
  bool abandonned = false;

  // Eléctro-vanne Chambre Avant-Arrière
  int relay_1 = 4;
  //Eléctro-vanne Chambre Arrivée Air
  int relay_4 = 12;
  //Distribution Chambre Arrière
  int relay_2 = 7;
  //Distribution Chambre Avant
  int relay_3 = 8;

  int bConfirmation = 10;
  int bCfuite = 11;
  int cP1 = A0;
  int cP2 = A1;

  float tolerance_a;
  int tempo;
  int tempoAir;
  int tol_a;
  int IntTolerance_a;

  int tmpAir;
  int i = 0;

  int pR_a = 0;
  float pRc_a = 0;

  int pR_b = 0;
  float pRc_b = 0;

  float pBase_a = 0;

  float pBase_b = 0;

  String tempoAirStr;
  String tempoStr = String(tempo);

  String pRstr_a;
  String pBaseStr_a;
  String pBaseM_a;

  String pRstr_b;

//Partie programme
void setup(){

  IntTolerance_a = EEPROM.read(2);
  tolerance_a = (String(IntTolerance_a).toFloat() / 100) * 14.504;
  tol_a = map(tolerance_a, 0, 200, 0, 1023);
  tempo = EEPROM.read(0);
  tempoAir = EEPROM.read(1);

  pinMode(bConfirmation, INPUT);
  pinMode(bCfuite, INPUT);

  pinMode(relay_1, OUTPUT);
  pinMode(relay_2, OUTPUT);
  pinMode(relay_3, OUTPUT);
  pinMode(relay_4, OUTPUT);

  pinMode(cP1, INPUT);
  pinMode(cP2, INPUT);
  
  Serial.begin(9600);
  Nex.begin(9600);
  
  delay(1000);
}

//Partie cycle du programme
void loop() { 
  headout: 

  Decompression();

  digitalWrite(relay_2, LOW);
  digitalWrite(relay_3, LOW);
  digitalWrite(relay_4, LOW);

  Clear();
  test1pass = false;
  fuite = false;

  delay(2000);
  Serial.println("Standby");
  Nex_Send("t0.bco=", GREEN, false);
  Nex_Send("t3.bco=", GREEN, false);
  Nex_Send("n0.bco=", GREEN, false);
  Nex_Send("n0.val=", String(tempoAir), false);
  
  //Ces blocs servent à couper le cyle et attendre une pression sur un bouton, pour modfier le temps de pression chaner x "if(i > x ...)"
  while(true){ 
    for(int i = 0;digitalRead(bConfirmation) == HIGH; i++){
      if(i > 100 && digitalRead(bConfirmation) == HIGH){
        goto whileout1;
      }
      delay(1);
    }
    String lRm = Nex_Get();
    if(lRm == "0D00"){
      Serial.println("Lancement Cycle");
      goto whileout1;

    } else if(lRm == "1100"){
      Serial.println("Configuration");

      Nex_Send_int("h20.val=", tempo);
      Nex_Send_int("h21.val=", tempoAir);
      Nex_Send_int("h22.val=", IntTolerance_a);
      Nex_Send_int("n20.val=", tempo);
      Nex_Send_int("n21.val=", tempoAir);
      Nex_Send_int("x20.val=", IntTolerance_a);
      Serial.println("Configuration done...");

    }else if(lRm.length() == 6){

      tempo = hexToDec(mList[0]);
      tempoAir = hexToDec(mList[1]);
      IntTolerance_a = hexToDec(mList[2]);
      tolerance_a = (String(IntTolerance_a).toFloat() / 100) * 14.504;
      tol_a = map(tolerance_a, 0, 200, 0, 1023);

      Serial.println(tempo);
      Serial.println(tempoAir);
      Serial.println(IntTolerance_a);
      Serial.println(tol_a);

      EEPROM.update(0, tempo);
      if(EEPROM.read(0) == tempo){
        Serial.println("Writing 1 done...");
      } else {
        Serial.println("Writing 1 failed...");
      }
      EEPROM.update(1, tempoAir);
      if(EEPROM.read(1) == tempoAir){
        Serial.println("Writing 2 done...");
      } else {
        Serial.println("Writing 2 failed...");
      }
      EEPROM.update(2, IntTolerance_a);
      if(EEPROM.read(2) == IntTolerance_a){
        Serial.println("Writing 3 done...");
      } else {
        Serial.println("Writing 3 failed...");
      }
    }
  
  }
  whileout1:
  
  //Affichage sur l'écran du premier test
  Serial.println("Test Ch Av");
  Nex_Send("t0.bco=", ORANGE, false);
  Nex_Send("t3.bco=", ORANGE, false);
  Nex_Send("t1.bco=", GREEN, false);
  Nex_Send("t7.bco=", GREEN, false);
  Nex_Send("x2.bco=", GREEN, false);
  
  delay(500);

  //Fonction qui ouvre les éléctrovannes pour faire baisser la pression
  Decompression();

  //Affichage sur l'écran de la pression de base
  pBaseStr_a = String(map(pBase_a, 0, 1023, 0, 200) / 14.504);
  pBaseM_a = "Pression de base : " + pBaseStr_a + " bar";
  Nex_Send("x2.txt=", pBaseM_a, true);

  digitalWrite(relay_2, HIGH);
  digitalWrite(relay_3, LOW);

  //Boucle d'envoi d'air
  tmpAir = tempoAir;
  while(i <= tmpAir){
    if(digitalRead(bCfuite) == HIGH){ 
      for(int i = 0;digitalRead(bCfuite) == HIGH; i++){
        if(i > 100 && digitalRead(bCfuite) == HIGH){
          goto headout;
        }
        delay(1);
      }
    }
    i=0;

    Serial.println("Boucle envoi Air 1");
    tempoAirStr = String(tmpAir);
    tmpAir--;
    Nex_Send("n0.val=", tempoAirStr, false);
    Serial.println(tempoAirStr);
    delay(1000);
  }
  
  digitalWrite(relay_2, LOW);
  digitalWrite(relay_3, LOW);

  Nex_Send("t4.bco=", GREEN, false);
  Nex_Send("x0.bco=", GREEN, false);

  delay(500);

  //Lancement du test
  Serial.println(Test_Air(cP1, cP2));

  //Condition en cas de fuit ou d'abandon
  if(fuite == true){
    goto headout;
  }
  if(abandonned == true){
    abandonned = false;
    goto headout;
  }

  test1pass = true;
  
  Serial.println("Test Ch. Av.");
  Nex_Send("t7.bco=", ORANGE, false);
  Nex_Send("t4.bco=", ORANGE, false);
  Nex_Send("x0.bco=", ORANGE, false);
  Nex_Send("t8.bco=", GREEN, false);

  delay(500);

  //Fonction qui ouvre les éléctrovannes pour faire baisser la pression
  Decompression();

  //Affichage de la pression de base sur l'écran
  pBaseStr_a = String(map(pBase_a, 0, 1023, 0, 200) / 14.504);
  pBaseM_a = "Pression de base : " + pBaseStr_a + " bar";
  Nex_Send("x2.txt=", pBaseM_a, true);

  digitalWrite(relay_3, HIGH);
  digitalWrite(relay_2, LOW);
  tmpAir = tempoAir;

  //Boucle d'envoi d'air
  while(i <= tmpAir){
    if(digitalRead(bCfuite) == HIGH){ 
      for(int i = 0;digitalRead(bCfuite) == HIGH; i++){
        if(i > 100 && digitalRead(bCfuite) == HIGH){
          goto headout;
        }
        delay(1);
      }
    }
    i=0;

    Serial.println("Boucle envoi Air 2");
    tempoAirStr = String(tmpAir);
    tmpAir--;
    Nex_Send("n0.val=", tempoAirStr, false);
    Serial.println(tempoAirStr);
    delay(1000);
  }

  digitalWrite(relay_3, LOW);
  digitalWrite(relay_2, LOW);

  Nex_Send("t5.bco=", GREEN, false);
  Nex_Send("x1.bco=", GREEN, false);
  
  //Lancement du test
  Serial.println(Test_Air(cP2, cP1));
  if(fuite == true){
    goto headout;
  }
  if(abandonned == true){
    abandonned = false;
    goto headout;
  }

  delay(200);
}

//Fonction du Test
String Test_Air(int cP_a, int cP_b){
  Serial.print("Test Air / Tolérance : ");
  Serial.println(String(tol_a));
  Serial.print("Pression de base : ");
  Serial.print(map(pBase_a, 0, 1023, 0, 200) / 14.504);
  Serial.println(" bar.");

  int _tempo = tempo * 10;
  bool firstD_a = true;
  bool firstD_b = true;

  while(i <= _tempo){ 
    Serial.println("Boucle Test Air");
    String _tempoStr = String(_tempo);
    Serial.println(_tempoStr);

    pR_a = analogRead(cP_a);
    pRc_a = map(pR_a, 0, 1023, 0, 200);
    pRc_a = pRc_a / 14,504;
    Serial.print("Pression A : ");
    Serial.println(pRc_a);
    pRstr_a = String(pRc_a);

    pR_b = analogRead(cP_b);
    pRc_b = map(pR_b, 0, 1023, 0, 200);
    pRc_b = pRc_b / 14,504;
    Serial.print("Pression B : ");
    Serial.println(pRc_b );
    pRstr_b = String(pRc_b);

    if(cP_a == cP1){
      Nex_Send("x0.txt=", pRstr_a, true);
      Nex_Send("n0.val=", _tempoStr, false);
      Nex_Send("x1.txt=", pRstr_b, true); 
    } else if (cP_a == cP2) {
      Nex_Send("x1.txt=", pRstr_a, true);
      Nex_Send("n0.val=", _tempoStr, false); 
      Nex_Send("x0.txt=", pRstr_b, true);     
    }

    delay(10);

    int difPr_a = pR_a - pBase_a;

    if(difPr_a > tol_a){
      _tempo--;
      delay(50);
      pR_a = analogRead(cP_a);
      if(analogRead(cP_a) - pBase_a > tol_a){
        Fuite(pRc_a, "A");
        return("Fuite A");
      }
    }

    if(digitalRead(bCfuite) == HIGH){ 
      for(int i = 0;digitalRead(bCfuite) == HIGH; i++){
        if(i > 100 && digitalRead(bCfuite) == HIGH){
          abandonned = true;
          return("Abandonned");
        }
        delay(1);
      }
    }
    i=0;
    
    firstD_a = true;
    firstD_b = true;
    _tempo--;

  }

  if(test1pass == true){
    Sans_Fuite();
    return("Pas de fuite");
  }
  fuite = false;
}

//Fonction en cas de fuite
void Fuite(float pF_a, String rF){
  Serial.print("Detection de fuite programme : ");
  Serial.println(rF);

  Serial.print("Fuite A detectee à : ");
  Serial.print(String(pF_a));
  Serial.println(" bar.");
  Serial.print("Pression de base : ");
  Serial.print(map(pBase_a, 0, 1023, 0, 200) / 14.504);
  Serial.println(" bar.");
  
  /*Serial.print("Fuite B detectee à : ");
  Serial.print(String(pF_b));
  Serial.println(" bar.");
  Serial.print("Pression de base : ");
  Serial.print(map(pBase_b, 0, 1023, 0, 200) / 14.504);
  Serial.println(" bar.");*/

  digitalWrite(relay_1, LOW);
  digitalWrite(relay_2, LOW);
  digitalWrite(relay_3, LOW);
  digitalWrite(relay_4, LOW);

  Nex_Send("t5.bco=", ORANGE, false);
  Nex_Send("x1.bco=", ORANGE, false);
  Nex_Send("t8.bco=", ORANGE, false);
  Nex_Send("t4.bco=", ORANGE, false);
  Nex_Send("x0.bco=", ORANGE, false);
  Nex_Send("t7.bco=", ORANGE, false);
  Nex_Send("t1.bco=", ORANGE, false);
  Nex_Send("n0.bco=", ORANGE, false);
  Nex_Send("x2.bco=", ORANGE, false);
  Nex_Send("t2.bco=", GREEN, false);

  Nex_Send("p1.pic=", "2", false);
  Nex_Send("page0.bco=", RED, false);
  Nex_Send("t6.bco=", RED, false);
  Nex_Send("t6.txt=", "Confirmer la fuite", true);

  delay(100);

  while(true){ 
    for(int i = 0;digitalRead(bCfuite) == HIGH; i++){
      if(i > 100 && digitalRead(bCfuite) == HIGH){
        goto fuiteOut;
      }
      delay(1);
      }
  }
  fuiteOut:
  
  Nex_Send("t6.txt=", "Retractation du verin", true);

  if(test1pass != true){
    digitalWrite(relay_4, HIGH);
    delay(100);
    digitalWrite(relay_1, HIGH);
    digitalWrite(relay_3, HIGH);
    while(digitalRead(bCfuite) == HIGH){
    }
    digitalWrite(relay_4, LOW);
    delay(100);
    digitalWrite(relay_1, LOW);
    digitalWrite(relay_3, LOW);
  }

  Decompression();
  fuite = true;
}

void Decompression(){
  Serial.println("Decompression");
  digitalWrite(relay_4, HIGH);

  pBase_a = analogRead(cP1);
  while(map(pBase_a, 0, 1023, 0, 200) / 14.504 > 1.75){
    pBase_a = analogRead(cP1);
  }

  digitalWrite(relay_4, LOW);
}
//Fonction en cas de non fuite
String Sans_Fuite(){
  Serial.println("Aucune fuite détectée");
  Serial.print("Pression de base A : ");
  Serial.print(map(pBase_a, 0, 1023, 0, 200) / 14.504);
  Serial.println(" bar.");
  /*Serial.print("Pression de base B : ");
  Serial.print(map(pBase_b, 0, 1023, 0, 200) / 14.504);
  Serial.println(" bar.");*/
  
  digitalWrite(relay_1, LOW);
  digitalWrite(relay_2, LOW);
  digitalWrite(relay_3, LOW);
  digitalWrite(relay_4, LOW);

  Nex_Send("t5.bco=", ORANGE, false);
  Nex_Send("x1.bco=", ORANGE, false);
  Nex_Send("t8.bco=", ORANGE, false);
  Nex_Send("t1.bco=", ORANGE, false);
  Nex_Send("n0.bco=", ORANGE, false);
  Nex_Send("x2.bco=", ORANGE, false);
  Nex_Send("t2.bco=", GREEN, false);

  Nex_Send("p1.pic=", "3", false);
  Nex_Send("page0.bco=", GREEN, false);
  Nex_Send("t6.bco=", GREEN, false);
  Nex_Send("t6.txt=", "Aucune fuite detectee", true);

  Decompression();

  while(true){ 
    for(int i = 0;digitalRead(bConfirmation) == HIGH; i++){
      if(i > 100 && digitalRead(bConfirmation) == HIGH){
        goto noFuiteOut;
      }
      delay(1);
      }
  }
  noFuiteOut:
  return("Pas de fuite détectée");
}

//Fonction d'envoi et de commande sur l'écran
String Nex_Send(String m, String val, bool Text){
  delay(50);
  char rc;
  char guill = '"';
  if(Text == true){
    val = guill + val + guill;
  }
  String m2 = m + val + "\xFF\xFF\xFF";
  Nex.print(m2);
  return("Sended"); 
}

//Fonction pour récupérer les envois de l'écran
String Nex_Get(){
  if (Nex.available() > 0) {
    rm = "";
    Serial.println("Available");
    delay(30);
    for(int i = 0; Nex.available() > 0; i++){
      char character = Nex.read();
      sprintf(Hex, "%02X", character);
      mList[i] = String(Hex);
      rm += mList[i];
    }
    Serial.println(rm);
    return rm;
    } else {
      return "Not Available";
  }
}

//Fonction simple qui remet l'écran a zéro
void Clear(){
  Serial.println("Clear Nextion");
  Nex_Send("rest", "", false);
}

int hexToDec(String hexVal){
  int decValue = 0;
  for(int u = 0; u < hexVal.length(); u++){
    char c = hexVal.charAt(u);
    if(c >= '0' && c <= '9'){
      decValue = decValue * 16 + (c - '0');
    } else if (c >= 'A' && c <= 'F'){
      decValue = decValue * 16 + (c - 'A' + 10);
    } else if (c >= 'a' && c <= 'f'){
      decValue = decValue * 16 + (c - 'a' + 10);
    } else {
      decValue = 8888;
      return decValue;
      Serial.println("Hex Error");
    }
  }
  return decValue;
  Serial.println(decValue);
}

String Nex_Send_int(String m30, int val30){
  Serial.println("INT Sending Started");
  delay(50);
  Nex.print(m30);
  Serial.println("INT Sending m30 done");
  Nex.print(val30);
  Serial.println("INT Sending val30 done");
  Nex.print("\xFF\xFF\xFF");
  Serial.println("INT Sending xFF done");
  return "Sended";
}

Le programme bloque dans la loop, au niveau de la première boucle while, ligne 110, quand j'appuis sur mon bouton "Configuration" j'ai bien le retour "Configuration" qui confirme le début de cette partie du code, mais après plus rien, en connectant mon alim externe et mon USB les envois "Nex_Send" ne sont pas faits ?

EDIT : En effet, dans la fonction "Nex_Send_int" que j'utilise, j'ai en retour serie seulement "INT Sending started", ce qui montre qe le reste n'est pas executé et que ça bloque à cet endroit pour une raison que j'ignore, le problème doit donc venir du Serial Software mais il se manifeste uniquement quand je suis alimenté pas mon réglateur de tension, et fonctionne (a peu près car ca arrive que ça bugge) sur l'alimentation USB.

[anon96738448]

Bonsoir,

Selon la Doc constructeur

Powering Alternatives for Arduino Boards | Arduino Documentation

Il faut une alimentation exterieur de 7 à 12V.
5V est sans doute trop juste.

D'un point de vue hard (câblages) puisque tu a des INPUT déclarées dans ton programme, il faut que leurs Communs ou 0V soient reliés au GND de l'arduino, et qu'elles fournissent en entrées une tension correcte (idéalement 0V ou 5V).

Je ne sais pas comment tu a branché tes BP?
Si tu utilise des "INPUT-PULLUP"?

Moi je ne suis pas assez calé pour en dire + au niveau de ton soft

[68tjs]

@anon96738448

Je ne sais pas comment tu a branché tes BP?

C'est bien pour cela que l'on demande aussi un schéma électrique.

@log_drakon : Tu auras beau mettre le code le plus sophistiqué, si ton schéma électrique est faux, cela ne fonctionnera jamais.

Et comme on dit : un schéma est compréhensible immédiatement, un long discours, c'est plus hasardeux.

[log_drakon]

Bonjour, je suis pas certain de savoir ou a été mon erreur, mais j'ai pris du temps pour réecrire mon programme entiérement, et ça marche, merci pour votre aide.