Probleme alimentation Arduino et LCD

[bewokxxxx]

je suis en train de programmer un Compacteur pour le génie civil, avec un ecran LCD et un KeyPad qui sert d'interface homme machine. Le programme du compacteur et l'affichage fonctionne a merveillle, mais lorsque j'alimente l'ecran et les capteurs (le tout ensemble enfaite) ca fait disfonctionner certains moteur et certains capteur.
J'ai donc alimenter lecran via un générateur 5V et larduino avec le PC (ca fonctionne) mais si je n'alimente pas la carte arduino avec le Pc ca ne focntionne plus (jai testé avec un générateur de 5V a 18V, avec une pile 9V, en usb et en jack, jai meme testé avec les entrées Vin et GND
seul lalimentation du PC fait fonctionner le montage (avec l'écran alimenté via le géné)

si quelqu'un sait pourquoi tout change du tout au tout en fonction de la source d'alim...

voici le code (un peu long) mais je pense pas que ca vienne de la :

#include <U8g2lib.h>
#include <Keypad.h>
#include <Arduino.h>

U8G2_ST7920_128X64_F_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* CS=*/ 10, /* reset=*/ 9);

const byte ROWS = 4;
const byte COLS = 4;
char keys[ROWS][COLS] = 
{ 
  {'1','2','3','A'},
  {'4','5','6','B'},
  {'7','8','9','C'},
  {'*','0','#','D'}
};
byte rowPins[ROWS] = {22,24,26,28};
byte colPins[COLS] = {30,32,34,36};
Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS);

//____________________________________ CODE ECRAN _____________________________________________//

enum Menu {
  MAIN_MENU, //0
  INFO_MENU, //1
  START_MENU, //2 
  TEST_MENU, //3

  PROCTOR_MENU, //4
  CBR_MENU, //5 

  PROCTOR_NORMAL, //6
  PROCTOR_MODIFIE,//7

  CBR_NORMAL,//8
  CBR_MODIFIE,//9


  INFO_CYCLE1,//10
  INFO_CYCLE2,//13
  INFO_CYCLE3,//16
  INFO_CYCLE4,//19

  START_cycle1,//11
  START_cycle2,//14
  START_cycle3,//17
  START_cycle4,//20

  INIT_1,//12
  INIT_2,//15
  INIT_3,//18
  INIT_4,//21
  
  CONTINUE_CYCLE_1, //22
  CONTINUE_CYCLE_2, //23 
  CONTINUE_CYCLE_3, //24
  CONTINUE_CYCLE_4, //25

  FIN_CYCLE_1, //26
  FIN_CYCLE_2, //27
  FIN_CYCLE_3, //28
  FIN_CYCLE_4, //29
};

Menu currentMenu = MAIN_MENU;

void displayMainMenu() 
{  // main menu 0
  u8g2.clearBuffer();
  u8g2.setFont(u8g2_font_minicute_tr); //
  u8g2.drawButtonUTF8(5,8, U8G2_BTN_INV, u8g2.getDisplayWidth()-2*5,7,1,"     COMPACTEUR");
 
  u8g2.setFont(u8g2_font_unifont_t_symbols);
    u8g2.drawGlyph(29, 29, 0x2190);  
    u8g2.drawGlyph(29, 45, 0x2190);  
    u8g2.drawGlyph(29, 61, 0x2190);  
      u8g2.setFont(u8g2_font_minicute_tr); 
  u8g2.drawStr(19, 26, "1    Information");
  u8g2.drawStr(17, 42, "2    Demarrer");
  u8g2.drawStr(17, 58, "3    Test moteur");
  u8g2.sendBuffer();
}

void displayInfoMenu() { //menu 1
  u8g2.clearBuffer();
    u8g2.setFont(u8g2_font_unifont_t_symbols);
    u8g2.drawGlyph(87, 66, 0x2190); //fleche retour
  u8g2.setFont(u8g2_font_minicute_tr); //
  u8g2.drawButtonUTF8(5,8, U8G2_BTN_INV, u8g2.getDisplayWidth()-2*5,7,1,"     INFORMATION");
  // Changer temporairement la taille de la police
   u8g2.setFont(u8g2_font_minicute_tr); // Choix d'une autre taille de police
  u8g2.drawStr(23, 24, "By PROVITEQ");
  // Revenir à la taille de police par défaut
  u8g2.drawStr(1, 39, "- PROCTOR A");
  u8g2.drawStr(1, 50, "- PROCTOR B (CBR)");
  u8g2.setFont(u8g2_font_04b_03_tr);
  u8g2.drawStr(79, 62, "0    retour ");
  u8g2.sendBuffer();
}

void displayStartMenu() 
{ //menu 2
  u8g2.clearBuffer();
  u8g2.setFont(u8g2_font_unifont_t_symbols);
    u8g2.drawGlyph(35, 30, 0x2190); 
    u8g2.drawGlyph(35, 45, 0x2190); 
    u8g2.drawGlyph(87, 66, 0x2190); //fleche retour
   u8g2.setFont(u8g2_font_minicute_tr);
  u8g2.drawButtonUTF8(5,8, U8G2_BTN_INV, u8g2.getDisplayWidth()-2*5,7,1,"       DEMARRER");
  u8g2.drawStr(20, 27, "1      PROCTOR A");
  u8g2.drawStr(20, 42, "2     PROCTOR B ");
  u8g2.drawStr(55, 52, " (CBR)");
  u8g2.setFont(u8g2_font_04b_03_tr);
  u8g2.drawStr(79, 62, "0    retour");
  u8g2.sendBuffer();
}


void displayTestMenu() 
{ //menu 3
  u8g2.clearBuffer();
    u8g2.setFont(u8g2_font_unifont_t_symbols);
    //vers gauche 
    u8g2.drawGlyph(12, 27, 0x2190); 
    u8g2.drawGlyph(12, 40, 0x2190); 
    u8g2.drawGlyph(12, 52, 0x2190); 
    u8g2.drawGlyph(12, 64, 0x2190); 
    //vers droite 
    u8g2.drawGlyph(105, 27, 0x2192); 
    u8g2.drawGlyph(105, 40, 0x2192); 
    u8g2.drawGlyph(105, 52, 0x2192); 
    u8g2.drawGlyph(105, 64, 0x2192); 
 u8g2.setFont(u8g2_font_minicute_tr);
  u8g2.drawButtonUTF8(5,8, U8G2_BTN_INV, u8g2.getDisplayWidth()-2*5,7,1,"     TEST MOTEUR");
  u8g2.drawStr(3, 25, "1    Rotation| Stop   4");
  u8g2.drawStr(70, 37, "|");
  u8g2.drawStr(3, 37, "2   Reculer   Stop   5");
  u8g2.drawStr(3, 49, "3   Avancer | Stop   6");
  u8g2.drawStr(4, 61, "A   Battage | Stop   B");
  u8g2.sendBuffer();
}


void displayProctorMenu() 
{ //menu 4
  u8g2.clearBuffer();
    u8g2.setFont(u8g2_font_unifont_t_symbols);
    u8g2.drawGlyph(20, 31, 0x2190); 
    u8g2.drawGlyph(20, 50, 0x2190); 
    u8g2.drawGlyph(87, 66, 0x2190); //fleche retour
u8g2.setFont(u8g2_font_minicute_tr);
  u8g2.drawButtonUTF8(5,8, U8G2_BTN_INV, u8g2.getDisplayWidth()-2*5,7,1,"   CYCLE PROCTOR A");
  u8g2.drawStr(10, 28, "1    PROCTOR Normal");
  u8g2.drawStr(10, 47, "2   PROCTOR Modifie ");
  u8g2.setFont(u8g2_font_04b_03_tr);
  u8g2.drawStr(79, 62, "0    retour");
  u8g2.sendBuffer();
}

void displayCbrMenu()
{ //menu 5
  u8g2.clearBuffer();
    u8g2.setFont(u8g2_font_unifont_t_symbols);
    u8g2.drawGlyph(20, 31, 0x2190); 
    u8g2.drawGlyph(20, 50, 0x2190); 
    u8g2.drawGlyph(87, 66, 0x2190); //fleche retour
u8g2.setFont(u8g2_font_minicute_tr);
  u8g2.drawButtonUTF8(5,8, U8G2_BTN_INV, u8g2.getDisplayWidth()-2*5,7,1,"   CYCLE PROCTOR B");
  u8g2.drawStr(10, 28, "1    PROCTOR Normal");
  u8g2.drawStr(10, 47, "2   PROCTOR Modifie ");
  u8g2.setFont(u8g2_font_04b_03_tr);
  u8g2.drawStr(79, 62, "0    retour");
  u8g2.sendBuffer();
}

void displayProctorNormal() 
{ // menu 6
  u8g2.clearBuffer();
      u8g2.setFont(u8g2_font_unifont_t_symbols);
    u8g2.drawGlyph(32, 26, 0x2190); 
    u8g2.drawGlyph(32, 39, 0x2190); 
    u8g2.drawGlyph(32, 53, 0x2190);
    u8g2.drawGlyph(87, 66, 0x2190); //fleche retour
u8g2.setFont(u8g2_font_minicute_tr);
  u8g2.drawButtonUTF8(5,8, U8G2_BTN_INV, u8g2.getDisplayWidth()-2*5,7,1,"  PROCTOR A NORMAL");
  u8g2.drawStr(17, 23, "1      Info cycle");
  u8g2.drawStr(17, 36, "2     Lancer cycle ");
  u8g2.drawStr(17, 50, "3     Initialisation");
  u8g2.setFont(u8g2_font_04b_03_tr);
  u8g2.drawStr(79, 62, "0    retour");
  u8g2.sendBuffer();
}

void displayProctorModifie() 
{ // menu 7
  u8g2.clearBuffer();
      u8g2.setFont(u8g2_font_unifont_t_symbols);
    u8g2.drawGlyph(32, 26, 0x2190); 
    u8g2.drawGlyph(32, 39, 0x2190); 
    u8g2.drawGlyph(32, 53, 0x2190);
    u8g2.drawGlyph(87, 66, 0x2190); //fleche retour
u8g2.setFont(u8g2_font_minicute_tr);
  u8g2.drawButtonUTF8(5,8, U8G2_BTN_INV, u8g2.getDisplayWidth()-2*5,7,1,"  PROCTOR A MODIFIE");
  u8g2.drawStr(17, 23, "1      Info cycle");
  u8g2.drawStr(17, 36, "2     Lancer cycle ");
  u8g2.drawStr(17, 50, "3     Initialisation");
  u8g2.setFont(u8g2_font_04b_03_tr);
  u8g2.drawStr(79, 62, "0    retour");
  u8g2.sendBuffer();
}

void displayCbrNormal() 
{ // menu 8
  u8g2.clearBuffer();
      u8g2.setFont(u8g2_font_unifont_t_symbols);
    u8g2.drawGlyph(32, 26, 0x2190); 
    u8g2.drawGlyph(32, 39, 0x2190); 
    u8g2.drawGlyph(32, 53, 0x2190);
    u8g2.drawGlyph(87, 66, 0x2190); //fleche retour
u8g2.setFont(u8g2_font_minicute_tr);
  u8g2.drawButtonUTF8(5,8, U8G2_BTN_INV, u8g2.getDisplayWidth()-2*5,7,1,"  PROCTOR B NORMAL");
  u8g2.drawStr(17, 23, "1      Info cycle");
  u8g2.drawStr(17, 36, "2     Lancer cycle ");
  u8g2.drawStr(17, 50, "3     Initialisation");
  u8g2.setFont(u8g2_font_04b_03_tr);
  u8g2.drawStr(79, 62, "0    retour");
  u8g2.sendBuffer();
}

void displayCbrModifie() 
{ // menu 9
  u8g2.clearBuffer();
      u8g2.setFont(u8g2_font_unifont_t_symbols);
    u8g2.drawGlyph(32, 26, 0x2190); 
    u8g2.drawGlyph(32, 39, 0x2190); 
    u8g2.drawGlyph(32, 53, 0x2190);
    u8g2.drawGlyph(87, 66, 0x2190); //fleche retour
u8g2.setFont(u8g2_font_minicute_tr);
  u8g2.drawButtonUTF8(5,8, U8G2_BTN_INV, u8g2.getDisplayWidth()-2*5,7,1,"  PROCTOR B MODIFIE");
  u8g2.drawStr(17, 23, "1      Info cycle");
  u8g2.drawStr(17, 36, "2     Lancer cycle ");
  u8g2.drawStr(17, 50, "3     Initialisation");
  u8g2.setFont(u8g2_font_04b_03_tr);
  u8g2.drawStr(79, 62, "0    retour");
  u8g2.sendBuffer();
}


void displayInfo1() 
{ //10
  u8g2.clearBuffer();
        u8g2.setFont(u8g2_font_unifont_t_symbols);
    u8g2.drawGlyph(87, 66, 0x2190); //fleche retour
u8g2.setFont(u8g2_font_minicute_tr);
  u8g2.drawStr(3, 10, "3 couches");
  u8g2.drawStr(3, 23, "25 coups par couche");
  u8g2.drawStr(1, 40, "duree : 1min 35s");
  u8g2.drawStr(1, 50, "(duree / couche)");
  u8g2.setFont(u8g2_font_04b_03_tr);
  u8g2.drawStr(79, 62, "0    retour");
  u8g2.sendBuffer();
}

void displayInfo2() 
{ //13
  u8g2.clearBuffer();
          u8g2.setFont(u8g2_font_unifont_t_symbols);
    u8g2.drawGlyph(87, 66, 0x2190); //fleche retour
u8g2.setFont(u8g2_font_minicute_tr);
  u8g2.drawStr(3, 10, "5 couches");
  u8g2.drawStr(3, 23, "25 coups par couche");
  u8g2.drawStr(1, 40, "duree : 1min 35s");
  u8g2.drawStr(1, 50, "(duree / couche)");
  u8g2.setFont(u8g2_font_04b_03_tr);
  u8g2.drawStr(79, 62, "0    retour");
  u8g2.sendBuffer();
}

void displayInfo3() 
{ //16
  u8g2.clearBuffer();
          u8g2.setFont(u8g2_font_unifont_t_symbols);
    u8g2.drawGlyph(87, 66, 0x2190); //fleche retour
u8g2.setFont(u8g2_font_minicute_tr);
  u8g2.drawStr(3, 10, "3 couches");
  u8g2.drawStr(3, 23, "56 coups par couche");
  u8g2.drawStr(1, 40, "duree : 1min 35s");
  u8g2.drawStr(1, 50, "(duree / couche)");
  u8g2.setFont(u8g2_font_04b_03_tr);
  u8g2.drawStr(79, 62, "0    retour");
  u8g2.sendBuffer();
}

void displayInfo4() 
{ //19
  u8g2.clearBuffer();
          u8g2.setFont(u8g2_font_unifont_t_symbols);
    u8g2.drawGlyph(87, 66, 0x2190); //fleche retour
u8g2.setFont(u8g2_font_minicute_tr);
  u8g2.drawStr(3, 10, "5 couches");
  u8g2.drawStr(3, 23, "56 coups par couche");
  u8g2.drawStr(1, 40, "duree : 1min 35s");
  u8g2.drawStr(1, 50, "(duree / couche)");
  u8g2.setFont(u8g2_font_04b_03_tr);
  u8g2.drawStr(79, 62, "0    retour");
  u8g2.sendBuffer();
}


void displayStart1() 
{ //11
  u8g2.clearBuffer();
u8g2.setFont(u8g2_font_minicute_tr);
  u8g2.drawButtonUTF8(5,8, U8G2_BTN_INV, u8g2.getDisplayWidth()-2*5,7,1,"  PROCTOR A NORMAL");
  u8g2.drawStr(20, 35, "CYCLE EN COURS");
  u8g2.drawStr(2, 54, "ne pas ouvrir la porte");
  u8g2.sendBuffer();
}

void displayStart2() 
{ //14
  u8g2.clearBuffer();
  u8g2.setFont(u8g2_font_minicute_tr);
  u8g2.drawButtonUTF8(5,8, U8G2_BTN_INV, u8g2.getDisplayWidth()-2*5,7,1,"  PROCTOR A MODIFIE");
  u8g2.drawStr(20, 35, "CYCLE EN COURS");
  u8g2.drawStr(2, 54, "ne pas ouvrir la porte");
  u8g2.sendBuffer();
}

void displayStart3() 
{ //17
  u8g2.clearBuffer();
u8g2.setFont(u8g2_font_minicute_tr);
  u8g2.drawButtonUTF8(5,8, U8G2_BTN_INV, u8g2.getDisplayWidth()-2*5,7,1,"  PROCTOR B NORMAL");
  u8g2.drawStr(20, 35, "CYCLE EN COURS");
  u8g2.drawStr(2, 54, "ne pas ouvrir la porte");
  u8g2.sendBuffer();
}

void displayStart4() 
{ //20
  u8g2.clearBuffer();
 u8g2.setFont(u8g2_font_minicute_tr);
  u8g2.drawButtonUTF8(5,8, U8G2_BTN_INV, u8g2.getDisplayWidth()-2*5,7,1,"  PROCTOR B MODIFIE");
  u8g2.drawStr(20, 35, "CYCLE EN COURS");
  u8g2.drawStr(2, 54, "ne pas ouvrir la porte");
  u8g2.sendBuffer();
}



void displayInit1() 
{ //12 
  u8g2.clearBuffer();
  u8g2.setFont(u8g2_font_minicute_tr);
  u8g2.drawButtonUTF8(5,8, U8G2_BTN_INV, u8g2.getDisplayWidth()-2*5,7,1,"    INITIALISATION");
  u8g2.drawStr(24, 30, "INITIALISATION");
  u8g2.drawStr(40, 41, "EN COURS");
    u8g2.drawStr(2, 58, "ne pas ouvrir la porte");
  u8g2.sendBuffer();
}

void displayInit2() 
{ //15
  u8g2.clearBuffer();
  u8g2.setFont(u8g2_font_minicute_tr);
  u8g2.drawButtonUTF8(5,8, U8G2_BTN_INV, u8g2.getDisplayWidth()-2*5,7,1,"    INITIALISATION");
  u8g2.drawStr(24, 30, "INITIALISATION");
  u8g2.drawStr(40, 41, "EN COURS");
    u8g2.drawStr(2, 58, "ne pas ouvrir la porte");
  u8g2.sendBuffer();
}

void displayInit3() 
{ //18
  u8g2.clearBuffer();
  u8g2.setFont(u8g2_font_minicute_tr);
  u8g2.drawButtonUTF8(5,8, U8G2_BTN_INV, u8g2.getDisplayWidth()-2*5,7,1,"    INITIALISATION");
  u8g2.drawStr(24, 30, "INITIALISATION");
  u8g2.drawStr(40, 41, "EN COURS");
    u8g2.drawStr(2, 58, "ne pas ouvrir la porte");
  u8g2.sendBuffer();
}

void displayInit4() 
{ //21
  u8g2.clearBuffer();
  u8g2.setFont(u8g2_font_minicute_tr);
  u8g2.drawButtonUTF8(5,8, U8G2_BTN_INV, u8g2.getDisplayWidth()-2*5,7,1,"    INITIALISATION");
  u8g2.drawStr(24, 30, "INITIALISATION");
  u8g2.drawStr(40, 41, "EN COURS");
    u8g2.drawStr(2, 58, "ne pas ouvrir la porte");
  u8g2.sendBuffer();
}


int cycleCounter = 0; 
void displayContinueCycle1() 
{ //22
u8g2.clearBuffer();
        u8g2.setFont(u8g2_font_unifont_t_symbols);
    u8g2.drawGlyph(22, 52, 0x2190); 
    u8g2.drawGlyph(22, 64, 0x2190); 
      u8g2.setFont(u8g2_font_minicute_tr);
  u8g2.drawButtonUTF8(5,8, U8G2_BTN_INV, u8g2.getDisplayWidth()-2*5,7,1,"   COUCHE TERMINE");
 u8g2.setFont(u8g2_font_minicute_tr);
  u8g2.setCursor(9, 32);
  u8g2.print("Couche complete : ");
  u8g2.print(cycleCounter); // Affiche la valeur du compteur
  u8g2.drawStr(10, 49, "1    Continuer cycle ");
  u8g2.drawStr(10, 61, "A    Annuler cycle");
  u8g2.sendBuffer();
}

void displayContinueCycle2() 
{ //23
u8g2.clearBuffer();
        u8g2.setFont(u8g2_font_unifont_t_symbols);
    u8g2.drawGlyph(22, 52, 0x2190); 
    u8g2.drawGlyph(22, 64, 0x2190); 
      u8g2.setFont(u8g2_font_minicute_tr);
  u8g2.drawButtonUTF8(5,8, U8G2_BTN_INV, u8g2.getDisplayWidth()-2*5,7,1,"   COUCHE TERMINE");
 u8g2.setFont(u8g2_font_minicute_tr);
  u8g2.setCursor(9, 32);
  u8g2.print("Couche complete : ");
  u8g2.print(cycleCounter); // Affiche la valeur du compteur
  u8g2.drawStr(10, 49, "1    Continuer cycle ");
  u8g2.drawStr(10, 61, "A    Annuler cycle");
  u8g2.sendBuffer();
}

void displayContinueCycle3() 
{ //24
u8g2.clearBuffer();
        u8g2.setFont(u8g2_font_unifont_t_symbols);
    u8g2.drawGlyph(22, 52, 0x2190); 
    u8g2.drawGlyph(22, 64, 0x2190); 
      u8g2.setFont(u8g2_font_minicute_tr);
  u8g2.drawButtonUTF8(5,8, U8G2_BTN_INV, u8g2.getDisplayWidth()-2*5,7,1,"   COUCHE TERMINE");
 u8g2.setFont(u8g2_font_minicute_tr);
  u8g2.setCursor(9, 32);
  u8g2.print("Couche complete : ");
  u8g2.print(cycleCounter); // Affiche la valeur du compteur
  u8g2.drawStr(10, 49, "1    Continuer cycle ");
  u8g2.drawStr(10, 61, "A    Annuler cycle");
  u8g2.sendBuffer();
}

void displayContinueCycle4() 
{ //25
u8g2.clearBuffer();
        u8g2.setFont(u8g2_font_unifont_t_symbols);
    u8g2.drawGlyph(22, 52, 0x2190); 
    u8g2.drawGlyph(22, 64, 0x2190); 
      u8g2.setFont(u8g2_font_minicute_tr);
  u8g2.drawButtonUTF8(5,8, U8G2_BTN_INV, u8g2.getDisplayWidth()-2*5,7,1,"   COUCHE TERMINE");
 u8g2.setFont(u8g2_font_minicute_tr);
  u8g2.setCursor(9, 32);
  u8g2.print("Couche complete : ");
  u8g2.print(cycleCounter); // Affiche la valeur du compteur
  u8g2.drawStr(10, 49, "1    Continuer cycle ");
  u8g2.drawStr(10, 61, "A    Annuler cycle");
  u8g2.sendBuffer();
}



void displayFinCycle1() 
{ //15
 u8g2.clearBuffer();
         u8g2.setFont(u8g2_font_unifont_t_symbols);
    u8g2.drawGlyph(44, 53, 0x2190); //fleche retour
  u8g2.setFont(u8g2_font_ncenB10_tr);
  u8g2.drawStr(20, 30, "FIN CYCLE");
   u8g2.setFont(u8g2_font_minicute_tr);
  u8g2.drawStr(32, 50, "0    retour");
  u8g2.sendBuffer();
}

void displayFinCycle2() 
{ //15
 u8g2.clearBuffer();
         u8g2.setFont(u8g2_font_unifont_t_symbols);
    u8g2.drawGlyph(44, 53, 0x2190); //fleche retour
  u8g2.setFont(u8g2_font_ncenB10_tr);
  u8g2.drawStr(20, 30, "FIN CYCLE");
   u8g2.setFont(u8g2_font_minicute_tr);
  u8g2.drawStr(32, 50, "0    retour");
  u8g2.sendBuffer();
}

void displayFinCycle3() 
{ //15
 u8g2.clearBuffer();
         u8g2.setFont(u8g2_font_unifont_t_symbols);
    u8g2.drawGlyph(44, 53, 0x2190); //fleche retour
  u8g2.setFont(u8g2_font_ncenB10_tr);
  u8g2.drawStr(20, 30, "FIN CYCLE");
   u8g2.setFont(u8g2_font_minicute_tr);
  u8g2.drawStr(32, 50, "0    retour");
  u8g2.sendBuffer();
}

void displayFinCycle4() 
{ //15
 u8g2.clearBuffer();
         u8g2.setFont(u8g2_font_unifont_t_symbols);
    u8g2.drawGlyph(44, 53, 0x2190); //fleche retour
  u8g2.setFont(u8g2_font_ncenB10_tr);
  u8g2.drawStr(20, 30, "FIN CYCLE");
   u8g2.setFont(u8g2_font_minicute_tr);
  u8g2.drawStr(32, 50, "0    retour");
  u8g2.sendBuffer();
}

//____________________________________ CODE COMPACTEUR _____________________________________________//

const int numInputs = 6;
const int analogIn[numInputs] = {A0, A1, A2, A8, A4, A5};
const int numOutputs = 4;
const int DigitalOut[numOutputs] = {2, 3, 4, 5};
bool capteurDame = false;

int val = 0;
float voltage = 0.0;

bool readanalogInA1() //capteur 6, rouge
{
  val = analogRead(A1);
  voltage = val * (5.0 / 1023.0);
  return voltage > 4.97;
}

bool readanalogInA0() //capteur 4, bleu 
{
  val = analogRead(A0);
  voltage = val * (5.0 / 1023.0);
  return voltage > 4.97;
}

bool readanalogInA2() //capteur centre, gris
{
  val = analogRead(A2);
  voltage = val * (5.0 / 1023.0);
  return voltage > 4.97;
}

bool readanalogInA8() //capteur Dame, blancOUnoir
{
  val = analogRead(A8);
  voltage = val * (5.0 / 1023.0);
  return voltage > 4.97;
}

void moteur(int *DigitalOut, bool moteuron) 
{
    analogWrite(*DigitalOut, moteuron ? 255 : 0);
}


char readKey() 
{
    char key = keypad.getKey();
    if (key) 
    {
        Serial.println(key);
    }
    return key;
}

void rotation_1sur6()
{
    //delay(50);
    moteur(&DigitalOut[0], true);
    delay(340);
    moteur(&DigitalOut[0], false);
}

void rotation_1sur12()
{
    moteur(&DigitalOut[0], true);
    delay(140);
    moteur(&DigitalOut[0], false);
}

void rotation_1sur4()
{
    moteur(&DigitalOut[0], true);
    delay(550);
    moteur(&DigitalOut[0], false);
}

void translationAvantJusquaCapteurA0() 
{
    int count_5V = 0;

    while (count_5V < 2) 
    {
        float tension = analogRead(A0) * (5.0 / 1023.0);

       // Serial.print("Tension : ");
       //Serial.println(tension, 2);

        if (tension >= 4.97) 
        {
            count_5V++;
            //Serial.println("Voltage 5V");
        } 
        else 
        {
            count_5V = 0; // Réinitialiser le compteur si la tension n'est pas de 5V
        }

        //Serial.print("Nombre de fois à 5V : ");
        //Serial.println(count_5V);

        if (count_5V == 2) 
        {
            //Serial.println("Moteur coupé");
            moteur(&DigitalOut[2], false);
        } 
        else 
        {
            moteur(&DigitalOut[2], true);
        }

        delay(50); // Attendre avant la prochaine lecture
    }
}

bool derniere_mesure;
float seuil=4.97;
bool A2_vrai;
int compte_5V = 0;
bool A1_vrai = false;

void translationAvantJusquaCapteurA1() 
{
    int count_5V = 0;

    while (count_5V < 3) 
    {
        float tension = analogRead(A1) * (5.0 / 1023.0);

        //Serial.print("Tension : ");
        //Serial.println(tension, 2);

        if (tension >= 4.97) 
        {
            count_5V++;
            //Serial.println("Voltage 5V");
        } 
        else 
        {
            count_5V = 0; // Réinitialiser le compteur si la tension n'est pas de 5V
        }

        //Serial.print("Nombre de fois à 5V : ");
        //Serial.println(count_5V);

        if (count_5V == 3) 
        {
            //Serial.println("Moteur coupé");
            moteur(&DigitalOut[2], false);
        } 
        else 
        {
            moteur(&DigitalOut[2], true);
        }

        delay(50); // Attendre avant la prochaine lecture
    }
}


void TranslationArriereJusquaCapteurA2()
{
    int count_5V = 0;

    while (count_5V < 2) 
    {
        float tension = analogRead(A2) * (5.0 / 1023.0);

        //Serial.print("Tension : ");
        //Serial.println(tension, 2);

        if (tension >= 4.99) 
        {
            count_5V++;
            //Serial.println("Voltage 5V");
        } else {
            count_5V = 0; // Réinitialiser le compteur si la tension n'est pas de 5V
        }

        //Serial.print("Nombre de fois à 5V : ");
        //Serial.println(count_5V);

        if (count_5V == 02) 
        {
            //Serial.println("Moteur coupé");
            moteur(&DigitalOut[1], false);
        } 
        else 
        {
            moteur(&DigitalOut[1], true);
        }

        delay(13); // Attendre avant la prochaine lecture
    }
}
void frapperUneFois() 
{
    int count_5V = 0;

    moteur(&DigitalOut[3], true); // Active le moteur pour frapper
    delay(50);

    while (count_5V < 2) 
    {
        float tension = analogRead(A8) * (5.0 / 1023.0); // Lecture de la tension sur le capteur A8

        //Serial.print("Tension A8 : ");
        //Serial.println(tension, 2);

        if (tension >= 4.97) 
        {
            count_5V++;
            //Serial.println("Voltage 5V A8");
        } 
        else 
        {
            count_5V = 0; // Réinitialiser le compteur si la tension n'est pas de 5V
        }

        //Serial.print("Nombre de fois à 5V A8 : ");
        //Serial.println(count_5V);

        if (count_5V == 2) 
        {
            delay(550);
            //Serial.println("Moteur coupé A8");
            moteur(&DigitalOut[3], false);
        } 
        else 
        {
            moteur(&DigitalOut[3], true);
        }

        delay(50); // Attendre avant la prochaine lecture de tension
    }

    moteur(&DigitalOut[3], false); // Désactive le moteur après la vérification
}

void battageETrotation() 
{
    int count_5V = 0;

    moteur(&DigitalOut[3], true); // Active le moteur pour frapper
    delay(50);

    while (count_5V < 2) 
    {
        float tension = analogRead(A8) * (5.0 / 1023.0); // Lecture de la tension sur le capteur A8

        //Serial.print("Tension A8 : ");
        //Serial.println(tension, 2);

        if (tension >= 4.97) 
        {
            count_5V++;
            //Serial.println("Voltage 5V A8");
        } 
        else 
        {
            count_5V = 0; // Réinitialiser le compteur si la tension n'est pas de 5V
        }

        //Serial.print("Nombre de fois à 5V A8 : ");
        //Serial.println(count_5V);

        if (count_5V == 2) 
        {
            delay(100);
            rotation_1sur6();
            delay(100);
            //Serial.println("Moteur coupé A8");
            moteur(&DigitalOut[3], false);
        } 
        else 
        {
            moteur(&DigitalOut[3], true);
        }

        delay(50); // Attendre avant la prochaine lecture de tension
    }

    moteur(&DigitalOut[3], false); // Désactive le moteur après la vérification
}


void battageETrotation4() 
{
    int count_5V = 0;

    moteur(&DigitalOut[3], true); // Active le moteur pour frapper
    delay(50);

    while (count_5V < 2) 
    {
        float tension = analogRead(A8) * (5.0 / 1023.0); // Lecture de la tension sur le capteur A8

        //Serial.print("Tension A8 : ");
        //Serial.println(tension, 2);

        if (tension >= 4.97) 
        {
            count_5V++;
            //Serial.println("Voltage 5V A8");
        } 
        else 
        {
            count_5V = 0; // Réinitialiser le compteur si la tension n'est pas de 5V
        }

        //Serial.print("Nombre de fois à 5V A8 : ");
        //Serial.println(count_5V);

        if (count_5V == 2) 
        {
            delay(100);
            rotation_1sur4();
            delay(100);
            //Serial.println("Moteur coupé A8");
            moteur(&DigitalOut[3], false);
        } 
        else 
        {
            moteur(&DigitalOut[3], true);
        }

        delay(50); // Attendre avant la prochaine lecture de tension
    }

    moteur(&DigitalOut[3], false); // Désactive le moteur après la vérification
}

void duree(int temps)
{
   delay(100*temps);
}

void cycle6()
{
  Serial.println("avancer au capteur A1");
  translationAvantJusquaCapteurA1();

    Serial.println("battage+rotation1/6  1");
  battageETrotation(); //1
  duree(1);
    Serial.println("battage+rotation1/6  2");
  battageETrotation(); //2
  duree(1);
    Serial.println("battage+rotation1/6  3");
  battageETrotation(); //3
  duree(1);
    Serial.println("battage+rotation1/6  4");
  battageETrotation(); //4
  duree(1);
    Serial.println("battage+rotation1/6  5");
  battageETrotation(); //5
  duree(1);
    Serial.println("battage+rotation1/6  6");
  frapperUneFois(); //6
  duree(1);

Serial.println("rotation de 1/12");
        duree(1); 
        rotation_1sur12(); 
        delay(100);
         Serial.println("reculer au centre");
        TranslationArriereJusquaCapteurA2();
        duree(2);
         Serial.println("battage central");
        moteur(&DigitalOut[3], true); 
        delay(2500); 
        moteur(&DigitalOut[3], false);
}


void cycle4()
{
    Serial.println("avancer au capteur A0");
    duree(1);
    translationAvantJusquaCapteurA0();
    duree(1);

for (int i = 0; i < 3; i++) 
  {
Serial.println("battage+rotation1/4  1");
    battageETrotation4(); //1
    duree(1);
Serial.println("battage+rotation1/4  2");
    battageETrotation4();//2
    duree(1);
Serial.println("battage+rotation1/4  3");
    battageETrotation4(); //3
    duree(1); 
Serial.println("battage+rotation1/4  4");
    battageETrotation4(); //4
    duree(1);
Serial.println("battage+rotation1/4  5");
    battageETrotation4(); //5
    duree(1);
Serial.println("battage+rotation1/4  6");
    battageETrotation4(); //6 
    duree(1); 
Serial.println("battage+rotation1/4  7");
    battageETrotation4(); //7
    duree(1);  
Serial.println("battage+rotation1/4  8");
    frapperUneFois(); //8
    duree(1);
 
    // Maintenant, effectuer la rotation 1/12
    Serial.println("rotation 1/12");
    rotation_1sur12();
  }
    //mise au centre pour le 25eme coups
    Serial.println("battage central");
    duree(1); 
    TranslationArriereJusquaCapteurA2();
    duree(1); 
    frapperUneFois();
}


void initialiserCompacteur()
{ bool A2_vrai = false;
  duree(1);
  Serial.println("initialisation dame");
  frapperUneFois();
  duree(1);
  unsigned long startTime = millis(); // Enregistre le temps actuel (en millisecondes) au moment où la touche 'C' est pressée.
  Serial.println("retour au centre");
  TranslationArriereJusquaCapteurA2();
}


void setup() 
{
  u8g2.begin();
  u8g2.setFont(u8g2_font_crox4tb_tr);
  u8g2.drawStr(15, 40, "PROVITEQ");  // Affiche "PROVITEQ" aux coordonnées x=15 et y=40
  u8g2.sendBuffer();  // Envoie le contenu du tampon pour l'affichage
  delay(1600);  // Pause de 1300 millisecondes
  u8g2.clearBuffer();  // Efface le contenu de l'écran
  displayMainMenu();  // Affiche le menu principal
  pinMode(LED_BUILTIN, OUTPUT);
      for (int i = 0; i < numOutputs; i++) 
    {
        pinMode(DigitalOut[i], OUTPUT);
    }
    Serial.begin(9600);
    Serial.println("Initialize System");
    Serial.println("Please press the keyboard:");
    analogWrite(DigitalOut[0] , 0);
    analogWrite(DigitalOut[1] , 0);
    analogWrite(DigitalOut[2] , 0);
    analogWrite(DigitalOut[3] , 0);
}



void loop() 
{
  char key = keypad.getKey();
  if (key) 
  {
        if (key == '0') 
        {
      // Go back to the previous menu
      switch (currentMenu) 
      {
        case INFO_MENU:
        case START_MENU:
        case TEST_MENU:
          currentMenu = MAIN_MENU;
          displayMainMenu();
          break;

        case PROCTOR_MENU:
        case CBR_MENU:
          currentMenu = START_MENU;
          displayStartMenu();
          break;

        case PROCTOR_NORMAL:
        case PROCTOR_MODIFIE:
        currentMenu = PROCTOR_MENU;
          displayProctorMenu();
          break;

        case CBR_NORMAL:
        case CBR_MODIFIE:
          currentMenu = CBR_MENU;
          displayCbrMenu();
          break;

        case INFO_CYCLE1:
        case INFO_CYCLE2:
        case INFO_CYCLE3:
        case INFO_CYCLE4:
        case START_cycle1:
        case START_cycle2:
        case START_cycle3:
        case START_cycle4:
        case INIT_1:
        case INIT_2:
        case INIT_3:
        case INIT_4:


          // Going back to respective parent menu
          if (currentMenu == INFO_CYCLE1 || currentMenu == START_cycle1 || currentMenu == INIT_1) 
          {
            currentMenu = PROCTOR_NORMAL;
            displayProctorNormal();
          } else if (currentMenu == INFO_CYCLE2 || currentMenu == START_cycle2 || currentMenu == INIT_2) 
          {
            currentMenu = PROCTOR_MODIFIE;
            displayProctorModifie();
          } else if (currentMenu == INFO_CYCLE3 || currentMenu == START_cycle3 || currentMenu == INIT_3) 
          {
            currentMenu = CBR_NORMAL;
            displayCbrNormal();
          } else if (currentMenu == INFO_CYCLE4 || currentMenu == START_cycle4 || currentMenu == INIT_4) 
          {
            currentMenu = CBR_MODIFIE;
            displayCbrModifie();
          }
          break;

        default:
          break;
      }
    } 
    else 
    {
      switch (currentMenu) {
        case MAIN_MENU:
          if (key == '1') 
          {
            currentMenu = INFO_MENU;
            displayInfoMenu();
          } else if (key == '2') 
          {
            currentMenu = START_MENU;
            displayStartMenu();
          } else if (key == '3') 
          {
            currentMenu = TEST_MENU;
            displayTestMenu();
          }
          break;

        case INFO_MENU:
          // Logique pour le menu d'informations
          break;

        case START_MENU:
          if (key == '1') 
          {
            currentMenu = PROCTOR_MENU;
            displayProctorMenu();
          } else if (key == '2') 
          {
            currentMenu = CBR_MENU;
            displayCbrMenu();
          }
          break;

        case TEST_MENU:
          // Logique pour le menu de test
          if (key == '1')
          {
            analogWrite(DigitalOut[0] , 255);
          }
          if (key == '2')
          {
            analogWrite(DigitalOut[1] , 255);
          }
          if (key == '3')
          {
            analogWrite(DigitalOut[2] , 255);
          }
          if (key == 'A')
          {
            analogWrite(DigitalOut[3] , 255);
          }
          if (key == '4')
          {
            analogWrite(DigitalOut[0] , 0);
          }
           if (key == '5')
          {
            analogWrite(DigitalOut[1] , 0);
          }
           if (key == '6')
          {
            analogWrite(DigitalOut[2] , 0);
          }
           if (key == 'B')
          {
            analogWrite(DigitalOut[3] , 0);
          }

          break;

        case PROCTOR_MENU:
          if (key == '1') 
          {
            currentMenu = PROCTOR_NORMAL;
            displayProctorNormal();
          } 
          else if (key == '2') 
          {
            currentMenu = PROCTOR_MODIFIE;
            displayProctorModifie();
          }
          break;

        case CBR_MENU:
          if (key == '1') 
          {
            currentMenu = CBR_NORMAL;
            displayCbrNormal();
          } 
          else if (key == '2') 
          {
            currentMenu = CBR_MODIFIE;
            displayCbrModifie();
          }
          break;


        case PROCTOR_NORMAL:
  if (key == '1') {
    currentMenu = INFO_CYCLE1;
    displayInfo1();
  } else if (key == '2') {
    cycleCounter = 0;
    currentMenu = START_cycle1;
    displayStart1();
    Serial.println("CYCLE 4 COMMENCÉ");
      cycle4();
      duree(1);
    Serial.println("CYCLE 4 TERMINÉ");  
    currentMenu = CONTINUE_CYCLE_1; // Afficher le menu "CONTINUE_CYCLE_1" après la fin du cycle
    cycleCounter++; // Incrémente le compteur à chaque fois que le cycle est terminé
    displayContinueCycle1();
  } else if (key == '3') {
    currentMenu = INIT_1;
    displayInit1();
    Serial.println("INITIALISATION COMMENCÉE");
    initialiserCompacteur();
    Serial.println("INITIALISATION TERMINÉE");
    currentMenu = PROCTOR_NORMAL;
    displayProctorNormal();
  }
  break;

// Ajoutez ensuite dans la partie où vous gérez CONTINUE_CYCLE_1 pour gérer le compteur et les actions associées
case CONTINUE_CYCLE_1:
  if (key == 'A') 
  {
    cycleCounter = 0; // Remise à zéro du compteur si l'utilisateur annule
    currentMenu = PROCTOR_NORMAL;
    displayProctorNormal();
  } 
  else if (key == '1') 
  {
    currentMenu = START_cycle1;
    displayStart1();
    Serial.println("CYCLE 4 COMMENCÉ");
      cycle4();
      duree(1);
    Serial.println("CYCLE 4 TERMINÉ");
    currentMenu = CONTINUE_CYCLE_1; // Revenir au menu de continuation du cycle
    cycleCounter++; // Incrémente le compteur à chaque fois que le cycle est terminé
    displayContinueCycle1();
    if (cycleCounter >= 3) 
    {
      // Si le compteur atteint 3, passer à un nouveau menu
      currentMenu = FIN_CYCLE_1;
      // Faites les actions nécessaires pour le nouveau menu
      displayFinCycle1();

    }
  }
  break;
        
case FIN_CYCLE_1:
  if (key == '0') 
  {
    currentMenu = PROCTOR_NORMAL;
    displayProctorNormal();
  }
  break;

case PROCTOR_MODIFIE:
  if (key == '1') {
    currentMenu = INFO_CYCLE2;
    displayInfo2();
  } else if (key == '2') {
    cycleCounter = 0;
    currentMenu = START_cycle2;
    displayStart2();
    Serial.println("CYCLE 4 modifie COMMENCÉ");
      cycle4();
      duree(1);
    Serial.println("CYCLE 4 modifie TERMINÉ");
    currentMenu = CONTINUE_CYCLE_2; // Afficher le menu "CONTINUE_CYCLE_1" après la fin du cycle
    cycleCounter++; // Incrémente le compteur à chaque fois que le cycle est terminé
    displayContinueCycle2();
  } else if (key == '3') {
    currentMenu = INIT_2;
    displayInit2();
    Serial.println("INITIALISATION COMMENCÉE");
    initialiserCompacteur();
    Serial.println("INITIALISATION TERMINÉE");
    currentMenu = PROCTOR_MODIFIE;
    displayProctorModifie();
  }
  break;

// Ajout de la gestion du compteur pour le menu PROCTOR_MODIFIE
case CONTINUE_CYCLE_2:
   if (key == 'A') 
  {
    cycleCounter = 0; // Remise à zéro du compteur si l'utilisateur annule
    currentMenu = PROCTOR_MODIFIE;
    displayProctorModifie();
  } 
  else if (key == '1') 
  {
    currentMenu = START_cycle2;
    displayStart2();
    Serial.println("CYCLE 4 COMMENCÉ");
      cycle4();
      duree(1);
    Serial.println("CYCLE 4 TERMINÉ");
    currentMenu = CONTINUE_CYCLE_2; // Revenir au menu de continuation du cycle
    cycleCounter++; // Incrémente le compteur à chaque fois que le cycle est terminé
    displayContinueCycle2();
  if (cycleCounter >= 5) {
    currentMenu = FIN_CYCLE_2;
    displayFinCycle2();
  }
  break;

case FIN_CYCLE_2:
  if (key == '0') {
    currentMenu = PROCTOR_MODIFIE;
    displayProctorModifie();
  }
  break;



       case CBR_NORMAL:
  if (key == '1') {
    currentMenu = INFO_CYCLE3;
    displayInfo3();
  } else if (key == '2') {
    cycleCounter = 0;
    currentMenu = START_cycle3;
    displayStart3();
    Serial.println("CYCLE 6 COMMENCÉ");
    for (int i = 0; i < 8; i++)
    {
    cycle6();
    duree(1);
    }
    Serial.println("CYCLE 6 TERMINÉ");
    currentMenu = CONTINUE_CYCLE_3; // Afficher le menu "CONTINUE_CYCLE_1" après la fin du cycle
    cycleCounter++; // Incrémente le compteur à chaque fois que le cycle est terminé
    displayContinueCycle3();
  } else if (key == '3') {
    currentMenu = INIT_3;
    displayInit3();
    Serial.println("INITIALISATION COMMENCÉE");
    initialiserCompacteur();
    Serial.println("INITIALISATION TERMINÉ");
    currentMenu = CBR_NORMAL;
    displayCbrNormal();
  }
  break;

case CONTINUE_CYCLE_3:
  if (key == 'A') {
    cycleCounter = 0; // Remise à zéro du compteur si l'utilisateur annule
    currentMenu = CBR_NORMAL;
    displayCbrNormal();
  } else if (key == '1') {
    currentMenu = START_cycle3;
    displayStart3();
    Serial.println("CYCLE 6 COMMENCÉ");
    for (int i = 0; i < 8; i++)
    {
    cycle6();
    duree(1);
    }
    Serial.println("CYCLE 6 TERMINÉ");
    currentMenu = CONTINUE_CYCLE_3; // Revenir au menu de continuation du cycle
    cycleCounter++; // Incrémente le compteur à chaque fois que le cycle est terminé
    displayContinueCycle3();
    if (cycleCounter >= 3) {
      currentMenu = FIN_CYCLE_3;
      displayFinCycle3();
    }
  }
  break;

case FIN_CYCLE_3:
  if (key == '0') {
    currentMenu = CBR_NORMAL;
    displayCbrNormal();
  }
  break;


       case CBR_MODIFIE:
  if (key == '1') {
    currentMenu = INFO_CYCLE4;
    displayInfo4();
  } else if (key == '2') {
    cycleCounter = 0;
    currentMenu = START_cycle4;
    displayStart4();
    Serial.println("CYCLE 4 COMMENCÉ");
    cycle4();
    duree(1);
    Serial.println("CYCLE 4 TERMINÉ");
    currentMenu = CONTINUE_CYCLE_4; // Afficher le menu "CONTINUE_CYCLE_1" après la fin du cycle
    cycleCounter++; // Incrémente le compteur à chaque fois que le cycle est terminé
    displayContinueCycle4();
  } else if (key == '3') {
    currentMenu = INIT_4;
    displayInit4();
    Serial.println("INITIALISATION COMMENCÉE");
    initialiserCompacteur();
    Serial.println("INITIALISATION TERMINÉE");
    currentMenu = CBR_MODIFIE;
    displayCbrModifie();
  }
  break;

case CONTINUE_CYCLE_4:
  if (key == 'A') {
    cycleCounter = 0; // Remise à zéro du compteur si l'utilisateur annule
    currentMenu = CBR_MODIFIE;

    displayCbrModifie();
  } else if (key == '1') {
    currentMenu = START_cycle4;
    displayStart4();
    Serial.println("CYCLE 4 COMMENCÉ");
    cycle4();
    duree(1);
    Serial.println("CYCLE 4 TERMINÉ");
    currentMenu = CONTINUE_CYCLE_4; // Revenir au menu de continuation du cycle
    cycleCounter++; // Incrémente le compteur à chaque fois que le cycle est terminé
    displayContinueCycle4();
    if (cycleCounter >= 5) {
      currentMenu = FIN_CYCLE_4;
      displayFinCycle4();
    }
  }
  break;

case FIN_CYCLE_4:
  if (key == '0') {
    currentMenu = CBR_MODIFIE;
    displayCbrModifie();
  }
  break;
        // ... (gestion des autres cas des sous-menus)
        }
      }
    }
  }
}

[sterretje]

[google translate]
Parce que vous avez écrit votre sujet en français, il a été déplacé dans la section française du forum.

[gonpezzi]

Les GNG de l'arduino et des capteurs et moteurs défaillants sont-ils connectés ?

[bewokxxxx]

(Désolé d'avance, je suis vraiment débutant). Les moteurs sont reliés à la terre. Les capteurs ont deux fils : un fil positif (+) et un fil qui est connecté aux entrées analogiques (A0, A1, A2 et A8) donc jimagine que la masse passe par la. Y a-t-il un GND spécial avec le PC qui ferait que ça fonctionne uniquement avec le PC ?

[fdufnews]

Un schéma de câblage serait sans doute plus parlant et moins sujet à une mauvaise interprétation

[bewokxxxx]

je vais faire ca !

[bewokxxxx]

voici le schema de cablage (fais un peu a l'arrache j'ai pas les logiciels adaptés)

j'ai donc testé le jack avec le chargeur 12V et le générateur avec Vin et GND de 5 a 15v et quelque et ya que USB du PC qui fait fonctionner a 100% le montage (jai pas le cablage du compacteur car cest bien long a faire et jy ai touché mais si jamais ya vraiment besoin je le ferais)

(le VCC de la carte arduino cest le cable bleu sur les photos il alimente les capteur et les relais des moteurs etc etc)

[gonpezzi]

Il faut joindre le GND du générateur 5V avec le GND du méga arduino.

​

[bewokxxxx]

J'avais effectivement réalisé cette connexion mais on m'a averti que ca pouvait causer un court-circuit. Cependant si c'était la source du problème, ca devrait se manifester quelle que soit la méthode d'alimentation de la carte Arduino non ?

dans le doute j'ai recabler la connexion j'ai retesté avec différentes sources d'alimentation, mais le problème persiste ca ne fonctionne qu'avec l'USB du PC. Exemple avec une autre alim, le moteur qui fait tourner le moule dans le compacteur semble être bloqué, c'est comme si quelqu'un retenait le moteur à la main pour l'empêcher de tourner. Bien qu'il reçoive de l'énergie et l'info, il reste bloqué et emet un bruit pas normal.

je me dis que ca pourrait etre un probleme mécanique ou du code, mais avec l'USB du pc il n'y a aucun probleme.

[fdufnews]

@bewokxxxx

voici le schema de cablage (fais un peu a l'arrache j'ai pas les logiciels adaptés)

Tu aurais pu le faire à main levée sur papier puis photographié, l'essentiel c'est que ce soit lisible.

• masse
  Il me semble qu'il n'y a aucune liaison de masse entre le compacteur et la Mega.
  Il faut qu'un même circuit de masse réunisse les équipements qui doivent échanger des signaux (l'alimentation, la Mega, l'écran, le compacteur).
• Alimentation Mega
  • La Mega peut recevoir un 5V externe sur son entrée +5V ou par l'USB. Éviter d'alimenter +5V et USB en même temps certaines cartes ne protégeant pas l'USB.
  • La Mega peut recevoir une tension entre 7 et 12V sur l'entrée Vin ou le jack. Il est déconseillé de mettre une tension supérieure à 12V sur Vin ou le jack car cela fait chauffer le régulateur sur la carte. On peut recevoir une tension par Vin ou le jack et être connecté par l'USB la carte protège l'USB dans ce cas.
    Il est aussi possible d'avoir des alimentation distinctes entre l'écran et l'arduino mais ce n'est pas une bonne idée car si les alimentations ne montent pas en même temps cela peut conduire a des problèmes de blocage matériel (latch up, mauvaise initialisation, ...).

@bewokxxxx

dans le doute j'ai recabler la connexion j'ai retesté avec différentes sources d'alimentation, mais le problème persiste ca ne fonctionne qu'avec l'USB du PC.

Cela pourrait être le symptôme d'un régulateur sur Vin qui aurait cramé.

Est-ce que la carte seule, alimentée par Vin ou le jack fonctionne correctement?

[bewokxxxx]

je vais aller relier toute les masses et refaire les test, pour ce qui est de l'alimentation j'ai et j'alimente jamais les deux (ou les trois) en meme temps, et le Vin je men suis servie à la toute fin car plus de solution le probleme étant la depuis le début.
Pour la double alim (ecran et arduino) il y a cette disposition car cest comme ca seulement que ca fonctionne, (jai meme fait ce circuit la (voir photo) qui fonctionne parfaitement aussi, avec double alim arduino

[bewokxxxx]

j'ai relier toute les masses, et il y a aucune différence, mais aujourd'hui les moteurs tournes bien (sans aucune modification) l'ecran est brancher sur le VCC de arduino et l'arduino est branché en USB. Maintenant cest les capteurs qui déconne un peu (il déconnait deja mais le probleme cetait surtout les moteurs), il sarrete au bout de 1cm ou pire va en buté.
exemple pour le capteur A2 (capteur qui remet le palteau du compacteur au centre)

void TranslationArriereJusquaCapteurA2()
{
    int count_5V = 0;

    while (count_5V < 2) 
    {
        float tension = analogRead(A2) * (5.0 / 1023.0);

        //Serial.print("Tension : ");
        //Serial.println(tension, 2);

        if (tension >= 4.99) 
        {
            count_5V++;
            //Serial.println("Voltage 5V");
        } else {
            count_5V = 0; // Réinitialiser le compteur si la tension n'est pas de 5V
        }

        //Serial.print("Nombre de fois à 5V : ");
        //Serial.println(count_5V);

        if (count_5V == 02) 
        {
            //Serial.println("Moteur coupé");
            moteur(&DigitalOut[1], false);
        } 
        else 
        {
            moteur(&DigitalOut[1], true);
        }

        delay(13); // Attendre avant la prochaine lecture
    }
}

quand l'ecran nest pas branché sur la carte on a 5V constant quand le capteur est enclenché mais si l'ecran est la on a plus que 4.99 constant (l'écran consomme vraiment vraiment pas beaucoup)

le plateau dépasse donc le capteur pour sarreter plus loin. J'ai testé de mettre 4.97V a la place 4.99 mais ca na rien changé

[fdufnews]

@bewokxxxx

quand l'ecran nest pas branché sur la carte on a 5V constant quand le capteur est enclenché mais si l'ecran est la on a plus que 4.99 constant

Ce sont des capteurs tout ou rien ou des capteurs analogiques?

[bewokxxxx]

je sais pas trop comment mais les problemes sont résolu je pense que cest du au masse et au fait que certaine valeur etait codé a 4.99 au lieu de 4.97

merci

[fdufnews]

Tu ne réponds pas à la question.
Si ce sont des capteurs tout ou rien il faut utiliser digitalRead() et non analogRead().

@bewokxxxx

je pense que cest du au masse et au fait que certaine valeur etait codé a 4.99 au lieu de 4.97

Tu es là dans le bruit de conversion

[bewokxxxx]

cest pas tout ou rien, on lit 4.99V quand cest fermé et environ 3.90 quand cest ouvert

[fdufnews]

C'est quoi exactement ces capteurs?

[bewokxxxx]

les capteurs positions A2 A0 A1 sont des capteur mécanique unidirectionnel

le capteur de la dame est un capteur inductif

et le capteur porte (dont je veux faire l'interruption) est un capteur magnétique

je peux envoyé les relevés de voltage lorsque les capteurs sont ouverts et fermés

[fdufnews]

Fil de discussion clos.
La suite par là

Interruption arduino

Oui, mais ce n'est pas une bonne solution. L'utilisation de digitalRead() apporte une certaine immunité au peerturbations et à la dérive de l'alimentation dans le temps que tu n'auras pas avec analogRead(). Une lecture analogique est 10 fois plus lente qu'une lecture digitale. C'est comme si tu plantais des clous avec un tournevis et qu'a ma proposition d'utiliser un marteau tu répondais " oui, d'accord, mais ça marche comme ça alors je vais continuer avec le tournevis"