Experimentboy

Table de tir Pyrotechnique - ExperimentBoy

Jun 9th, 2018
14,702
1
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 45.44 KB | None | 1 0
  1. #include <TM1637.h>
  2. #include <Wire.h>
  3. #include <SPI.h>
  4. #include <RF24.h>
  5. #include <LiquidCrystal_I2C.h>
  6. #include <Keypad.h>
  7.  
  8. LiquidCrystal_I2C lcd(0x27,20,4);
  9.  
  10. const byte ROW = 4;
  11. const byte COL = 4;
  12. char keypress;
  13. char keys[ROW][COL] =
  14. {
  15.   {'1','2','3','A'},
  16.   {'4','5','6','B'},
  17.   {'7','8','9','C'},
  18.   {'*','0','#','D'}
  19. };
  20. byte pin_row[ROW] = {5, 4, 3, 2};
  21. byte pin_col[COL] = {9, 8, 7, 6};
  22.  
  23. Keypad keypad = Keypad(makeKeymap(keys), pin_row, pin_col, ROW, COL);
  24.  
  25. TM1637 disp1(34,14), disp2(35,14), disp3(36,14), disp4(37,14), disp5(38,14), disp6(39,14), disp7(40,14), disp8(41,14), disp9(42,14), disp10(43,14), disp11(44,14), disp12(45,14);
  26.  
  27. TM1637 displays[12] = {disp1, disp2, disp3, disp4, disp5, disp6, disp7, disp8, disp9, disp10, disp11, disp12};
  28.  
  29. byte display_brightness = 2; //niveau de lumière des afficheurs, 7 = max
  30. #define flag_display_active 20 //valeur arbitraire, utilisée pour déterminer que l'on doit activer et afficher les valeurs sur tous les afficheurs actifs, pour éviter de lancer delayToDisplay() avec une boucle for
  31. #define flag_display_non_active 21
  32. #define flag_display_all 22
  33.  
  34. /*
  35. Pour les display, on peut afficher des lettres, exemples:
  36. int8_t SEGA[] = {5, 14, 16, 10};
  37. int8_t LEGO[] = {21, 14, 16, 0};
  38. int8_t HEAT[] = {17, 14, 10, 27};
  39. int8_t INIT[] = {19, 24, 19, 27};
  40. int8_t STOP[] = {5, 27, 0, 25};
  41.  
  42. On peut balancer une liste de taille [4] directement dans .display, ou écrire un digit manuellement:
  43.   tm1637.point(false);
  44.   tm1637.display(0, DispMSG[0]);
  45.   tm1637.display(DispMSG);
  46. */
  47. #define radio_channel 42
  48. #define pin_radio_CSN 17
  49. #define pin_radio_CE 16
  50. #define radio_data RF24_250KBPS //vitesse de transmission faible pour portée max
  51. #define radio_power RF24_PA_HIGH //puissance de transmission, MIN, LOW, HIGH, MAX
  52. RF24 radio(pin_radio_CE, pin_radio_CSN);
  53.  
  54. const byte address[][6] = {"XXXXX1","XXXXX2"}; //Ici, j'ai changé les addresses, hein, parce que le but c'est que ce soit sécurisé, NAN MAIS FAIS MARCHER TA TÊTE UN PEU !
  55.  
  56. byte pin_output[] = {22,23,24,25,26,27,28,29,30,31,32,33}; //pins des sorties vers les mosfets
  57.  
  58. #define pin_trigger_button 11
  59. #define pin_light_button 13
  60. #define pin_trigger_external 12
  61. #define pin_safety 10
  62. #define pin_buzzer 15
  63.  
  64. #define selector_menuMain 0
  65. #define selector_menuOutputSelection 1
  66. #define selector_menuSettings 2
  67. #define selector_menuBrightness 3
  68. #define selector_menuSleep 4
  69. #define selector_menuOutputDisplay 5
  70. #define selector_menuUnit 6
  71. #define selector_menuDelaySet 7
  72. #define selector_menuTriggerMode 8
  73. #define selector_menuTriggerConfirmation 9
  74. #define selector_menuTrigger 10
  75. #define selector_menuTriggerRadio 11
  76. byte selector = selector_menuMain; //Variable de détermination du menu suivant à ouvrir, 0 = menu principal
  77.  
  78. bool settings_ok = false; // Variable qui permet de vérifier si les réglages ont déjà été faits, pour activer l'option de lancement rapide au menu principal
  79.  
  80. #define trigger_mode_remote 30
  81. #define trigger_mode_button 31
  82. #define trigger_mode_external 32
  83. byte trigger_mode;
  84. unsigned long output_duration = 500000; // Temps de basculement de sortie, enµs
  85. bool safety = false; //variable d'état de la sécurité
  86. char message_trigger[] = "TRIGGER", message_safety[] = "SAFETY", message_stop[] = "STOP"; //messages codes à recevoir pour déclencer
  87.  
  88. byte output_number = 1; //Variable du nombre de sorties sélectionnées, par défaut 1
  89.  
  90. unsigned long delays[] = {0,0,0,0,0,0,0,0,0,0,0,0}, output_time[] = {0,0,0,0,0,0,0,0,0,0,0,0};
  91. unsigned long trigger_start_time;
  92. #define unit_msdec 0
  93. #define unit_ms 1
  94. #define unit_s 2
  95. byte unit = unit_ms;
  96. byte unit_previous = unit;
  97.  
  98.  
  99. void setup() {
  100.     Serial.begin(115200);
  101.     Serial1.begin(115200);
  102.  
  103.     lcd.init();
  104.     lcd.backlight();
  105.  
  106.     radio.begin();
  107.     radio.setChannel(radio_channel); //fréquence (max 125)
  108.    
  109.     radio.setAutoAck(1); //active (par défaut, ON) la vérification de transmission de paquet
  110.     //Pour EMETTEUR:
  111.     radio.setRetries(2,10);
  112.     //Définit le délai (par défaut, 0=250µs, puis on rajoute n fois ce délai) puis le nombre de retry d'envois des données (max 15), on augmente le délai si distance
  113.  
  114.     radio.setCRCLength(RF24_CRC_8); //taille du code de vérification à la fin du paquet, 8 ou 16 bits (plus lourd, du con)
  115.     radio.openWritingPipe(address[0]); //addresse d'écriture, sur 5 octets
  116.     radio.openReadingPipe(1,address[1]); //addresse de lecture, sur 5 octets, et pipe numéro 1 (de 1 à 6), on laisse toujours le 1
  117.     // ON INITIALISE LES ADRESSES A L'INVERSE ENTRE LE RECEPTEUR ET L'EMETTEUR, il suffit ensuite de changer startListening / stopListening à la volée pour transmettre dans l'autre sens
  118.     radio.setPALevel(radio_power);
  119.     radio.setDataRate(radio_data);
  120.     radio.startListening();
  121.    
  122.     displays[0].init();
  123.     displays[0].set(display_brightness);
  124.     //digits[]={1,2,3,4};
  125.  
  126.     for(byte n = 0; n<12; n++)
  127.     {
  128.         pinMode(pin_output[n],OUTPUT);
  129.         displays[n].init();
  130.         displays[n].set(display_brightness);
  131.     }
  132.  
  133.     pinMode(pin_trigger_button, INPUT_PULLUP);
  134.     pinMode(pin_trigger_external, INPUT_PULLUP);
  135.     pinMode(pin_light_button, OUTPUT);
  136.     pinMode(pin_safety,OUTPUT);
  137.  
  138.     lcd.setCursor(3,1); lcd.print("EXPERIMENTBOY");
  139.     tone(pin_buzzer, 2000,250);
  140.     delay(750);
  141.    
  142.     //par défaut, on allume la première sortie et le premier afficheur
  143.     Serial1.print("LN0");
  144.     delayToDisplay(0);
  145. }
  146.  
  147. byte menuMain()
  148. {
  149.     lcd.clear(); lcd.noBlink();
  150.    
  151.     lcd.setCursor(0,0); lcd.print("A: Lancement"); //Vers sélection des sorties
  152.     lcd.setCursor(0,1); lcd.print("B: Options"); // Vers réglage lumi, mode veille
  153.     lcd.setCursor(0,2); lcd.print("C: Test ligne");
  154.     if(settings_ok) {lcd.setCursor(0,3); lcd.print("D: Lancement rapide");}
  155.     else {lcd.setCursor(0,3); lcd.print("D: Trigger Radio");}
  156.     //lcd.blink();
  157.  
  158.     keypress = keypad.waitForKey();
  159.     while(!isAlpha(keypress)) {keypress = keypad.waitForKey();}
  160.     if (keypress == 'A') selector = selector_menuOutputSelection;
  161.     else if (keypress == 'B') selector = selector_menuSettings;
  162.     else if (keypress == 'C') lineTest();
  163.     else if(keypress == 'D' && settings_ok) selector = selector_menuTriggerConfirmation;
  164.     else if(keypress == 'D' && !settings_ok) selector = selector_menuTriggerRadio;
  165.     //else selector = selector_menuMain;
  166.  
  167.     return selector;
  168. }
  169.  
  170. byte menuOutputSelection()
  171. {
  172.     String temp_output_number = String(output_number);
  173.     //if(output_number == 0) temp_output_number = "";
  174.     //bool valid_number = false;
  175.     lcd.clear(); lcd.blink();
  176.     lcd.print("Nb de sorties: 1-12");
  177.     lcd.setCursor(0,3); lcd.print("D:Eff           #:OK");
  178.     lcd.setCursor(0,1); lcd.print("Selection: "); lcd.print(temp_output_number);
  179.    
  180.     keypress = keypad.waitForKey();
  181.     if(keypress != '#') temp_output_number = "";
  182.    
  183.     while(1)
  184.     {
  185.         if(isDigit(keypress) && (temp_output_number.length()<2))
  186.         {
  187.             temp_output_number.concat(keypress); //on ajoute les caractères tapés au clavier à une chaîne, que l'on va ensuite transformer en int à la validation, et on vérifie si ça colle à un nombre de sorties possible
  188.         }
  189.        
  190.         else if(keypress == 'D')
  191.         {
  192.             temp_output_number = "";
  193.             lcd.setCursor(11,1);
  194.             lcd.print("         ");
  195.             lcd.setCursor(11,1);
  196.         }
  197.  
  198.         else if (keypress == '#')
  199.         {
  200.             if(temp_output_number.toInt() == 0 || temp_output_number.toInt()>12)
  201.             {
  202.                 //valid_number = false;
  203.                 temp_output_number = "";
  204.                 lcd.setCursor(11,1); lcd.print("NOPE");
  205.                 delay(1000); lcd.setCursor(11,1); lcd.print("    "); lcd.setCursor(11,1);
  206.             }
  207.             else
  208.             {
  209.                 output_number = temp_output_number.toInt();
  210.                
  211.                 Serial1.print("LT"+temp_output_number); // transmettre à l'autre arduino le nombre de leds à allumer
  212.                
  213.                 displayOff(flag_display_non_active);
  214.                 delayToDisplay(flag_display_active);
  215.                
  216.                 selector = selector_menuUnit;
  217.                 return selector;
  218.             }
  219.         }
  220.        
  221.         lcd.setCursor(11,1); lcd.print("  ");
  222.         lcd.setCursor(11,1); lcd.print(temp_output_number);
  223.         keypress = keypad.waitForKey();
  224.     }
  225. }
  226.  
  227. byte menuSettings()
  228. {
  229.     lcd.clear(); lcd.noBlink();
  230.     lcd.print("A: Luminosite 7seg");
  231.     lcd.setCursor(0,1); lcd.print("B: Mode veille");
  232.     lcd.setCursor(0,2); lcd.print("C: Test sorties");
  233.     lcd.setCursor(0,3); lcd.print("D: Menu principal");
  234.    
  235.     keypress = keypad.waitForKey();
  236.    
  237.     while(!isAlpha(keypress)) {keypress = keypad.waitForKey();}
  238.    
  239.     switch(keypress)
  240.     {
  241.         case 'A': selector = selector_menuBrightness; break;
  242.         case 'B': selector = selector_menuSleep; break;
  243.         case 'C': outputTest(); break;
  244.         case 'D': selector = selector_menuMain; break;
  245.     }
  246.     return selector;
  247. }
  248.  
  249. byte menuBrightness()
  250. {
  251.     byte keypress_byte;
  252.     lcd.clear(); lcd.blink();
  253.     lcd.setCursor(16,3); lcd.print("#:OK");
  254.     lcd.setCursor(0,1); lcd.print("Actuelle: "); lcd.print(display_brightness);
  255.     lcd.setCursor(0,0); lcd.print("Luminosite: 0-7?");
  256.  
  257.     delayToDisplay(flag_display_active); //allume les afficheurs actifs (par défaut, le 1er, en unité 0000ms)
  258.  
  259.     keypress = keypad.waitForKey();
  260.  
  261.     while (keypress != '#')
  262.     {
  263.         if(isDigit(keypress))
  264.         {
  265.             keypress_byte = ((String)keypress).toInt();
  266.        
  267.             if(keypress_byte >=7)
  268.                 keypress_byte = 7;
  269.                
  270.             display_brightness = keypress_byte;
  271.             lcd.setCursor(10,1); lcd.print(display_brightness);
  272.  
  273.             for (byte n = 0; n<12; n++)
  274.             {
  275.                 displays[n].set(display_brightness);
  276.             }
  277.             delayToDisplay(flag_display_active);
  278.         }
  279.         keypress = keypad.waitForKey();
  280.     }
  281.    
  282.     //displayOff(flag_display_active); //éteint les afficheurs
  283.     //Serial1.print("L0");
  284.     selector = selector_menuMain;
  285.     return selector;
  286. }
  287.  
  288. byte menuSleep()
  289. {
  290.     lcd.clear();        lcd.print("    Mode Veille");
  291.     lcd.setCursor(0,1); lcd.print("  Appuyez sur une");
  292.     lcd.setCursor(0,2); lcd.print("touche pour rallumer");
  293.     lcd.setCursor(0,3); lcd.print("A:Menu          #:Go");
  294.    
  295.     keypress = keypad.waitForKey();
  296.    
  297.     while(keypress != 'A' && keypress != '#') {keypress = keypad.waitForKey();}
  298.    
  299.     if(keypress == '#')
  300.     {
  301.         displayOff(flag_display_all);
  302.         lcd.noBacklight();
  303.         Serial1.print("L0");
  304.        
  305.         keypad.waitForKey();
  306.        
  307.         delayToDisplay(flag_display_active);
  308.         Serial1.print("LT" + (String)output_number);
  309.         lcd.backlight();
  310.        
  311.     }
  312.    
  313.     selector = selector_menuMain; return selector;
  314. }
  315.  
  316. byte menuUnit()
  317. {
  318.     lcd.clear(); lcd.noBlink();
  319.     lcd.print("Selection de l'unite");
  320.     lcd.setCursor(0,1); lcd.print("A: 00.00ms");
  321.     lcd.setCursor(0,2); lcd.print("B: 0000ms");
  322.     lcd.setCursor(0,3); lcd.print("C: 000s");
  323.    
  324.     while(1)
  325.     {
  326.         keypress = keypad.waitForKey();
  327.        
  328.         switch(keypress)
  329.         {
  330.             case 'A':
  331.                 unit = unit_msdec;
  332.                 delayToDisplay(flag_display_active);
  333.                 selector = selector_menuDelaySet;
  334.                 return selector;
  335.                 break;
  336.             case 'B':
  337.                 unit = unit_ms;
  338.                 delayToDisplay(flag_display_active);
  339.                 selector = selector_menuDelaySet;
  340.                 return selector;
  341.                 break;
  342.             case 'C':
  343.                 unit = unit_s;
  344.                 delayToDisplay(flag_display_active);
  345.                 selector = selector_menuDelaySet;
  346.                 return selector;
  347.                 break;
  348.             default: break;
  349.         }
  350.     }
  351.    
  352.    
  353. }
  354.  
  355. void displayOff(byte display_number)
  356. {
  357.     //Eteint l'afficheur donné, tous si display_number = 0
  358.     switch (display_number)
  359.     {
  360.         case flag_display_active:
  361.             for(byte n = 0; n<output_number; n++)
  362.             {
  363.                 displays[n].point(false);
  364.                 displays[n].init();
  365.             }
  366.             break;
  367.            
  368.         case flag_display_all:
  369.             for(byte n = 0; n<12; n++)
  370.             {
  371.                 displays[n].point(false);
  372.                 displays[n].init();
  373.             }
  374.             break;
  375.            
  376.         case flag_display_non_active:
  377.             for(byte n = output_number; n<12; n++)
  378.             {
  379.                 displays[n].point(false);
  380.                 displays[n].init();
  381.             }
  382.             break;
  383.        
  384.         default:
  385.             displays[display_number].point(false);
  386.             displays[display_number].init();
  387.     }
  388. }
  389.  
  390. void delayToDisplay(byte display_number)
  391. {
  392.     //Traduit le delays[] de l'afficheur display_number en chiffres pour l'afficheur, en fonction de l'unité, et l'affiche
  393.     int8_t temp_digits[4];
  394.    
  395.     if(display_number == flag_display_active) //dans le cas où on demande d'afficher les temps sur tous les afficheurs actifs, la fonction se fait tourner elle-même pour tous les afficheurs jusqu'au nombre de sorties
  396.     {
  397.         for(byte n=0; n<output_number; n++)
  398.             delayToDisplay(n);
  399.     }
  400.    
  401.     else
  402.     {
  403.         switch(unit)
  404.         {
  405.             case unit_msdec:
  406.                  displays[display_number].point(true);
  407.                  temp_digits[0] = (delays[display_number] / 10000) % 10; //récupération du chiffre des dizaines de milliers de µs
  408.                  temp_digits[1] = (delays[display_number] / 1000) % 10; //récupération du chiffre des milliers de µs
  409.                  temp_digits[2] = (delays[display_number] / 100) % 10; //récupération du chiffre des centaines de µs
  410.                  temp_digits[3] = (delays[display_number] / 10) % 10; //récupération du chiffre des dizaines de µs
  411.                  displays[display_number].display(temp_digits);
  412.                  break;
  413.                    
  414.             case unit_ms:
  415.                  displays[display_number].point(false);
  416.                  temp_digits[0] = (delays[display_number] / 1000000) % 10;
  417.                  temp_digits[1] = (delays[display_number] / 100000) % 10;
  418.                  temp_digits[2] = (delays[display_number] / 10000) % 10;
  419.                  temp_digits[3] = (delays[display_number] / 1000) % 10;
  420.                  displays[display_number].display(temp_digits);
  421.                  break;
  422.                  
  423.             case unit_s:
  424.                  displays[display_number].point(false);
  425.                  temp_digits[0] = 27; //affiche un 't' en premier chiffre, pour indiquer qu'on est en secondes et pas en ms
  426.                  temp_digits[1] = (delays[display_number] / 100000000) % 10;
  427.                  temp_digits[2] = (delays[display_number] / 10000000) % 10;
  428.                  temp_digits[3] = (delays[display_number] / 1000000) % 10;
  429.                  displays[display_number].display(temp_digits);
  430.                  break;
  431.                  
  432.             default: break;
  433.         }
  434.     }
  435.  
  436. }
  437.  
  438. String delayToLCD(byte display_number)
  439. {
  440.     //Retourne la chaîne de caractères à afficher, pour afficher le delays[] déjà stocké en mémoire sur le LCD
  441.     String delay_text="";
  442.    
  443.     switch(unit)
  444.     {
  445.         case unit_msdec:
  446.              delay_text.concat((delays[display_number] / 10000) % 10);
  447.              delay_text.concat((delays[display_number] / 1000) % 10);
  448.              delay_text.concat('.');
  449.              delay_text.concat((delays[display_number] / 100) % 10);
  450.              delay_text.concat((delays[display_number] / 10) % 10);
  451.              return delay_text;
  452.              break;
  453.                
  454.         case unit_ms:
  455.              delay_text.concat((delays[display_number] / 1000000) % 10);
  456.              delay_text.concat((delays[display_number] / 100000) % 10);
  457.              delay_text.concat((delays[display_number] / 10000) % 10);
  458.              delay_text.concat((delays[display_number] / 1000) % 10);
  459.              return delay_text;
  460.              break;
  461.              
  462.         case unit_s:
  463.              delay_text.concat((delays[display_number] / 100000000) % 10);
  464.              delay_text.concat((delays[display_number] / 10000000) % 10);
  465.              delay_text.concat((delays[display_number] / 1000000) % 10);
  466.              return delay_text;
  467.              break;
  468.              
  469.         default: return ""; break;
  470.     }
  471. }
  472.  
  473. byte menuDelaySet()
  474. {
  475.     bool finish = false;
  476.     bool previous = false;
  477.     byte temp_output_current = 0; //variable local de la sortie en cours de réglage
  478.     String temp_delay_string = "";
  479.     unsigned long temp_coef = 1000;
  480.    
  481.     lcd.clear(); lcd.blink(); lcd.print("Reglage en ");
  482.     switch(unit)
  483.     {
  484.         case unit_msdec: lcd.print("00.00ms"); break;
  485.         case unit_ms: lcd.print("0000ms"); break;
  486.         case unit_s: lcd.print("000s"); break;
  487.         default: lcd.print("ERR"); break;
  488.     }
  489.     lcd.setCursor(0,1); lcd.print("Sortie: ");
  490.     lcd.setCursor(0,2); lcd.print("Reglage: ");
  491.     lcd.setCursor(0,3); lcd.print("D:Eff "); lcd.print("C:Prec "); lcd.print("#:Suiv");
  492.     //lcd.setCursor(0,4); lcd.print("Retour:");
  493.    
  494.     while(temp_output_current < output_number) // t finish repasse à faux
  495.     {
  496.         Serial1.print("LN" + (String) temp_output_current);
  497.         lcd.setCursor(8,1); lcd.print("  ");
  498.         lcd.setCursor(8,1); lcd.print(temp_output_current+1);
  499.         lcd.setCursor(13,3);
  500.         if (temp_output_current == output_number-1) lcd.print("#:OK  ");
  501.         else lcd.print("#:Suiv");
  502.        
  503.         while(!finish)
  504.         {
  505.             if (unit_previous!=unit){            //remise à 0 des délais si chgmt d'unité
  506.                 for (byte n=0; n<12; n++) delays[n]=0;
  507.                 delayToDisplay(flag_display_active);
  508.             }        
  509.             unit_previous = unit;
  510.            
  511.             if(unit == unit_msdec)
  512.             {
  513.                 lcd.setCursor(9,2);
  514.                 lcd.print(delayToLCD(temp_output_current));
  515.                 keypress=keypad.waitForKey();  //On rentre un chiffre (pas de virgule) ou valider (0000 par défaut)
  516.                
  517.                 while((keypress=='*' || keypress=='D') && keypress!='C')     //Si c'est une virgule ou suppr on redemande
  518.                 {
  519.                     keypress=keypad.waitForKey();
  520.                 }
  521.                
  522.                 if(keypress!='#' && keypress!='C')    //si on ne valide pas, c'est un chiffre
  523.                 {
  524.                     temp_delay_string=(((String)keypress).toInt());             //On enregistre ce chiffre
  525.                     lcd.setCursor(9,2); lcd.print("     ");
  526.                     lcd.setCursor(9,2); lcd.print(keypress);                    //afficher 1er chiffre
  527.                     temp_coef=1000;                                             //Coef vaut 1000 pour que le chiffre tapé soit converti [EX: 1ms vers 1000µs]
  528.                     keypress=keypad.waitForKey();                               //on en demande une entrée (chiffre, virgule ou valider)
  529.                    
  530.                     if (keypress!='#' && keypress!='*' && keypress!='D' && keypress!='C'){//si c'est un chiffre
  531.                         temp_delay_string.concat(((String)keypress).toInt());   //on le concatène
  532.                         lcd.print(keypress);                                    //afficher 2eme chiffre
  533.                         while(keypress!='#' && keypress!='*' && keypress!='D' && keypress!='C'){//on demande validation '#' ou virgule '*' ou delete 'D'
  534.                             keypress=keypad.waitForKey();
  535.                         }
  536.                     }
  537.                    
  538.                     if (keypress=='*' && keypress!='D' && keypress!='C')        //Si c'est une virgule '*'
  539.                     {
  540.                         lcd.print('.');                                         //afficher la virgule
  541.                         while((keypress=='#' || keypress=='*') && keypress!='D' && keypress!='C')//on demande un chiffre
  542.                         {
  543.                             keypress=keypad.waitForKey();
  544.                         }
  545.                         if (keypress!='D' && keypress!='C'){
  546.                         temp_delay_string.concat(((String)keypress).toInt());   //On concatène le 1er chiffre apres la virgule
  547.                         lcd.print(keypress);                                    //afficher 1er chiffre après la virgule
  548.                         temp_coef=100;                                          //Coef vaut 100 pour que le chiffre tapé soit converti [EX: 12.3ms (123 dans la mémoire) vers 12300µs]
  549.                         }
  550.                         keypress=keypad.waitForKey();
  551.                         while(keypress=='*'){                                   //pas de virgule
  552.                             keypress=keypad.waitForKey();
  553.                         }
  554.                         if (keypress!='#' && keypress!='D' && keypress!='C'){
  555.                             temp_delay_string.concat(((String)keypress).toInt());//On concatène le 2eme chiffre apres la virgule
  556.                             lcd.print(keypress);                                //afficher 2eme chiffre apres la virgule
  557.                             temp_coef=10;                                       //Coef vaut 10 pour que le chiffre tapé soit converti [EX: 12.34ms (1234 dans la mémoire) vers 12340µs]
  558.                         }
  559.                     }
  560.                     while(keypress!='#' && keypress!='D' && keypress!='C'){     //on demande validation '#' ou delete
  561.                         keypress=keypad.waitForKey();
  562.                     }                    
  563.                 }
  564.                
  565.                 if (keypress=='#'){ //Si on valide, on multiplie le chiffre enregistré, par le coef
  566.                     if(temp_delay_string != "") delays[temp_output_current]=temp_delay_string.toInt()*temp_coef;
  567.                     delayToDisplay(temp_output_current);
  568.                     temp_delay_string = "";
  569.                     lcd.setCursor(9,2); lcd.print("     ");
  570.                     lcd.setCursor(0,3); lcd.print(temp_delay_string);
  571.                     finish=true;
  572.                 }
  573.                
  574.                 if (keypress=='D'){
  575.                     lcd.setCursor(9,2); lcd.print("     ");
  576.                     temp_delay_string = "";
  577.                 }
  578.                
  579.                 if (keypress=='C'){
  580.                     temp_delay_string = "";
  581.                     lcd.setCursor(9,2); lcd.print("     ");
  582.                     previous = true;
  583.                     finish=true;
  584.                 }
  585.                
  586.             }
  587.            
  588.             else if (unit == unit_ms)
  589.             {                
  590.                 lcd.setCursor(9,2);
  591.                 lcd.print(delayToLCD(temp_output_current));
  592.                 keypress=keypad.waitForKey();
  593.                
  594.                 while(keypress=='D' && keypress!='C')     //Si c'est suppr on redemande
  595.                 {
  596.                     keypress=keypad.waitForKey();
  597.                 }
  598.                
  599.                 if(keypress!='#' && keypress!='C')    //si on ne valide pas, c'est un chiffre
  600.                 {
  601.                     temp_delay_string=(((String)keypress).toInt());             //On enregistre ce chiffre
  602.                     lcd.setCursor(9,2); lcd.print("     ");
  603.                     lcd.setCursor(9,2); lcd.print(keypress);                    //afficher 1er chiffre
  604.                     temp_coef=1000;                                           //Coef vaut 1000 pour que le chiffre tapé soit converti [EX: 1ms vers 1000µs]
  605.                     keypress=keypad.waitForKey();                               //on en demande une entrée (chiffre ou valider)
  606.                    
  607.                     if (keypress!='#' && keypress!='D' && keypress!='C'){       //si c'est un chiffre (2eme)
  608.                         temp_delay_string.concat(((String)keypress).toInt());   //on le concatène
  609.                         lcd.print(keypress);                                    //afficher 2eme chiffre
  610.                         keypress=keypad.waitForKey();
  611.                         if (keypress!='#' && keypress!='D' && keypress!='C'){   //si c'est un chiffre (3eme)
  612.                             temp_delay_string.concat(((String)keypress).toInt());   //on le concatène
  613.                             lcd.print(keypress);                                    //afficher 3eme chiffre
  614.                             keypress=keypad.waitForKey();
  615.                             if (keypress!='#' && keypress!='D' && keypress!='C'){   //si c'est un chiffre (4eme)
  616.                                 temp_delay_string.concat(((String)keypress).toInt());   //on le concatène
  617.                                 lcd.print(keypress);                                    //afficher 4eme chiffre
  618.                             }
  619.                         }
  620.                     }
  621.                    
  622.                     while(keypress!='#' && keypress!='D' && keypress!='C'){     //on demande validation '#' ou delete
  623.                         keypress=keypad.waitForKey();
  624.                     }                    
  625.                 }
  626.                
  627.                 if (keypress=='#'){ //Si on valide, on multiplie le chiffre enregistré, par le coef
  628.                     if(temp_delay_string != "") delays[temp_output_current]=temp_delay_string.toInt()*temp_coef;
  629.                     delayToDisplay(temp_output_current);
  630.                     temp_delay_string = "";
  631.                     lcd.setCursor(9,2); lcd.print("    ");
  632.                     lcd.setCursor(0,3); lcd.print(temp_delay_string);
  633.                     finish=true;
  634.                 }
  635.                
  636.                 if (keypress=='D'){
  637.                     lcd.setCursor(9,2); lcd.print("    ");
  638.                     temp_delay_string = "";
  639.                 }
  640.                
  641.                 if (keypress=='C'){
  642.                     temp_delay_string = "";
  643.                     lcd.setCursor(9,2); lcd.print("    ");
  644.                     previous = true;
  645.                     finish=true;
  646.                 }
  647.                
  648.             }
  649.             else if (unit == unit_s)
  650.             {
  651.                 lcd.setCursor(9,2);
  652.                 lcd.print(delayToLCD(temp_output_current));
  653.                 keypress=keypad.waitForKey();
  654.                
  655.                 while(keypress=='D' && keypress!='C')     //Si c'est suppr on redemande
  656.                 {
  657.                     keypress=keypad.waitForKey();
  658.                 }
  659.                
  660.                 if(keypress!='#' && keypress!='C')    //si on ne valide pas, c'est un chiffre
  661.                 {
  662.                     temp_delay_string=(((String)keypress).toInt());             //On enregistre ce chiffre
  663.                     lcd.setCursor(9,2); lcd.print("     ");
  664.                     lcd.setCursor(9,2); lcd.print(keypress);                    //afficher 1er chiffre
  665.                     temp_coef=1000000;                                             //Coef vaut 1000000 pour que le chiffre tapé soit converti [EX: 1s vers 1000000µs]
  666.                     keypress=keypad.waitForKey();                               //on en demande une entrée (chiffre ou valider)
  667.                    
  668.                     if (keypress!='#' && keypress!='D' && keypress!='C'){       //si c'est un chiffre (2eme)
  669.                         temp_delay_string.concat(((String)keypress).toInt());   //on le concatène
  670.                         lcd.print(keypress);                                    //afficher 2eme chiffre
  671.                         keypress=keypad.waitForKey();
  672.                         if (keypress!='#' && keypress!='D' && keypress!='C'){   //si c'est un chiffre (3eme)
  673.                             temp_delay_string.concat(((String)keypress).toInt());   //on le concatène
  674.                             lcd.print(keypress);                                    //afficher 3eme chiffre
  675.                         }
  676.                     }
  677.                    
  678.                     while(keypress!='#' && keypress!='D' && keypress!='C'){     //on demande validation '#' ou delete
  679.                         keypress=keypad.waitForKey();
  680.                     }                    
  681.                 }
  682.                
  683.                 if (keypress=='#'){ //Si on valide, on multiplie le chiffre enregistré, par le coef
  684.                     if(temp_delay_string != "") delays[temp_output_current]=temp_delay_string.toInt()*temp_coef;
  685.                     delayToDisplay(temp_output_current);
  686.                     temp_delay_string = "";
  687.                     lcd.setCursor(9,2); lcd.print("   ");
  688.                     lcd.setCursor(0,3); lcd.print(temp_delay_string);
  689.                     finish=true;
  690.                 }
  691.                
  692.                 if (keypress=='D'){
  693.                     lcd.setCursor(9,2); lcd.print("   ");
  694.                     temp_delay_string = "";
  695.                 }
  696.                
  697.                 if (keypress=='C'){
  698.                     temp_delay_string = "";
  699.                     lcd.setCursor(9,2); lcd.print("   ");
  700.                     previous = true;
  701.                     finish=true;
  702.                 }
  703.            
  704.             }
  705.         }
  706.         if (previous)
  707.         {
  708.             if(temp_output_current!=0)temp_output_current--;
  709.             lcd.setCursor(8,1); lcd.print("  ");
  710.             lcd.setCursor(8,1); lcd.print(temp_output_current+1);
  711.             previous = false;
  712.         }
  713.            
  714.         else
  715.             temp_output_current++;
  716.        
  717.         finish=false;
  718.                
  719.     }
  720.     Serial1.print("LT"+(String)output_number);
  721.     selector = selector_menuTriggerMode;
  722.     return selector;
  723. }
  724.  
  725. byte menuTriggerMode()
  726. {
  727.     //Fonction de sélection du mode de trigger
  728.     lcd.clear(); lcd.noBlink();
  729.     lcd.print("Mode de Trigger:");
  730.     lcd.setCursor(0,1); lcd.print("A: Telecommande");
  731.     lcd.setCursor(0,2); lcd.print("B: Bouton");
  732.     lcd.setCursor(0,3); lcd.print("C: Externe");
  733.    
  734.     keypress = keypad.waitForKey();
  735.    
  736.     while(keypress != 'A' && keypress != 'B' && keypress != 'C')
  737.     {
  738.         keypress = keypad.waitForKey();
  739.     }
  740.    
  741.     switch (keypress)
  742.     {
  743.         case 'A': trigger_mode = trigger_mode_remote; break;
  744.         case 'B': trigger_mode = trigger_mode_button; break;
  745.         case 'C': trigger_mode = trigger_mode_external; break;
  746.         default: break;
  747.     }
  748.     selector = selector_menuTriggerConfirmation;
  749.     return selector;
  750. }
  751.  
  752. byte menuTriggerConfirmation()
  753. {
  754.     settings_ok = true; //tag qui indique au menu principal que les réglages ont été faits, pour débloquer "lancement rapide"
  755.    
  756.     while(1)
  757.     {
  758.         lcd.clear(); lcd.noBlink();
  759.         lcd.print("    Confirmer ?");
  760.         lcd.setCursor(0,1); lcd.print("#: Valider");
  761.         lcd.setCursor(0,2); lcd.print("*: Test ligne");
  762.         lcd.setCursor(0,3); lcd.print("A: Menu Principal");
  763.        
  764.         keypress = keypad.waitForKey();
  765.        
  766.         while(keypress != '#' && keypress != '*' && keypress != 'A')
  767.             {
  768.                 keypress = keypad.waitForKey();
  769.             }
  770.        
  771.         switch (keypress)
  772.         {
  773.             case '#': selector = selector_menuTrigger; return selector; break;
  774.             case '*': lineTest(); break;
  775.             case 'A': selector = selector_menuMain; return selector; break;
  776.         }        
  777.     }
  778. }
  779.  
  780. byte menuTrigger()
  781. {
  782.     char radio_message_tab[32] = "";
  783.     String radio_message = "";
  784.     byte output_next = 0;
  785.    
  786.     lcd.clear(); lcd.noBlink();
  787.     lcd.print("    TRIGGER PRET");
  788.     tone(pin_buzzer, 2000, 250);
  789.     delay(1000);
  790.     lcd.setCursor(0,3); lcd.print("A: STOP");
  791.     lcd.setCursor(0,1); lcd.print("Standby: ");
  792.    
  793.     switch(trigger_mode)
  794.     {
  795.         case trigger_mode_button: lcd.print("Bouton"); break;
  796.         case trigger_mode_external: lcd.print("Externe"); break;
  797.         case trigger_mode_remote: lcd.print("Radio"); break;
  798.     }
  799.    
  800.     if(trigger_mode == trigger_mode_button)
  801.     {
  802.         digitalWrite(pin_light_button, 1);
  803.         while(digitalRead(pin_trigger_button))
  804.         {
  805.             if (keypad.getKey() == 'A')
  806.             {
  807.                 selector = selector_menuMain;
  808.                 digitalWrite(pin_light_button, 0);
  809.                 return selector;
  810.             }
  811.         }
  812.     }
  813.    
  814.     else if(trigger_mode == trigger_mode_external)
  815.     {
  816.         while(digitalRead(pin_trigger_external))
  817.         {
  818.             if (keypad.getKey() == 'A')
  819.             {
  820.                 selector = selector_menuMain;
  821.                 return selector;
  822.             }
  823.         }
  824.     }
  825.    
  826.     else if(trigger_mode == trigger_mode_remote)
  827.     {  
  828.         //HYPER IMPORTANT, si on a envoyé le signal trigger avant d'être en standby, il est toujours dans le buffer du module et va être lu quand on valide... donc on efface tout message déjà présent
  829.         radio_message_tab[32] = "";
  830.         radio.read(&radio_message_tab, sizeof(radio_message_tab));
  831.         radio_message_tab[32] = "";
  832.        
  833.        
  834.         while((String(radio_message_tab)).indexOf(String(message_trigger)) == -1) // String(radio_message_tab) != String(message_trigger)
  835.         {
  836.             //Serial.println("JE SUIS LA");
  837.             if(radio.available())
  838.             {  
  839.                 radio_message_tab[32] = "";
  840.                 //radio_message = "";
  841.                 //Serial.println("MESSAGE RECU");
  842.                 radio.read(&radio_message_tab, sizeof(radio_message_tab));
  843.                 //Serial.print("Message radio: "); Serial.println(radio_message_tab);
  844.                 //Serial.print("Message safety:"); Serial.println(message_safety);
  845.                 //radio_message = String(radio_message_tab);
  846.                
  847.                 if(String(radio_message_tab) == String(message_safety))
  848.                 {
  849.                     //Serial.print("LA SECURITEY FAIT SON TAF: ");
  850.                     Serial.println(safety);
  851.                     safety = !safety;
  852.                     digitalWrite(pin_safety, safety);
  853.                 }
  854.                
  855.                 else if (String(radio_message_tab) == String(message_stop))
  856.                 {
  857.                     selector = selector_menuMain;
  858.                     safety = false;
  859.                     digitalWrite(pin_safety, 0);
  860.                     digitalWrite(pin_light_button,0);  
  861.                     return selector;
  862.                 }  
  863.             }
  864.            
  865.             if (keypad.getKey() == 'A')
  866.             {
  867.                 selector = selector_menuMain;
  868.                 safety = false;
  869.                 digitalWrite(pin_safety, safety);  
  870.                 return selector;
  871.             }                              
  872.         }
  873.     }
  874.    
  875.     // LANCEMENT SEQUENCE //
  876.     trigger_start_time = micros(); //récupération du T0
  877.    
  878.     output_time[0] = trigger_start_time + delays[0];
  879.     for (byte n=1; n<output_number; n++)
  880.         output_time[n] = output_time[n-1] + delays[n];
  881.    
  882.     while(output_next < output_number && micros()<=(output_time[output_number-1]+output_duration+100)) //la condition de fin doit être que la dernière output a dépassé son temps de fin de déclenchement
  883.     {
  884.         if(output_time[output_next]<trigger_start_time) //on ne rentre dans l'anti-overflow que si on sait que le moment de déclenchement de la sortie suivante est plus petit que le moment de start
  885.         {
  886.             //on ne déclenche pas la sécu overflow après le dernier déclenchement, sinon on reste coincé
  887.             while(micros()>output_time[output_next])
  888.             {
  889.                 //sécu si l'output_time a overflow, on bloque déjà le temps que micros() overflow aussi, puis on bloque tant que micros() est en dessous du output_time
  890.                 for(byte n = 0; n<=output_next; n++)
  891.                 {
  892.                     if(digitalRead(pin_output[n]) && micros()>=(output_time[n]+output_duration)) digitalWrite(pin_output[n],0);
  893.                 }
  894.             }
  895.         }
  896.        
  897.         // pendant qu'on coince dans ces boucles, il faut vérifier sur toutes les sorties *précédentes* si on a dépassé le temps d'arrêt de déclenchement, output_time + output_duration
  898.        
  899.         while(micros()<output_time[output_next])
  900.         {
  901.             //pendant qu'on attend le temps de basculement de la sortie suivante, on vérifie si le temps est venu de couper les sorties précédentes, en vérifiant qu'elles sont encore actives pour optimisey
  902.             for(byte n = 0; n<=output_next; n++)
  903.             {
  904.                 if(digitalRead(pin_output[n]) && micros()>=(output_time[n]+output_duration)) digitalWrite(pin_output[n],0);
  905.             }
  906.         }
  907.        
  908.         if(output_next == output_number-1)
  909.         {
  910.             for(byte n = 0; n<=output_next; n++)
  911.             {
  912.                 if(digitalRead(pin_output[n]) && micros()>=(output_time[n]+output_duration)) digitalWrite(pin_output[n],0);
  913.             }
  914.         }
  915.  
  916.         digitalWrite(pin_output[output_next],1);
  917.        
  918.         if(output_next < output_number-1)
  919.         {
  920.             output_next++;
  921.         }
  922.         //else
  923.         //Serial.print("output_next fin de boucle: "); Serial.println(output_next);
  924.     }
  925.     digitalWrite(pin_output[output_next],0); //on éteint la dernière sortie après la boucle, c'est sale, mais ça évite de faire des tests en + durant la boucle principale. Elle dure donc 100µs de + que output_duration
  926.     safety = false;
  927.     digitalWrite(pin_safety, 0);
  928.     digitalWrite(pin_light_button,0);
  929. }
  930.  
  931. byte menuTriggerRadio()
  932. {
  933.     //Option de déclenchement individuel des sorties via télécommande
  934.     char radio_message_tab[32] = "";
  935.     String temp_output_number = "";
  936.    
  937.     lcd.clear();
  938.     lcd.noBlink();
  939.    
  940.     displayOff(flag_display_all);
  941.     Serial1.print("L0");
  942.    
  943.     lcd.print("   TRIGGER MANUEL");
  944.     lcd.setCursor(0,1); lcd.print("     Via Radio");
  945.     lcd.setCursor(0,3); lcd.print("A:STOP");
  946.    
  947.     while(radio.available())
  948.     {
  949.         radio.read(&radio_message_tab, sizeof(radio_message_tab));
  950.         radio_message_tab[32] = ""; //on vide le buffer du module radio de tout message arrivé précédemment
  951.     }
  952.  
  953.    
  954.     while(1)
  955.     {
  956.         if(radio.available())
  957.         {  
  958.             radio_message_tab[32] = "";
  959.             temp_output_number = "";
  960.            
  961.             //Serial.println("MESSAGE RECU");
  962.             radio.read(&radio_message_tab, sizeof(radio_message_tab));
  963.             Serial.print("Message radio: "); Serial.println(String(radio_message_tab));
  964.             //Serial.print("Message safety:"); Serial.println(message_safety);
  965.            
  966.             if((String(radio_message_tab)).indexOf(String(message_trigger)) >= 0) // on détecte si le message de Trigger est dans le message relevé
  967.                 {
  968.                     Serial.println("TRIGGER détecté dans le message");
  969.                     for (byte n = 0; n<sizeof(radio_message_tab); n++)
  970.                         {
  971.                             Serial.println(radio_message_tab[n]);
  972.                             if(isdigit(radio_message_tab[n]))
  973.                                temp_output_number += (char)radio_message_tab[n];
  974.                         }
  975.                     if(temp_output_number.toInt() >= 0 && temp_output_number.toInt() < 12)
  976.                     {
  977.                         digitalWrite(pin_output[temp_output_number.toInt()],1);
  978.                         delay(output_duration/1000);
  979.                         digitalWrite(pin_output[temp_output_number.toInt()],0);
  980.                     }
  981.                 }
  982.            
  983.             if(String(radio_message_tab) == String(message_safety))
  984.             {
  985.                 Serial.println(safety);
  986.                 safety = !safety;
  987.                 digitalWrite(pin_safety, safety);
  988.             }
  989.            
  990.             else if (String(radio_message_tab) == String(message_stop))
  991.             {
  992.                 selector = selector_menuMain;
  993.                 safety = false;
  994.                 digitalWrite(pin_safety, safety);
  995.                 delayToDisplay(flag_display_active);
  996.                 Serial1.print("LT" + (String)output_number);
  997.                 return selector;
  998.             }  
  999.         }
  1000.        
  1001.         if (keypad.getKey() == 'A')
  1002.         {
  1003.             selector = selector_menuMain;
  1004.             safety = false;
  1005.             digitalWrite(pin_safety, safety);
  1006.             delayToDisplay(flag_display_active);
  1007.             Serial1.print("LT" + (String)output_number);
  1008.             return selector;
  1009.         }
  1010.     }
  1011.    
  1012. }
  1013.  
  1014.  
  1015. void lineTest()
  1016. {
  1017.     //Fonction de lancement du test de ligne sur l'autre Arduino
  1018.     //On demande le nombre de lignes à tester, par défaut on met le nombre output_number déjà rentré
  1019.     String temp_line_number = String(output_number);
  1020.     String line_test_message = ""; // Message renvoyé par l'autre Arduino
  1021.     bool line_number_ok = false;
  1022.    
  1023.    
  1024.     lcd.clear(); lcd.blink();
  1025.     digitalWrite(pin_light_button,0);
  1026.     lcd.print("   TEST DE LIGNE");
  1027.     lcd.setCursor(0,3); lcd.print("D:Eff  A:Retour #:Go");
  1028.     lcd.setCursor(0,1); lcd.print("Nb de sorties: "); lcd.print(output_number);
  1029.    
  1030.     keypress = keypad.waitForKey();
  1031.     if(keypress != '#') temp_line_number = "";
  1032.    
  1033.     while(!line_number_ok)
  1034.     {
  1035.         if(isDigit(keypress) && (temp_line_number.length()<2))
  1036.         {
  1037.             temp_line_number.concat(keypress);
  1038.             lcd.setCursor(15,1);
  1039.             lcd.print(temp_line_number);
  1040.         }
  1041.         else if(keypress == 'D')
  1042.         {
  1043.             temp_line_number = "";
  1044.             lcd.setCursor(15,1);
  1045.             lcd.print("  ");
  1046.             lcd.setCursor(15,1);
  1047.         }
  1048.  
  1049.         else if (keypress == '#')
  1050.         {
  1051.             if(temp_line_number.toInt() == 0 || temp_line_number.toInt()>12)
  1052.             {
  1053.                 //valid_number = false;
  1054.                 temp_line_number = "";
  1055.                 lcd.setCursor(15,1); lcd.print("NOPE");
  1056.                 delay(1000); lcd.setCursor(15,1); lcd.print("    "); lcd.setCursor(15,1);
  1057.             }
  1058.             else
  1059.             {
  1060.                 line_number_ok = true;
  1061.             }
  1062.         }
  1063.         else if (keypress == 'A') return;
  1064.        
  1065.         if(!line_number_ok) keypress = keypad.waitForKey();
  1066.     }
  1067.    
  1068.     lcd.noBlink();    
  1069.     lcd.setCursor(0,1); lcd.print("Lignes HS:       ");
  1070.    
  1071.     while(keypress != 'A')
  1072.     {
  1073.         line_test_message = "";
  1074.        
  1075.         lcd.setCursor(0,2); lcd.print("                    ");
  1076.         lcd.setCursor(0,3); lcd.print("      ");
  1077.         lcd.setCursor(0,2);
  1078.        
  1079.         Serial1.print("O"+temp_line_number); //envoi du code de lancement du test de ligne sur l'autre Arduino
  1080.         delay(500); //on attend largement que le test soit fait
  1081.        
  1082.         while(Serial1.available())
  1083.         {
  1084.             line_test_message.concat((char)Serial1.read());
  1085.         }
  1086.        
  1087.         tone(pin_buzzer, 2000, 500);
  1088.         //Serial.print("message:"); Serial.println(line_test_message);
  1089.         //Serial.print("Taille message:"); Serial.println(line_test_message.length());
  1090.        
  1091.         if (line_test_message.length()<20)
  1092.             lcd.print(line_test_message);
  1093.        
  1094.         else
  1095.         {
  1096.             //on découpe en deux lignes l'affichage du message s'il est trop long
  1097.             Serial.println(line_test_message.substring(0,20));
  1098.             Serial.println(line_test_message.substring(21));
  1099.             lcd.print(line_test_message.substring(0,20));
  1100.             lcd.setCursor(0,3);
  1101.             lcd.print(line_test_message.substring(21));
  1102.         }
  1103.         lcd.setCursor(7,3); lcd.print("A:Retour #:Go");        
  1104.         keypress = keypad.waitForKey();
  1105.        
  1106.         while(keypress != '#' && keypress != 'A') {keypress = keypad.waitForKey();}      
  1107.     }
  1108.  
  1109. }
  1110.  
  1111. void outputTest()
  1112. {
  1113.     lcd.clear(); lcd.noBlink(); lcd.print("  ! Test Sorties !");
  1114.     lcd.setCursor(0,1); lcd.print("Impulsion: " + (String)(output_duration/1000) + "ms");
  1115.     lcd.setCursor(0,3); lcd.print("A:Menu         #:Go");
  1116.    
  1117.     keypress = keypad.waitForKey();
  1118.     while(keypress != 'A' && keypress != '#') {keypress = keypad.waitForKey();}
  1119.    
  1120.     while(keypress != 'A')
  1121.     {
  1122.         lcd.setCursor(0,2); lcd.print("Test en cours...");
  1123.         for(byte n = 0; n<12; n++)
  1124.         {
  1125.             digitalWrite(pin_output[n],1);
  1126.             delay(output_duration/1000);
  1127.             digitalWrite(pin_output[n],0);
  1128.         }
  1129.         lcd.setCursor(0,2); lcd.print("Test fini       ");
  1130.         keypress = keypad.waitForKey();
  1131.         while(keypress != 'A' && keypress != '#') {keypress = keypad.waitForKey();}
  1132.     }
  1133.     selector = selector_menuMain; return selector;
  1134. }
  1135.  
  1136. void loop() {
  1137.  
  1138.     switch (selector)
  1139.     {
  1140.         case selector_menuMain: menuMain(); break;
  1141.         case selector_menuOutputSelection: menuOutputSelection(); break;
  1142.         case selector_menuSettings: menuSettings(); break;
  1143.         case selector_menuBrightness: menuBrightness(); break;
  1144.         case selector_menuSleep: menuSleep(); break;
  1145.         case selector_menuUnit: menuUnit(); break;
  1146.         case selector_menuDelaySet: menuDelaySet(); break;
  1147.         case selector_menuTriggerMode: menuTriggerMode(); break;
  1148.         case selector_menuTriggerConfirmation: menuTriggerConfirmation(); break;
  1149.         case selector_menuTrigger: menuTrigger(); break;
  1150.         case selector_menuTriggerRadio: menuTriggerRadio();
  1151.         default: selector = selector_menuMain; break;
  1152.     }
  1153. }
Advertisement
Add Comment
Please, Sign In to add comment