Interruption arduino + keypad

bewokxxxx · November 27, 2023, 2:06pm

toujours dans le cadre d'un compacteur, le projet est terminé a 95%, mais il me reste a connecter un capteur magnétique sur une porte.
lorsque la porte est fermé j'ai plus que 4.96 et quand la porte est ouverte j'ai moins donc le seuil cest 4.96V.
je narrive pas a codé cette interuption soit elle n'est jamais lu soit elle reste bloqué dedans, j'ai essayé plusieurs méthode non concluante.

voici le code complet :

#include <U8g2lib.h>
#include <Keypad.h>
#include <Arduino.h>
#include <avr/io.h>
#include <avr/interrupt.h>

U8G2_ST7920_128X64_F_SW_SPI u8g2(U8G2_R0, /* clock=*/ 8, /* data=*/ 7, /* CS=*/ 6, /* 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 10s");
  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 10s");
  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 : 2min 50s");
  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 : 2min 50s");
  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.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 == 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();
}

const int doorPin = A9; // Broche pour la porte (A9)
volatile bool doorOpen = false; // État de la porte (initialisé à fermé)

void doorStateChanged() 
{
  float voltage = analogRead(doorPin) * (5.0 / 1023.0); // Lecture de la tension
  doorOpen = (voltage < 4.95); // Mettre à jour l'état de la porte en fonction du seuil de 4V
}



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);
  pinMode(doorPin, INPUT_PULLUP); // Activer la résistance de pull-up interne
  attachInterrupt(digitalPinToInterrupt(doorPin), doorStateChanged, CHANGE); 

}



void loop() 
{
  if (doorOpen) {
    // La porte est ouverte, exécutez ici le code correspondant
    Serial.println("La porte est ouverte !");
  } else {
    // La porte est fermée, exécutez ici le code correspondant
    Serial.println("La porte est fermée.");
  }
  delay(1000); // Léger délai pour éviter les lectures trop rapides

  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)
        }
      }
    }
  }
}

et voici la parti ou ya l'interruption (non fonctionnel) je les mise dans le main mais j'ai tester en dehors etc j'ai meme fais a la main avec les registres sans succes)


const int doorPin = A9; // Broche pour la porte (A9)
volatile bool doorOpen = false; // État de la porte (initialisé à fermé)

void doorStateChanged() 
{
  float voltage = analogRead(doorPin) * (5.0 / 1023.0); // Lecture de la tension
  doorOpen = (voltage < 4.95); // Mettre à jour l'état de la porte en fonction du seuil de 4V
}



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);
  pinMode(doorPin, INPUT_PULLUP); // Activer la résistance de pull-up interne
  attachInterrupt(digitalPinToInterrupt(doorPin), doorStateChanged, CHANGE); 

}



void loop() 
{
  if (doorOpen) {
    // La porte est ouverte, exécutez ici le code correspondant
    Serial.println("La porte est ouverte !");
  } else {
    // La porte est fermée, exécutez ici le code correspondant
    Serial.println("La porte est fermée.");
  }
  delay(1000); // Léger délai pour éviter les lectures trop rapides

PerryBebbington · November 27, 2023, 6:37pm

@bewokxxxx

Post mis dans la mauvaise section, on parle anglais dans les forums généraux. ➜ déplacé vers le forum francophone.

Merci de prendre en compte les recommandations listées dans "Les bonnes pratiques du Forum Francophone".

jpbbricole · November 27, 2023, 7:41pm

Bonsoir bewokxxxx

Dans ton interruption tu lis doorPin de façon analogique alors que tu déclares:
pinMode(doorPin, INPUT_PULLUP); // Activer la résistance de pull-up interne

Si 1 côté du contact de porte est au GND et l'autre à doorPin, tu peux simplement lire avec un digitalRead(doorPin), ça vaut LOW (false ou 0) si la porte est fermée et un HIGH (true ou 1) si elle est ouverte.

donc ton interruption peut être:

void doorStateChanged() 
{
  doorOpen = digitalRead(doorPin);
}

A+
Cordialement
jpbbricole

fdufnews · November 27, 2023, 8:20pm

@bewokxxxx

Cela recoupe ma remarque dans l'autre fil de discussion que tu as ouvert et à laquelle tu n'as pas répondu.

Je pense que tu te crées des complications inutiles.

bewokxxxx · November 28, 2023, 8:33am

je crois avoir compris ce que tu veux dire mais si on a pas 0V et 5V ca fonctionne quand meme en digitalRead ?

jpbbricole · November 28, 2023, 9:06am

Bonjour bewokxxxx

J'ai fait l'essai avec une tension variable sur A0, En passant de 0 à 5V, on passe de LOW à HIGH à ~2,4V et en passant de 5 à 0V. on passe de HIGH à LOW à ~2V.

Je ne connais pas ton installation de contact de porte, mais si d'un côté du contact tu as GND et de l'autre côté, l'entrée de l'Arduino et que tu initialises l'entrée avec PULLUP, tu as 5V (ou à peu près) quand le contact est ouvert et 0 (ou à peu près) quand le contact est fermé.

Cordialement
jpbbricole

fdufnews · November 28, 2023, 9:30am

Tu ne donnes pas assez de détails sur les équipements que tu mets en œuvre et on ne peut pas t'aider efficacement.
Tu parles de capteurs mais sans donner d'info sur leur technologie (interrupteur, sortie logique collecteur ouvert, sortie logique totem pole, ....).
Ton schéma donne à penser qu'il manque une masse et/ou une alimentation entre ces capteurs et ton arduino.

bewokxxxx · November 28, 2023, 9:44am

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

bewokxxxx · November 28, 2023, 9:50am

tu peux me montrer le programme que tu as utilisé pour faire ton test stp ca m'aiderais grandement, merci

jpbbricole · November 28, 2023, 9:56am

Dans les exemples de L'IDE Arduino, Digital Read Serial avec A0 comme port.

bewokxxxx · November 28, 2023, 10:04am

ah oui je connaissais pas les exemples tres bien merci

bewokxxxx · November 28, 2023, 10:08am

donc j'ai testé le capteur sur A9 et 52 et il reste a 1 tout le temps vu que ouvert il est a 3.90 - 4.10V et fermé a 5V, ya une solution pour changer le seuil de bascule ou pas ?

jpbbricole · November 28, 2023, 10:14am

Comment as-tu câblé ton capteur, fais un petit dessin à main levée

bewokxxxx · November 28, 2023, 10:22am

j'ai un fil bleu et un fil maron/rouge, j'ai mit le rouge sur le 5V arduino et le bleu sur le port A9 (ou 52)

fdufnews · November 28, 2023, 11:14am

Donc des interrupteurs qui fonctionnent en tout ou rien. Si ils ne sont raccordés à rien d'autre par ailleurs, il faut :

les raccorder à ton Arduino entre une entrée et GND.
initialiser l'entrée en INPUT_PULLUP
lire leur état avec digitalRead()

Là, il faut encore plus d'info. Ce type de capteur sort quelque fois en collecteur ouvert, d'autres fois en présentant une tension. Il faudrait vérifier la référence du capteur et trouver sa doc.

Même remarque qu'au dessus il faut plus de détail pour savoir comment l'utiliser.

Une chose est quasiment certaine, ces capteurs ont peu de chance d'être des capteurs analogique. Donc leur lecture se fera sans doute par des digitalRead() mais par contre il y aura peut-être des adaptations de niveau à faire (ou pas).

Autre chose, ce serait bien de continuer ces échanges sur un seul fil de discussion.
Je te propose donc:

soit fermer l'autre fil de discussion
soit coller ce fil de discussion à la suite de l'autre

jpbbricole · November 28, 2023, 11:39am

Bonjour bewokxxxx

As tu une référence sur ce contact?
S'il n'y a que 2 fils sur ton capteur magnétique, on peut en déduire qu'il a, à l'intérieur, un contact "sec", donc je mettrai le fil rouge sur A9 et le bleu à GND, avec une initialisation INPUT_PULLUP
Fais l'essai, en mesurant le potentiel ouvert/fermé.

A+
Cordialement
jpbbricole

bewokxxxx · November 28, 2023, 1:14pm

fdufnews:

bewokxxxx:

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

Donc des interrupteurs qui fonctionnent en tout ou rien. Si ils ne sont raccordés à rien d'autre par ailleurs, il faut :

les raccorder à ton Arduino entre une entrée et GND.

initialiser l'entrée en INPUT_PULLUP

lire leur état avec digitalRead()

bewokxxxx:

le capteur de la dame est un capteur inductif

Là, il faut encore plus d'info. Ce type de capteur sort quelque fois en collecteur ouvert, d'autres fois en présentant une tension. Il faudrait vérifier la référence du capteur et trouver sa doc.

bewokxxxx:

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

Même remarque qu'au dessus il faut plus de détail pour savoir comment l'utiliser.

Une chose est quasiment certaine, ces capteurs ont peu de chance d'être des capteurs analogique. Donc leur lecture se fera sans doute par des digitalRead() mais par contre il y aura peut-être des adaptations de niveau à faire (ou pas).

Autre chose, ce serait bien de continuer ces échanges sur un seul fil de discussion.
Je te propose donc:

soit fermer l'autre fil de discussion

soit coller ce fil de discussion à la suite de l'autre

je ne sais pas comment le fermé mais disons que nous poursuivons sur celui la j'ai mis "solution" sur un commentaire sur lautre sujet.

pour ce qui est des 2 premiers type de capteur, vu que je n'ai pas dinterruption ou autre, mon code fonctionne tres bien en analogique, cest pour la porte et le capteur magnétique, je l'ai mit en digital read comme conseigné et je vais chercher les détails

terwal · November 28, 2023, 1:17pm

Je ne serais te répondre exactement, mais il me semble pas très sain de changer la tension de bascule des niveaux logiques, si il est au alentour de 5V/2, c'est pour avoir des niveaux les plus francs possible.
Un workaround de bidouille, serait de lire la valeur analogique et de déterminer toi même l'état, mais faut-il que la valeur soit suffisamment stable et l'ADC suffisamment précis et stable.

bewokxxxx · November 28, 2023, 1:42pm

cest ce que j'ai fais pour les autres capteurs le seuil est a 4.10 en général du coup je met que si la tensione est au dessus de 4.97V le capteurs est fermé sinon il est ouvert (avec des vérifications de tension etc) mais du coup ca fonctionne pas pour une interruption.

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
    }
}

(jai mis dautres info dans la réponse suivante )

bewokxxxx · November 28, 2023, 1:51pm

voici le capteur (avec le seul mot gravé dessus : rodman ) et ses deux cables :

jai cablé le bleu directe a la masse la ou elles sont toutes connecté, et le marron a A9 directement. j'ai testé avec lexemple ca met 0 0 0 0 quand cest fermé et quand cest ouvert 0 1 0 1 0 1

voici le voltage (avec ce cablage) quand le capteur est ouvert

et quand cest fermé

(je ne me suis pas trompé dimage)

Topic		Replies	Views
Machine a état, avec écran LCD et Keypad Français	169	1726	September 10, 2024
Probleme alimentation Arduino et LCD Français	19	493	November 28, 2023
Deux thermocouples K - LCD - incrémentation des alarmes - mise en veille du buzzer Français	17	101	February 20, 2026
Projet pour un étudiant en électromécanique Français	36	272	December 30, 2025
Porte poulailler économique autonome Réalisations et Projets Finis	11	357	January 3, 2026

Interruption arduino + keypad

Related topics