API tools faq
paste
Advertisement
Experimentboy

Experimentboy - Afficheur Géant

Experimentboy
Feb 17th, 2015
12,891
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 42.97 KB | None | 0 0
raw download clone embed print report
  1. //Programme de l'afficheur géant d'Experimentboy
  2. // Vidéo --> http://youtu.be/pH1GlNIYR24
  3.  
  4.  
  5. //Indice = digit, sous indice = n° du bit
  6. //Premier digit (indice 0) = droite
  7. //Premier bit (sous-indice 0) = poids FAIBLE
  8. byte digit[]={14,15,16,17}; //4 pins de l'écriture des 4 bits des décodeurs (en parallèle)
  9. byte latch[] = {10,9,8,7,6,5}; // 6 pins des latch des décodeurs
  10.  
  11. int nombre[] = {0,0,0,0,0,0}; //nombres à afficher en façade
  12.  
  13. volatile unsigned long t0, t1, tv0, tv1;
  14. long trest1, trest2, tecoul, tadd1, tadd2, tfin1, tfin2; //tadd1 et 2 sont les temps à ajouter
  15. unsigned long intervalle;
  16.  
  17. volatile bool trigged1 = false, trigged2 = false;
  18. bool termine; //parametre de fin
  19. bool ptiml; //parametre de modification du temps en mode timelapse
  20. bool again = false; // si appui sur OK au lieu de retour a la fin, recommence avec les mêmes reglages
  21. bool timlphase = false; //false pour mode OFF, true pour ON
  22. bool timlchg = false; // passage a true lors d'un changement de mode du cycle (timelapse)
  23.  
  24. int tempo = 80; //vitesse de defilement des valeurs en reglage
  25. byte antirebond = 60;
  26.  
  27. byte vmode = 1, vsmode = 1, vunit = 0, reg = 0; //types de reglages
  28.  
  29. const byte cpt = 1, dcpt = 2, vit = 3, timl = 4; //types de mode
  30. const byte tps = 1, nb = 2, itrv = 3, svit = 4; // types de sous-mode
  31. const byte aucune = 0, hms = 1, msc = 2, ms = 3, mps = 4, kmh = 5, cm = 6; //types d'unite
  32.  
  33. unsigned int dist = 100, rnbmax = 0; // variables pour le reglage de la distance et du nb de passages max (final)
  34. unsigned int rnb = 0; //variable compteur de passages courant
  35. float rvitesse = 0; // variable pour le resultat de la vitesse ou de l'intervalle
  36.  
  37. int rtemps1[3] = {0,0,0}; //listes contenant HH,MM,SS ou MM,SS,dc pour cpt, dcpt, timelapse OFF
  38. int atemps1[3] = {0,0,0}; //liste contenant le temps rtemps1 mais modifiee pour l'affichage
  39.  
  40. int rtemps12[3] = {0,0,0}; // liste contenant HH,MM,SS ou MM,SS,dc le temps pour timelapse ON
  41. int atemps12[3] = {0,0,0};
  42.  
  43. int rtemps2[2] = {0,0}; // liste contenant SSS,ms pour cpt, dcpt, timelapse OFF
  44. int atemps2[2] = {0,0};
  45.  
  46. int rtemps22[2] = {0,0};// liste contenant SSS,ms pour timelapse ON
  47. int atemps22[2] = {0,0};
  48.  
  49. //Sorties
  50. const byte dpt0 = 30, dpt1 = 31, pt0 = 34, pt1 = 35, pt2 = 36, rgb_r = 40, rgb_g = 41, rgb_b0 = 42, rgb_b1 = 43, SIG = 50;
  51. byte pin_out[] = {dpt0, dpt1, pt0, pt1, pt2, rgb_r, rgb_g, rgb_b0, rgb_b1, SIG};
  52.  
  53. //Entrees
  54. const byte haut = 22, bas = 23, gauche = 24, droite = 25, retour = 26, ok = 27, TR1 = 2, TR2 = 3, PAUSE = 18, RESET = 19;
  55. byte pin_in[] = {haut, bas, gauche, droite, retour, ok, TR1, TR2, PAUSE, RESET};
  56.  
  57. #include <Wire.h>
  58. #include <LiquidCrystal_I2C.h>
  59. LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
  60.  
  61.  
  62. void setup()
  63. {
  64.     interrupts();
  65.     attachInterrupt(0,trigger1,RISING);
  66.     attachInterrupt(1,trigger2,RISING);
  67.     attachInterrupt(5,pause,RISING);
  68.  
  69.     lcd.begin(20,4);
  70.     lcd.blink();
  71.     //Serial.begin(115200);
  72.  
  73.     for(byte b = 0; b<6; b++)
  74.     {
  75.         pinMode(latch[b], OUTPUT); digitalWrite(latch[b],0); // sorties latch
  76.     }
  77.  
  78.     for(byte a = 0; a < 4; a++)
  79.       pinMode(digit[a],OUTPUT); //Sorties bits
  80.  
  81.     for(byte a = 0; a<10; a++)
  82.       pinMode(pin_out[a],OUTPUT); //sorties pins autres
  83.     digitalWrite(SIG,0);
  84.  
  85.     for(byte a = 0; a<10; a++)
  86.       pinMode(pin_in[a],INPUT); //entrees
  87.  
  88.     reset_digits();
  89.  
  90.     if(digitalRead(retour)) test();
  91.  
  92.     digitalWrite(rgb_r,1);
  93.  
  94. }
  95.  
  96. void test()
  97. {
  98.     //TESTE TOUT AU DEMARRAGE SI APPUI RETOUR
  99.     lcd.print("Test...");
  100.     for(byte n = 0; n < 10; n++)
  101.     {
  102.         for(byte i = 0; i<6; i++)
  103.             nombre[i] = n;
  104.         affiche_digits();
  105.         delay(400);
  106.     }
  107.         for(byte i = 0; i<6; i++)
  108.             nombre[i] = 0;
  109.         affiche_digits();
  110.         delay(400);
  111.  
  112.     for(byte n = 0; n < 10; n++)
  113.     {
  114.         digitalWrite(pin_out[n],1);
  115.         delay(400);
  116.         digitalWrite(pin_out[n],0);
  117.     }
  118.  
  119.     //Easter Egg trop swag
  120.     nombre[0] = 2;
  121.     nombre[1] = 4;
  122.     for(byte n = 2; n<6; n++)
  123.         nombre[n] = 10;
  124.     affiche_digits();
  125.  
  126.     lcd.clear();
  127.     lcd.print("Test fini !");
  128.     lcd.setCursor(0,2); lcd.print("Experimentboy");
  129.     delay(2000);
  130.  
  131.     for(byte i = 0; i<6; i++)
  132.         nombre[i] = 0;
  133.     affiche_digits();
  134.  
  135. }
  136.  
  137. void menu()
  138. {
  139.     // Affiche les reglages du menu
  140.     lcd.clear();
  141.  
  142.     lcd.print("       -TIMER-");
  143.     lcd.setCursor(0,1); lcd.print("Mode:");
  144.     lcd.setCursor(17,3); lcd.print(">OK");
  145.     lcd.setCursor(4,1);
  146. }
  147.  
  148. void mode()
  149. {
  150.     affiche_mode();
  151.     if (again) return;
  152.  
  153.     while(!digitalRead(ok))
  154.     {
  155.         if(digitalRead(droite))
  156.         {
  157.             if(vmode == timl)
  158.                 vmode = cpt;
  159.             else vmode ++;
  160.             affiche_mode();
  161.             while(digitalRead(droite)) {}
  162.             delay(antirebond);
  163.         }
  164.  
  165.         else if (digitalRead(gauche))
  166.         {
  167.             if(vmode == cpt)
  168.                 vmode = timl;
  169.             else vmode --;
  170.             affiche_mode();
  171.             while(digitalRead(gauche)) {}
  172.             delay(antirebond);
  173.         }
  174.     }
  175. }
  176.  
  177. void affiche_mode()
  178. {
  179.     lcd.setCursor(5,1);
  180.     switch (vmode)
  181.     {
  182.     case cpt:
  183.         lcd.print("CPT ");
  184.         break;
  185.     case dcpt:
  186.         lcd.print("DCPT");
  187.         break;
  188.     case vit:
  189.         lcd.print("VIT ");
  190.         break;
  191.     case timl:
  192.         lcd.print("CYCL");
  193.         break;
  194.     default:
  195.         lcd.print("ERR");
  196.     }
  197.     lcd.setCursor(4,1);
  198. }
  199.  
  200. void smode()
  201. {
  202.     if(again)
  203.     {
  204.         affiche_smode();
  205.         return;
  206.     }
  207.  
  208.     if(vmode == vit) vsmode = svit;
  209.     else if (vmode == cpt || vmode == dcpt) vsmode = tps;
  210.  
  211.     // EN TIMELAPSE, LE SMODE EST DEFINI SUR TPS PAR DEFAUT
  212.     else if (vmode == timl)
  213.     {
  214.         vsmode = tps;
  215.         return;
  216.     }
  217.  
  218.     lcd.setCursor(10,1); lcd.print("|");
  219.     affiche_smode();
  220.  
  221.     while(digitalRead(ok)) {}
  222.     delay(antirebond);
  223.  
  224.     while(!digitalRead(ok))
  225.     {
  226.         switch(vmode)
  227.         {
  228.         case cpt:
  229.             if(digitalRead(droite) || digitalRead(gauche))
  230.             {
  231.                 if(vsmode == tps) vsmode = nb; // changement du sous-mode entre Temps et Nombre de passage
  232.                 else vsmode = tps;
  233.                 affiche_smode();
  234.                 while(digitalRead(droite) || digitalRead(gauche)) {}
  235.                 delay(antirebond);
  236.             }
  237.             break;
  238.  
  239.         case dcpt:
  240.             if(digitalRead(droite) || digitalRead(gauche))
  241.             {
  242.                 if(vsmode == tps) vsmode = nb; // changement du sous-mode entre Temps et Nombre de passage
  243.                 else vsmode = tps;
  244.                 affiche_smode();
  245.                 while(digitalRead(droite) || digitalRead(gauche)) {}
  246.                 delay(antirebond);
  247.             }
  248.             break;
  249.  
  250.         case vit:
  251.             if(digitalRead(droite) || digitalRead(gauche))
  252.             {
  253.                 if(vsmode == itrv) vsmode = svit; // changement du sous-mode entre intervalle et vitesse
  254.                 else vsmode = itrv;
  255.                 affiche_smode();
  256.                 while(digitalRead(droite) || digitalRead(gauche)) {}
  257.                 delay(antirebond);
  258.             }
  259.             break;
  260.  
  261.         case timl:
  262.             break;
  263.         }
  264.     }
  265. }
  266.  
  267. void affiche_smode()
  268. {
  269.     lcd.setCursor(11,1);
  270.     switch (vsmode)
  271.     {
  272.     case tps:
  273.         lcd.print("Temps  ");
  274.         break;
  275.     case nb:
  276.         lcd.print("Passage");
  277.         break;
  278.     case itrv:
  279.         lcd.print("Intrvl ");
  280.         break;
  281.     case svit:
  282.         lcd.print("Vitesse");
  283.         break;
  284.     default:
  285.         lcd.print("ERR");
  286.     }
  287.     lcd.setCursor(10,1);
  288. }
  289.  
  290.  
  291. void unite()
  292. {
  293.     if(vsmode == nb || vsmode == itrv)
  294.     {
  295.         vunit = aucune;
  296.         return;
  297.     }
  298.  
  299.     if(again)
  300.     {
  301.         affiche_unit();
  302.         return;
  303.     }
  304.  
  305.     else if(vsmode == tps) vunit = msc;
  306.     else if(vsmode == svit) vunit = mps;
  307.  
  308.     affiche_unit();
  309.  
  310.  
  311.  
  312.     while(digitalRead(ok)) {};
  313.     delay(antirebond);
  314.  
  315.     while(!digitalRead(ok))
  316.     {
  317.         switch(vsmode)
  318.         {
  319.         case tps:
  320.             if(digitalRead(droite))
  321.             {
  322.                 if(vunit == ms) vunit = hms; // changement unite de temps
  323.                 else vunit++;
  324.                 affiche_unit();
  325.                 while(digitalRead(droite)) {}
  326.                 delay(antirebond);
  327.             }
  328.             else if(digitalRead(gauche))
  329.             {
  330.                 if(vunit == hms) vunit = ms;
  331.                 else vunit --;
  332.                 affiche_unit();
  333.                 while(digitalRead(gauche)) {};
  334.                 delay(antirebond);
  335.             }
  336.             break;
  337.  
  338.         case svit:
  339.             if(digitalRead(droite) || digitalRead(gauche))
  340.             {
  341.                 if(vunit == kmh) vunit = mps; // changement unite km/h ou m/s
  342.                 else vunit = kmh;
  343.                 affiche_unit();
  344.                 while(digitalRead(droite) || digitalRead(gauche)) {}
  345.                 delay(antirebond);
  346.             }
  347.             break;
  348.         }
  349.     }
  350. }
  351.  
  352. void affiche_unit()
  353. {
  354.     lcd.setCursor(0,2);
  355.     affiche_points();
  356.  
  357.     lcd.print("Unit:");
  358.     switch (vunit)
  359.     {
  360.     case hms:
  361.         lcd.print("HH:MM:SS");
  362.         break;
  363.     case msc:
  364.         lcd.print("MM:SS.dc");
  365.         break;
  366.     case ms:
  367.         lcd.print("SSS.dcm ");
  368.         break;
  369.     case mps:
  370.         lcd.print("m/s ");
  371.         break;
  372.     case kmh:
  373.         lcd.print("km/h");
  374.         break;
  375.     case aucune:
  376.         break;
  377.     default:
  378.         lcd.print("ERR");
  379.         break;
  380.     }
  381. lcd.setCursor(4,2);
  382. }
  383.  
  384.  
  385. void reglage()
  386. {
  387.     if(vmode == vit && vsmode == itrv)
  388.     {
  389.         return;
  390.     }
  391.  
  392.     //pre affichage selon le sous mode ou l'unite, evite de l'ecrire a chaque passage d'affiche_reglage()
  393.  
  394.     lcd.setCursor(0,2);
  395.     if(vsmode == svit) lcd.print("D=       ");
  396.     else if(vsmode == tps && vmode == timl)
  397.     {
  398.         lcd.print("OFF :");
  399.         lcd.setCursor(0,3);
  400.         lcd.print("ON  :");
  401.         lcd.setCursor(5,2);
  402.     }
  403.     else lcd.print("Set :");
  404.  
  405.     if(again)
  406.     {
  407.         affiche_reglage();
  408.         return;
  409.     }
  410.  
  411.     ptiml = false;
  412.  
  413.     affiche_points();
  414.     affiche_reglage();
  415.     while(digitalRead(ok)) {}
  416.     delay(antirebond);
  417.  
  418.     while(!digitalRead(ok))
  419.     {
  420.         if(vunit == hms || vunit == msc)
  421.         {
  422.             if(digitalRead(haut))
  423.             {
  424.                 rtemps1[reg]++;
  425.  
  426.                 //Verification du depassement en fonction de l'unite et de la valeur
  427.                 if(vunit == hms)
  428.                 {
  429.                     if(reg == 0) rtemps1[reg] %= 100; // heures
  430.                     else rtemps1[reg] %= 60; // minutes secondes
  431.                 }
  432.                 else
  433.                 {
  434.                     if(reg == 1) rtemps1[reg] %= 60; //secondes
  435.                     else rtemps1[reg] %= 100; // minutes et centiemes
  436.                 }
  437.                 affiche_reglage();
  438.                 delay(tempo); //En restant appuye, defilement
  439.             }
  440.  
  441.             else if(digitalRead(bas))
  442.             {
  443.                 rtemps1[reg]--;
  444.  
  445.                 //Verification du depassement en fonction de l'unite et de la valeur
  446.                 if(vunit == hms)
  447.                 {
  448.                     if(reg == 0 && rtemps1[reg] < 0) rtemps1[reg] = 99;
  449.                     else if ((reg == 2 || reg == 1 ) && rtemps1[reg] < 0) rtemps1[reg] = 59; // heures en modulo 100
  450.                 }
  451.                 else
  452.                 {
  453.                     if(reg == 1 && rtemps1[reg] < 0) rtemps1[reg] = 59; //minutes et
  454.                     else if ((reg == 0 || reg == 2) && rtemps1[reg] < 0) rtemps1[reg] = 99;
  455.                 }
  456.                 affiche_reglage();
  457.                 delay(tempo); //En restant appuye, defilement
  458.             }
  459.  
  460.  
  461.             if (digitalRead(droite))
  462.             {
  463.                 if (reg == 2) reg = 0;
  464.                 else reg++;
  465.                 affiche_reglage();
  466.                 while(digitalRead(droite)){}
  467.                 delay(antirebond);
  468.             }
  469.  
  470.             else if (digitalRead(gauche))
  471.             {
  472.                 if (reg == 0) reg = 2;
  473.                 else reg--;
  474.                 affiche_reglage();
  475.                 while(digitalRead(gauche)){}
  476.                 delay(antirebond);
  477.             }
  478.         }
  479.  
  480.  
  481.  
  482.         else if(vunit == ms)
  483.         {
  484.             //cas de l'unite de temps ms
  485.             if(digitalRead(haut))
  486.             {
  487.                 rtemps2[reg]++;
  488.  
  489.                 //Verification du depassement
  490.                 rtemps2[reg] %= 1000;
  491.  
  492.                 affiche_reglage();
  493.                 delay(tempo); //En restant appuye, defilement
  494.             }
  495.  
  496.             else if(digitalRead(bas))
  497.              {
  498.                 rtemps2[reg]--;
  499.  
  500.                 //Verification du depassement en fonction de l'unite et de la valeur
  501.                 if(rtemps2[reg] < 0) rtemps2[reg] = 999;
  502.                 affiche_reglage();
  503.                 delay(tempo); //En restant appuye, defilement
  504.              }
  505.  
  506.  
  507.  
  508.             if (digitalRead(droite) || digitalRead(gauche))
  509.             {
  510.                 if (reg == 0) reg = 1;
  511.                 else reg = 0;
  512.                 affiche_reglage();
  513.                 while(digitalRead(droite) || digitalRead(gauche)){}
  514.                 delay(antirebond);
  515.             }
  516.         }
  517.  
  518.         else if(vunit == aucune)
  519.         {
  520.             if(digitalRead(haut))
  521.             {
  522.                 rnbmax++;
  523.                 affiche_reglage();
  524.                 delay(tempo); //En restant appuye, defilement
  525.             }
  526.  
  527.             else if(digitalRead(bas))
  528.              {
  529.                 //if(rnbmax > 0 )
  530.                 rnbmax--;
  531.                 affiche_reglage();
  532.                 delay(tempo); //En restant appuye, defilement
  533.              }
  534.         }
  535.  
  536.         else if (vunit == kmh || vunit == mps)
  537.         {
  538.             if(digitalRead(haut))
  539.             {
  540.                 dist++;
  541.                 affiche_reglage();
  542.                 delay(tempo); //En restant appuye, defilement
  543.             }
  544.  
  545.             else if(digitalRead(bas))
  546.              {
  547.                 if(dist > 0) dist--;
  548.                 affiche_reglage();
  549.                 delay(tempo); //En restant appuye, defilement
  550.              }
  551.         }
  552.     }
  553.  
  554.  
  555.  
  556.     //egalisation des listes parametres et listes affichages
  557.     for(byte n = 0; n<3; n++)
  558.         atemps1[n] = rtemps1[n];
  559.  
  560.     for(byte n = 0; n<2; n++)
  561.         atemps2[n] = rtemps2[n];
  562.  
  563.     //Deuxieme reglage si mode timelapse
  564.     if(vmode == timl)
  565.     {
  566.         ptiml = true;
  567.         reg=0;
  568.         affiche_reglage();
  569.  
  570.         while(digitalRead(ok)) {}
  571.         delay(antirebond);
  572.  
  573.         while(!digitalRead(ok))
  574.         {
  575.             if(vunit == hms || vunit == msc)
  576.             {
  577.                 if(digitalRead(haut))
  578.                 {
  579.                     rtemps12[reg]++;
  580.  
  581.                     //Verification du depassement en fonction de l'unite et de la valeur
  582.                     if(vunit == hms)
  583.                     {
  584.                         if(reg == 0) rtemps12[reg] %= 100; // heures
  585.                         else rtemps12[reg] %= 60; // minutes secondes
  586.                     }
  587.                     else
  588.                     {
  589.                         if(reg == 1) rtemps12[reg] %= 60; //secondes
  590.                         else rtemps12[reg] %= 100; // minutes et centiemes
  591.                     }
  592.  
  593.                     affiche_reglage();
  594.                     delay(tempo); //En restant appuye, defilement
  595.                 }
  596.  
  597.  
  598.  
  599.                 else if(digitalRead(bas))
  600.                 {
  601.                     rtemps12[reg]--;
  602.  
  603.                     //Verification du depassement en fonction de l'unite et de la valeur
  604.                     if(vunit == hms)
  605.                     {
  606.                         if(reg == 0 && rtemps12[reg] < 0) rtemps12[reg] = 99;
  607.                         else if ((reg == 2 || reg == 1 ) && rtemps12[reg] < 0) rtemps12[reg] = 59; // heures en modulo 100
  608.                     }
  609.                     else
  610.                     {
  611.                         if(reg == 1 && rtemps12[reg] < 0) rtemps12[reg] = 59; //minutes et
  612.                         else if ((reg == 0 || reg == 2) && rtemps12[reg] < 0) rtemps12[reg] = 99;
  613.                     }
  614.                     affiche_reglage();
  615.                     delay(tempo); //En restant appuye, defilement
  616.                 }
  617.  
  618.  
  619.                 if (digitalRead(droite))
  620.                 {
  621.                     if (reg == 2) reg = 0;
  622.                     else reg++;
  623.                     affiche_reglage();
  624.                     while(digitalRead(droite)){}
  625.                     delay(antirebond);
  626.                 }
  627.  
  628.                 else if (digitalRead(gauche))
  629.                 {
  630.                     if (reg == 0) reg = 2;
  631.                     else reg--;
  632.                     affiche_reglage();
  633.                     while(digitalRead(gauche)){}
  634.                     delay(antirebond);
  635.                 }
  636.             }
  637.  
  638.  
  639.             else if(vunit == ms)
  640.             {
  641.                 //cas de l'unite de temps ms
  642.                 if(digitalRead(haut))
  643.                 {
  644.                     rtemps22[reg]++;
  645.  
  646.                     //Verification du depassement
  647.                     rtemps22[reg] %= 1000;
  648.  
  649.                     affiche_reglage();
  650.                     delay(tempo); //En restant appuye, defilement
  651.                 }
  652.  
  653.                 else if(digitalRead(bas))
  654.                  {
  655.                     rtemps22[reg]--;
  656.  
  657.                     //Verification du depassement en fonction de l'unite et de la valeur
  658.                     if(rtemps22[reg] < 0) rtemps22[reg] = 999;
  659.                     affiche_reglage();
  660.                     delay(tempo); //En restant appuye, defilement
  661.                  }
  662.  
  663.  
  664.                 if (digitalRead(droite) || digitalRead(gauche))
  665.                 {
  666.                     if (reg == 0) reg = 1;
  667.                     else reg = 0;
  668.                     affiche_reglage();
  669.                     while(digitalRead(droite) || digitalRead(gauche)){}
  670.                     delay(antirebond);
  671.                 }
  672.             }
  673.  
  674.         }
  675.  
  676.         //egalisation des listes reglage et affichage
  677.         for(byte n = 0; n<3; n++)
  678.             atemps12[n] = rtemps12[n];
  679.  
  680.         for(byte n = 0; n<2; n++)
  681.             atemps22[n] = rtemps22[n];
  682.     }
  683. }
  684.  
  685. void affiche_reglage()
  686. {
  687.     if(!ptiml)
  688.     {
  689.         lcd.setCursor(5,2);
  690.         if(vunit == hms || vunit == msc)
  691.         {
  692.             if(rtemps1[0] < 10) lcd.print("0"); lcd.print(rtemps1[0]); lcd.print(":");
  693.             if(rtemps1[1] < 10) lcd.print("0"); lcd.print(rtemps1[1]);
  694.             if(vunit == hms)
  695.                 lcd.print(":");
  696.             else
  697.                 lcd.print(".");
  698.  
  699.             if(rtemps1[2] < 10) lcd.print("0"); lcd.print(rtemps1[2]);
  700.             lcd.setCursor(reg*3+4,2); //placement du curseur en fonction du parametre courant
  701.  
  702.             if(vmode == dcpt || vmode == timl)
  703.             {
  704.                 nombre[0] = rtemps1[2] % 10;
  705.                 nombre[1] = rtemps1[2] / 10;
  706.                 nombre[2] = rtemps1[1] % 10;
  707.                 nombre[3] = rtemps1[1] / 10;
  708.                 nombre[4] = rtemps1[0] % 10;
  709.                 nombre[5] = rtemps1[0] / 10;
  710.                 affiche_digits();
  711.             }
  712.  
  713.         }
  714.  
  715.         else if(vunit == ms)
  716.         {
  717.  
  718.             if(rtemps2[0] < 100) lcd.print("0"); if(rtemps2[0] < 10) lcd.print("0"); lcd.print(rtemps2[0]);
  719.             lcd.print(".");
  720.             if(rtemps2[1] < 100) lcd.print("0"); if(rtemps2[1] < 10) lcd.print("0"); lcd.print(rtemps2[1]);
  721.             lcd.print("s");
  722.             lcd.setCursor(reg*4+4,2);
  723.  
  724.             if(vmode == dcpt || vmode == timl)
  725.             {
  726.                 nombre[0] = rtemps2[1] % 10;
  727.                 nombre[1] = (rtemps2[1] % 100) / 10;
  728.                 nombre[2] = rtemps2[1] / 100;
  729.                 nombre[3] = rtemps2[0] % 10;
  730.                 nombre[4] = (rtemps2[0] % 100) / 10;
  731.                 nombre[5] = rtemps2[0] / 100;
  732.                 affiche_digits();
  733.             }
  734.  
  735.         }
  736.  
  737.         else if (vunit == aucune)
  738.         {
  739.             lcd.print(rnbmax); lcd.print(" fois    ");
  740.             lcd.setCursor(4,2);
  741.  
  742.         if(vmode == dcpt || vmode == timl)
  743.         {
  744.             nombre[5] = 0;
  745.             nombre[4] = rnbmax / 10000;
  746.             nombre[3] = (rnbmax / 1000) %10;
  747.             nombre[2] = (rnbmax / 100) %10;
  748.             nombre[1] = (rnbmax / 10) %10;
  749.             nombre[0] = rnbmax %10;
  750.             affiche_digits();
  751.         }
  752.  
  753.         }
  754.  
  755.         else if (vunit == kmh || vunit == mps)
  756.         {
  757.             lcd.setCursor(2,2);
  758.             lcd.print(dist); lcd.print("cm ");
  759.             lcd.setCursor(1,2);
  760.         }
  761.     }
  762.  
  763.  
  764.     //DEUXIEME REGLAGE TIMELAPSE
  765.     else
  766.     {
  767.         lcd.setCursor(5,3);
  768.         //deuxieme reglage timelapse
  769.         if(vunit == hms || vunit == msc)
  770.         {
  771.             if(rtemps12[0] < 10) lcd.print("0"); lcd.print(rtemps12[0]); lcd.print(":");
  772.             if(rtemps12[1] < 10) lcd.print("0"); lcd.print(rtemps12[1]);
  773.             if(vunit == hms)
  774.             {
  775.                 lcd.print(":");
  776.                 // CODE EVENTUEL POUR AFFICHER AUSSI LES POINTS SUR LE PANNEAU
  777.             }
  778.             else
  779.             {
  780.                 lcd.print(".");
  781.                 // CODE EVENTUEL POUR AFFICHER AUSSI LES POINTS SUR LE PANNEAU
  782.             }
  783.             if(rtemps12[2] < 10) lcd.print("0"); lcd.print(rtemps12[2]);
  784.             lcd.setCursor(reg*3+4,3); //placement du curseur en fonction du parametre courant
  785.         }
  786.  
  787.         else if(vunit == ms)
  788.         {
  789.  
  790.             if(rtemps22[0] < 100) lcd.print("0"); if(rtemps22[0] < 10) lcd.print("0"); lcd.print(rtemps22[0]);
  791.             lcd.print(".");
  792.             if(rtemps22[1] < 100) lcd.print("0"); if(rtemps22[1] < 10) lcd.print("0"); lcd.print(rtemps22[1]);
  793.             lcd.print("s");
  794.             lcd.setCursor(reg*4+4,3);
  795.  
  796.             affiche_digits();
  797.         }
  798.     }
  799. }
  800.  
  801.  
  802. void stb_ok()
  803. {
  804.     while(digitalRead(ok)) {}
  805.     delay(antirebond*3);
  806.     lcd.setCursor(17,3);
  807.  
  808.     while(!digitalRead(ok)) {}
  809. }
  810.  
  811. void stb()
  812. {
  813.     lcd.setCursor(14,3); lcd.print(">READY"); lcd.setCursor(14,3);
  814.     trigged1 = false;
  815.     trigged2 = false;
  816.  
  817.     if(vsmode == tps)
  818.     {
  819.         switch (vunit)
  820.         {
  821.             //Calcul du temps a ajouter a millis() au moment du trigger, pour aller plus vite
  822.             case hms:
  823.                 tadd1 = 3600000 * (long)rtemps1[0] + 60000*(long)rtemps1[1] + 1000*(long)rtemps1[2];
  824.                 break;
  825.  
  826.             case msc:
  827.                 tadd1 = 60000*(long)rtemps1[0] + 1000*(long)rtemps1[1] + 10*(long)rtemps1[2];
  828.                 break;
  829.  
  830.             case ms:
  831.                 tadd1 = 1000*(long)rtemps2[0] + rtemps2[1];
  832.                 break;
  833.         }
  834.         if(vmode == timl)
  835.         {
  836.             switch (vunit)
  837.             {
  838.                 //Calcul du temps a ajouter a millis() au moment du trigger, pour aller plus vite
  839.                 case hms:
  840.                     tadd2 = 3600000 * (long)rtemps12[0] + 60000* (long)rtemps12[1] + 1000* (long)rtemps12[2];
  841.                     break;
  842.  
  843.                 case msc:
  844.                     tadd2 = 60000*(long)rtemps12[0] + 1000*(long)rtemps12[1] + 10*rtemps12[2];
  845.                     break;
  846.  
  847.                 case ms:
  848.                     tadd2 = 1000*(long)rtemps22[0] + rtemps22[1];
  849.                     break;
  850.             }
  851.         }
  852.  
  853.         //lancement de la fonction de standby correspondant au mode sachant que le sous mode est un temps
  854.         if(vmode == cpt) stb_cpt_tps();
  855.         else if(vmode == dcpt) stb_dcpt_tps();
  856.         else stb_timl();
  857.     }
  858.  
  859.     else if(vsmode == nb)
  860.     {
  861.         if(vmode == cpt) stb_cpt_nb();
  862.         else
  863.         {
  864.             rnb = rnbmax;
  865.             stb_dcpt_nb();
  866.         }
  867.     }
  868.  
  869.     else if(vsmode == svit) stb_vit_vit();
  870.     else if(vsmode == itrv) stb_vit_itrv();
  871. }
  872.  
  873. void stb_cpt_tps()
  874. {
  875.     if(vunit == hms)
  876.     {
  877.         while(!trigged1){} //attente du trigger
  878.  
  879.         tfin1 = t0 + tadd1;
  880.         trigged1 = true;
  881.         while(!termine)
  882.         {
  883.             calcul_cpt_hms();
  884.             affiche_digits();
  885.         }
  886.         //APRES FIN
  887.     }
  888.     else if(vunit == msc)
  889.     {
  890.         while(!trigged1){} //attente du trigger
  891.  
  892.         tfin1 = t0 + tadd1;
  893.         trigged1 = true;
  894.         while(!termine)
  895.         {
  896.             calcul_cpt_msc();
  897.             affiche_digits();
  898.         }
  899.         //APRES FIN
  900.     }
  901.  
  902.     else if(vunit == ms)
  903.     {
  904.         while(!trigged1){} //attente du trigger
  905.  
  906.         tfin1 = t0 + tadd1;
  907.         trigged1 = true;
  908.         while(!termine)
  909.         {
  910.             calcul_cpt_ms();
  911.             affiche_digits();
  912.         }
  913.         //APRES FIN
  914.     }
  915. }
  916.  
  917. void calcul_cpt_hms()
  918. {
  919.     //calcul du temps ecoule
  920.     tecoul = millis() - t0;
  921.     if(millis()  >= tfin1)
  922.     {
  923.         relais();
  924.         nombre[0] = rtemps1[2] % 10;
  925.         nombre[1] = rtemps1[2] / 10;
  926.         nombre[2] = rtemps1[1] % 10;
  927.         nombre[3] = rtemps1[1] / 10;
  928.         nombre[4] = rtemps1[0] % 10;
  929.         nombre[5] = rtemps1[0] / 10;
  930.         termine = true;
  931.         return;
  932.     }
  933.  
  934.     //decoupage puis soustraction des heures
  935.     atemps1[0] = tecoul / 3600000;
  936.     tecoul %= 3600000;
  937.  
  938.     //minutes
  939.     atemps1[1] = tecoul / 60000;
  940.     tecoul %= 60000;
  941.  
  942.     //secondes
  943.     atemps1[2] = tecoul / 1000;
  944.  
  945.     nombre[0] = atemps1[2] % 10;
  946.     nombre[1] = atemps1[2] / 10;
  947.     nombre[2] = atemps1[1] % 10;
  948.     nombre[3] = atemps1[1] / 10;
  949.     nombre[4] = atemps1[0] % 10;
  950.     nombre[5] = atemps1[0] / 10;
  951. }
  952.  
  953. void calcul_cpt_msc()
  954. {
  955.     //calcul du temps ecoule
  956.     tecoul = millis() - t0;
  957.     if(millis()  >= tfin1)
  958.     {
  959.         relais();
  960.         nombre[0] = rtemps1[2] % 10;
  961.         nombre[1] = rtemps1[2] / 10;
  962.         nombre[2] = rtemps1[1] % 10;
  963.         nombre[3] = rtemps1[1] / 10;
  964.         nombre[4] = rtemps1[0] % 10;
  965.         nombre[5] = rtemps1[0] / 10;
  966.         termine = true;
  967.         return;
  968.     }
  969.  
  970.     //decoupage puis soustraction des minutes
  971.     atemps1[0] = tecoul / 60000;
  972.     tecoul %= 60000;
  973.  
  974.     //secondes
  975.     atemps1[1] = tecoul / 1000;
  976.     tecoul %= 1000;
  977.  
  978.     //centiemes
  979.     atemps1[2] = tecoul / 10;
  980.  
  981.     nombre[0] = atemps1[2] % 10;
  982.     nombre[1] = atemps1[2] / 10;
  983.     nombre[2] = atemps1[1] % 10;
  984.     nombre[3] = atemps1[1] / 10;
  985.     nombre[4] = atemps1[0] % 10;
  986.     nombre[5] = atemps1[0] / 10;
  987. }
  988.  
  989. void calcul_cpt_ms()
  990. {
  991.     //calcul du temps ecoule
  992.     tecoul = millis() - t0;
  993.     if(millis()  >= tfin1)
  994.     {
  995.         relais();
  996.         nombre[0] = rtemps2[1] % 10;
  997.         nombre[1] = (rtemps2[1] % 100) / 10;
  998.         nombre[2] = rtemps2[1] / 100;
  999.         nombre[3] = rtemps2[0] % 10;
  1000.         nombre[4] = (rtemps2[0] % 100) / 10;
  1001.         nombre[5] = rtemps2[0] / 100;
  1002.         termine = true;
  1003.         return;
  1004.     }
  1005.  
  1006.     //decoupage puis soustraction des secondes
  1007.     atemps2[0] = tecoul / 1000;
  1008.     tecoul %= 1000;
  1009.  
  1010.     //millisecondes
  1011.     atemps2[1] = tecoul;
  1012.  
  1013.  
  1014.     nombre[0] = atemps2[1] % 10;
  1015.     nombre[1] = (atemps2[1] % 100) / 10;
  1016.     nombre[2] = atemps2[1] / 100;
  1017.     nombre[3] = atemps2[0] % 10;
  1018.     nombre[4] = (atemps2[0] % 100) / 10;
  1019.     nombre[5] = atemps2[0] / 100;
  1020. }
  1021.  
  1022.  
  1023. void stb_dcpt_tps()
  1024. {
  1025.     if(vunit == hms)
  1026.     {
  1027.         while(!trigged1){} //attente du trigger
  1028.  
  1029.         tfin1 = t0 + tadd1;
  1030.         trigged1 = true;
  1031.         while(!termine)
  1032.         {
  1033.             calcul_dcpt_hms();
  1034.             affiche_digits();
  1035.         }
  1036.         //APRES FIN
  1037.     }
  1038.     else if(vunit == msc)
  1039.     {
  1040.         while(!trigged1){} //attente du trigger
  1041.  
  1042.         tfin1 = t0 + tadd1;
  1043.         trigged1 = true;
  1044.         while(!termine)
  1045.         {
  1046.             calcul_dcpt_msc();
  1047.             affiche_digits();
  1048.         }
  1049.         //APRES FIN
  1050.     }
  1051.  
  1052.     else if(vunit == ms)
  1053.     {
  1054.         while(!trigged1){} //attente du trigger
  1055.  
  1056.         tfin1 = t0 + tadd1;
  1057.         trigged1 = true;
  1058.         while(!termine)
  1059.         {
  1060.             calcul_dcpt_ms();
  1061.             affiche_digits();
  1062.         }
  1063.         //APRES FIN
  1064.     }
  1065. }
  1066.  
  1067. void calcul_dcpt_hms()
  1068. {
  1069.     //calcul du temps restant
  1070.     trest1 = tfin1 - millis();
  1071.     if(trest1 <= 0)
  1072.     {
  1073.         relais();
  1074.         //affiche 00:00:00
  1075.         for(byte i = 0; i<6; i++)
  1076.             nombre[i] = 0;
  1077.         termine = true;
  1078.         return;
  1079.     }
  1080.  
  1081.     //decoupage puis soustraction des heures
  1082.     atemps1[0] = trest1 / 3600000;
  1083.     trest1 %= 3600000;
  1084.  
  1085.     //minutes
  1086.     atemps1[1] = trest1 / 60000;
  1087.     trest1 %= 60000;
  1088.  
  1089.     //secondes
  1090.     atemps1[2] = trest1 / 1000;
  1091.  
  1092.     nombre[0] = atemps1[2] % 10;
  1093.     nombre[1] = atemps1[2] / 10;
  1094.     nombre[2] = atemps1[1] % 10;
  1095.     nombre[3] = atemps1[1] / 10;
  1096.     nombre[4] = atemps1[0] % 10;
  1097.     nombre[5] = atemps1[0] / 10;
  1098.  
  1099. }
  1100.  
  1101. void calcul_dcpt_msc()
  1102. {
  1103.     //calcul du temps restant
  1104.     trest1 = tfin1 - millis();
  1105.     if(trest1 <= 0)
  1106.     {
  1107.         relais();
  1108.         //affiche 00:00.00
  1109.         for(byte i = 0; i<6; i++)
  1110.             nombre[i] = 0;
  1111.         termine = true;
  1112.         return;
  1113.     }
  1114.  
  1115.     //decoupage puis soustraction des minutes
  1116.     atemps1[0] = trest1 / 60000;
  1117.     trest1 %= 60000;
  1118.  
  1119.     //secondes
  1120.     atemps1[1] = trest1 / 1000;
  1121.     trest1 %= 1000;
  1122.  
  1123.     //centiemes
  1124.     atemps1[2] = trest1 / 10;
  1125.  
  1126.     nombre[0] = atemps1[2] % 10;
  1127.     nombre[1] = atemps1[2] / 10;
  1128.     nombre[2] = atemps1[1] % 10;
  1129.     nombre[3] = atemps1[1] / 10;
  1130.     nombre[4] = atemps1[0] % 10;
  1131.     nombre[5] = atemps1[0] / 10;
  1132. }
  1133.  
  1134. void calcul_dcpt_ms()
  1135. {
  1136.     //calcul du temps restant
  1137.     trest1 = tfin1 - millis();
  1138.     if(trest1 <= 0)
  1139.     {
  1140.         relais();
  1141.         //affiche 000.000
  1142.         for(byte i = 0; i<6; i++)
  1143.             nombre[i] = 0;
  1144.         termine = true;
  1145.         return;
  1146.     }
  1147.  
  1148.     //decoupage puis soustraction des secondes
  1149.     atemps2[0] = trest1 / 1000;
  1150.     trest1 %= 1000;
  1151.  
  1152.     //millisecondes
  1153.     atemps2[1] = trest1;
  1154.  
  1155.  
  1156.     nombre[0] = atemps2[1] % 10;
  1157.     nombre[1] = (atemps2[1] % 100) / 10;
  1158.     nombre[2] = atemps2[1] / 100;
  1159.     nombre[3] = atemps2[0] % 10;
  1160.     nombre[4] = (atemps2[0] % 100) / 10;
  1161.     nombre[5] = atemps2[0] / 100;
  1162. }
  1163.  
  1164.  
  1165.  
  1166. void stb_cpt_nb()
  1167. {
  1168.     while(!termine)
  1169.     {
  1170.         calcul_cpt_nb();
  1171.         affiche_digits();
  1172.     }
  1173. }
  1174.  
  1175. void calcul_cpt_nb()
  1176. {
  1177.     if(trigged1)
  1178.     {
  1179.         delayMicroseconds(5000);
  1180.         trigged1 = false;
  1181.         rnb++;
  1182.         if(rnb >= rnbmax)
  1183.         {
  1184.             relais();
  1185.             termine = true;
  1186.         }
  1187.  
  1188.         nombre[5] = 0;
  1189.         nombre[4] = rnb / 10000;
  1190.         nombre[3] = (rnb / 1000) %10;
  1191.         nombre[2] = (rnb / 100) %10;
  1192.         nombre[1] = (rnb / 10) %10;
  1193.         nombre[0] = rnb%10;
  1194.     }
  1195. }
  1196.  
  1197. void stb_dcpt_nb()
  1198. {
  1199.     while(!termine)
  1200.     {
  1201.         calcul_dcpt_nb();
  1202.         affiche_digits();
  1203.     }
  1204. }
  1205.  
  1206. void calcul_dcpt_nb()
  1207. {
  1208.     if(trigged1)
  1209.     {
  1210.         delayMicroseconds(5000);
  1211.         trigged1 = false;
  1212.         rnb--;
  1213.  
  1214.         nombre[5] = 0;
  1215.         nombre[4] = rnb / 10000;
  1216.         nombre[3] = (rnb / 1000) %10;
  1217.         nombre[2] = (rnb / 100) %10;
  1218.         nombre[1] = (rnb / 10) %10;
  1219.         nombre[0] = rnb%10;
  1220.  
  1221.         if(rnb <= 0)
  1222.         {
  1223.             relais();
  1224.             termine = true;
  1225.         }
  1226.     }
  1227. }
  1228.  
  1229.  
  1230. void stb_vit_vit()
  1231. {
  1232.     digitalWrite(rgb_r,0);
  1233.     lcd.setCursor(0,3);
  1234.     lcd.print("V=");
  1235.  
  1236.     if(dist < 10) lcd.setCursor(6,2);
  1237.     else if(dist < 100) lcd.setCursor(7,2);
  1238.     else if(dist < 1000) lcd.setCursor(8,2);
  1239.     lcd.print("T=");
  1240.  
  1241.     while(!trigged1 || !trigged2)
  1242.     {
  1243.         if(trigged1) digitalWrite(rgb_b0, 1);
  1244.         if(trigged2) digitalWrite(rgb_b1, 1);
  1245.     }
  1246.     digitalWrite(rgb_b0, 1);
  1247.     digitalWrite(rgb_b1, 1);
  1248.  
  1249.     calcul_vit_vit();
  1250.     affiche_digits();
  1251.  
  1252.     //Precision d'affichage selon temps
  1253.     (intervalle < 100000) ?
  1254.         lcd.print(((float)intervalle)/1000,3):
  1255.         lcd.print(((float)intervalle)/1000);
  1256.  
  1257.     lcd.print("ms");
  1258.  
  1259.     lcd.setCursor(14,3); lcd.print(">RESET");
  1260.  
  1261.     lcd.setCursor(2,3);
  1262.  
  1263.     lcd.print(rvitesse);
  1264.     (vunit == mps)? lcd.print("m/s"): lcd.print("km/h");
  1265.  
  1266.     lcd.setCursor(1,3);
  1267.  
  1268.     float vkmh, vmps;
  1269.  
  1270.     if (vunit == mps)
  1271.     {
  1272.         vmps = rvitesse;
  1273.         vkmh = rvitesse*3.6;
  1274.     }
  1275.     else
  1276.     {
  1277.         vkmh = rvitesse;
  1278.         vmps = rvitesse / 3.6;
  1279.     }
  1280.  
  1281.     while(!digitalRead(ok))
  1282.     {
  1283.         if(digitalRead(gauche) || digitalRead(droite))
  1284.         {
  1285.             lcd.setCursor(2,3);
  1286.             if(vunit == mps)
  1287.             {
  1288.                 vunit = kmh;
  1289.                 lcd.print(vkmh);
  1290.                 lcd.print("km/h");
  1291.             }
  1292.             else
  1293.             {
  1294.                 vunit = mps;
  1295.                 lcd.print(vmps);
  1296.                 lcd.print("m/s  ");
  1297.             }
  1298.             calcul_vit_vit();
  1299.             affiche_digits();
  1300.  
  1301.             lcd.setCursor(1,3);
  1302.             while(digitalRead(gauche) || digitalRead(droite)) {}
  1303.             delay(antirebond);
  1304.         }
  1305.     }
  1306.  
  1307.     while(digitalRead(ok)) {}
  1308.     delay(antirebond*2);
  1309. }
  1310.  
  1311. void calcul_vit_vit()
  1312.  {
  1313.  
  1314.     (tv1 > tv0)?
  1315.         intervalle = tv1 - tv0:
  1316.         intervalle = tv0 - tv1;
  1317.  
  1318.         rvitesse = ((float)dist/100.0)/((float)(intervalle)/1000000.0);
  1319.  
  1320.     if(vunit == kmh) rvitesse *= 3.6;
  1321.  
  1322.     if(rvitesse < 1000)
  1323.     {
  1324.         digitalWrite(pt0,0);
  1325.         digitalWrite(pt1,1);
  1326.         nombre[5] = (int)(rvitesse / 100);
  1327.         nombre[4] = ((int)(rvitesse / 10)) % 10;
  1328.         nombre[3] = ((int)(rvitesse)) % 10;
  1329.         nombre[2] = ((int)(rvitesse * 10)) % 10;
  1330.         nombre[1] = ((long)(rvitesse * 100)) % 10;
  1331.         nombre[0] = ((long)(rvitesse * 1000)) % 10;
  1332.     }
  1333.  
  1334.     else if(rvitesse < 10000)
  1335.     {
  1336.         digitalWrite(pt1,0);
  1337.         digitalWrite(pt0,1);
  1338.         nombre[5] = (int)(rvitesse / 1000);
  1339.         nombre[4] = ((int)(rvitesse / 100)) % 10;
  1340.         nombre[3] = ((int)(rvitesse /10)) % 10;
  1341.         nombre[2] = ((int)rvitesse) % 10;
  1342.         nombre[1] = ((long)(rvitesse * 10)) % 10;
  1343.         nombre[0] = ((long)(rvitesse * 100)) % 10;
  1344.     }
  1345.  
  1346.     else
  1347.     {
  1348.         digitalWrite(pt0,1);
  1349.         nombre[5] = 9;
  1350.         nombre[4] = 9;
  1351.         nombre[3] = 9;
  1352.         nombre[2] = 9;
  1353.         nombre[1] = 9;
  1354.         nombre[0] = 9;
  1355.     }
  1356. }
  1357.  
  1358. void stb_vit_itrv()
  1359. {
  1360.     digitalWrite(rgb_r,0);
  1361.     lcd.setCursor(0,2); lcd.print("T=");
  1362.  
  1363.     while(!trigged1 || !trigged2)
  1364.     {
  1365.         if(trigged1) digitalWrite(rgb_b0, 1);
  1366.         if(trigged2) digitalWrite(rgb_b1, 1);
  1367.     }
  1368.  
  1369.     digitalWrite(rgb_b1, 1);
  1370.     digitalWrite(rgb_b0, 1);
  1371.     calcul_vit_itrv();
  1372.     affiche_digits();
  1373.     lcd.print(((float)intervalle)/1000.0,3); lcd.print("ms");
  1374. }
  1375.  
  1376. void calcul_vit_itrv()
  1377. {
  1378.     (tv1 > tv0)? intervalle = tv1-tv0: intervalle = tv0-tv1;
  1379.     if(intervalle < 10000000)
  1380.     {
  1381.         //0.00000
  1382.         digitalWrite(pt2,1);
  1383.         nombre[5] = intervalle/1000000;
  1384.         nombre[4] = (intervalle/100000)%10;
  1385.         nombre[3] = (intervalle/10000)%10;
  1386.         nombre[2] = (intervalle/1000)%10;
  1387.         nombre[1] = (intervalle/100)%10;
  1388.         nombre[0] = (intervalle/10)%10;
  1389.     }
  1390.  
  1391.     else if(intervalle < 1000000000)
  1392.     {
  1393.         //000.000
  1394.         digitalWrite(pt1,1);
  1395.         nombre[5] = intervalle/100000000;
  1396.         nombre[4] = (intervalle/10000000)%10;
  1397.         nombre[3] = (intervalle/1000000)%10;
  1398.         nombre[2] = (intervalle/100000)%10;
  1399.         nombre[1] = (intervalle/10000)%10;
  1400.         nombre[0] = (intervalle/1000)%10;
  1401.     }
  1402.  
  1403.     else
  1404.     {
  1405.         //0000.00
  1406.         digitalWrite(pt0,1);
  1407.         nombre[5] = intervalle/1000000000;
  1408.         nombre[4] = (intervalle/100000000)%10;
  1409.         nombre[3] = (intervalle/10000000)%10;
  1410.         nombre[2] = (intervalle/1000000)%10;
  1411.         nombre[1] = (intervalle/100000)%10;
  1412.         nombre[0] = (intervalle/10000)%10;
  1413.     }
  1414. }
  1415.  
  1416.  
  1417. void stb_timl()
  1418. {
  1419.     timlphase = false; //start en mode off
  1420.  
  1421.     while(!trigged1){} //attente du trigger
  1422.     trigged1 = true;
  1423.  
  1424.     while(!digitalRead(RESET)) //condition d'arret du timelapse ?
  1425.     {
  1426.         timlchg = false;
  1427.         if(!timlphase)
  1428.         {
  1429.             //Reset des compteurs de fin lorsqu'un cycle est termine
  1430.             tfin1 = millis() + tadd1;
  1431.             tfin2 = tfin1 + tadd2;
  1432.         }
  1433.  
  1434.         digitalWrite(SIG,timlphase);
  1435.         digitalWrite(rgb_g,timlphase);
  1436.         digitalWrite(rgb_r,!timlphase);
  1437.  
  1438.         while(!timlchg)
  1439.         {
  1440.             switch (vunit)
  1441.             {
  1442.                 case hms: calcul_timl_hms(); break;
  1443.                 case msc: calcul_timl_msc(); break;
  1444.                 case ms: calcul_timl_ms(); break;
  1445.             }
  1446.             affiche_digits();
  1447.         }
  1448.     }
  1449. }
  1450.  
  1451.  
  1452. void calcul_timl_hms()
  1453. {
  1454.     if(!timlphase)
  1455.     {
  1456.         //Phase OFF
  1457.  
  1458.         //calcul du temps restant
  1459.         trest1 = tfin1 - millis();
  1460.         if(trest1 <= 0)
  1461.         {
  1462.             timlchg = true;
  1463.             timlphase = true;
  1464.             return;
  1465.         }
  1466.  
  1467.         //decoupage puis soustraction des heures
  1468.         atemps1[0] = trest1 / 3600000;
  1469.         trest1 %= 3600000;
  1470.  
  1471.         //minutes
  1472.         atemps1[1] = trest1 / 60000;
  1473.         trest1 %= 60000;
  1474.  
  1475.         //secondes
  1476.         atemps1[2] = trest1 / 1000;
  1477.  
  1478.         nombre[0] = atemps1[2] % 10;
  1479.         nombre[1] = atemps1[2] / 10;
  1480.         nombre[2] = atemps1[1] % 10;
  1481.         nombre[3] = atemps1[1] / 10;
  1482.         nombre[4] = atemps1[0] % 10;
  1483.         nombre[5] = atemps1[0] / 10;
  1484.     }
  1485.  
  1486.     else
  1487.     {
  1488.         //Phase ON
  1489.  
  1490.         //calcul du temps restant
  1491.         trest2 = tfin2 - millis();
  1492.         if(trest2 <= 0)
  1493.         {
  1494.             timlchg = true;
  1495.             timlphase = false;
  1496.             return;
  1497.         }
  1498.  
  1499.         //decoupage puis soustraction des heures
  1500.         atemps12[0] = trest2 / 3600000;
  1501.         trest2 %= 3600000;
  1502.  
  1503.         //minutes
  1504.         atemps12[1] = trest2 / 60000;
  1505.         trest2 %= 60000;
  1506.  
  1507.         //secondes
  1508.         atemps12[2] = trest2 / 1000;
  1509.  
  1510.         nombre[0] = atemps12[2] % 10;
  1511.         nombre[1] = atemps12[2] / 10;
  1512.         nombre[2] = atemps12[1] % 10;
  1513.         nombre[3] = atemps12[1] / 10;
  1514.         nombre[4] = atemps12[0] % 10;
  1515.         nombre[5] = atemps12[0] / 10;
  1516.     }
  1517. }
  1518.  
  1519. void calcul_timl_msc()
  1520. {
  1521.  
  1522.     if(!timlphase)
  1523.     {
  1524.         //Phase OFF
  1525.  
  1526.         //calcul du temps restant
  1527.         trest1 = tfin1 - millis();
  1528.         if(trest1 <= 0)
  1529.         {
  1530.             timlchg = true;
  1531.             timlphase = true;
  1532.             return;
  1533.         }
  1534.  
  1535.         //decoupage puis soustraction des minutes
  1536.         atemps1[0] = trest1 / 60000;
  1537.         trest1 %= 60000;
  1538.  
  1539.         //secondes
  1540.         atemps1[1] = trest1 / 1000;
  1541.         trest1 %= 1000;
  1542.  
  1543.         //centiemes
  1544.         atemps1[2] = trest1 / 10;
  1545.  
  1546.         nombre[0] = atemps1[2] % 10;
  1547.         nombre[1] = atemps1[2] / 10;
  1548.         nombre[2] = atemps1[1] % 10;
  1549.         nombre[3] = atemps1[1] / 10;
  1550.         nombre[4] = atemps1[0] % 10;
  1551.         nombre[5] = atemps1[0] / 10;
  1552.     }
  1553.  
  1554.     else
  1555.     {
  1556.         //Phase ON
  1557.  
  1558.         //calcul du temps restant
  1559.         trest2 = tfin2 - millis();
  1560.         if(trest2 <= 0)
  1561.         {
  1562.             timlchg = true;
  1563.             timlphase = false;
  1564.             return;
  1565.         }
  1566.  
  1567.         //decoupage puis soustraction des minutes
  1568.         atemps12[0] = trest2 / 60000;
  1569.         trest2 %= 60000;
  1570.  
  1571.         //secondes
  1572.         atemps12[1] = trest2 / 1000;
  1573.         trest2 %= 1000;
  1574.  
  1575.         //centiemes
  1576.         atemps12[2] = trest2 / 10;
  1577.  
  1578.         nombre[0] = atemps12[2] % 10;
  1579.         nombre[1] = atemps12[2] / 10;
  1580.         nombre[2] = atemps12[1] % 10;
  1581.         nombre[3] = atemps12[1] / 10;
  1582.         nombre[4] = atemps12[0] % 10;
  1583.         nombre[5] = atemps12[0] / 10;
  1584.     }
  1585. }
  1586.  
  1587. void calcul_timl_ms()
  1588. {
  1589.     if(!timlphase)
  1590.     {
  1591.         //Phase ON
  1592.  
  1593.         //calcul du temps restant
  1594.         trest1 = tfin1 - millis();
  1595.         if(trest1 <= 0)
  1596.         {
  1597.             timlchg = true;
  1598.             timlphase = true;
  1599.             return;
  1600.         }
  1601.  
  1602.         //decoupage puis soustraction des secondes
  1603.         atemps2[0] = trest1 / 1000;
  1604.         trest1 %= 1000;
  1605.  
  1606.         //millisecondes
  1607.         atemps2[1] = trest1;
  1608.  
  1609.         nombre[0] = atemps2[1] % 10;
  1610.         nombre[1] = (atemps2[1] % 100) / 10;
  1611.         nombre[2] = atemps2[1] / 100;
  1612.         nombre[3] = atemps2[0] % 10;
  1613.         nombre[4] = (atemps2[0] % 100) / 10;
  1614.         nombre[5] = atemps2[0] / 100;
  1615.     }
  1616.  
  1617.     else
  1618.     {
  1619.         //Phase OFF
  1620.  
  1621.         //calcul du temps restant
  1622.         trest2 = tfin2 - millis();
  1623.         if(trest2 <= 0)
  1624.         {
  1625.             timlchg = true;
  1626.             timlphase = false;
  1627.             return;
  1628.         }
  1629.  
  1630.         //decoupage puis soustraction des secondes
  1631.         atemps22[0] = trest2 / 1000;
  1632.         trest2 %= 1000;
  1633.  
  1634.         //millisecondes
  1635.         atemps22[1] = trest2;
  1636.  
  1637.         nombre[0] = atemps22[1] % 10;
  1638.         nombre[1] = (atemps22[1] % 100) / 10;
  1639.         nombre[2] = atemps22[1] / 100;
  1640.         nombre[3] = atemps22[0] % 10;
  1641.         nombre[4] = (atemps22[0] % 100) / 10;
  1642.         nombre[5] = atemps22[0] / 100;
  1643.     }
  1644. }
  1645.  
  1646.  
  1647. void affiche_digits()
  1648. {
  1649.     for(byte i=0; i<6; i++)
  1650.     {
  1651.         for(byte n=0; n<4; n++)
  1652.             digitalWrite(digit[n], bitRead(nombre[i],n));
  1653.         //Latch
  1654.         digitalWrite(latch[i],1);
  1655.         digitalWrite(latch[i],0);
  1656.     }
  1657. }
  1658.  
  1659.  
  1660.  
  1661.  
  1662. void trigger1()
  1663. {
  1664.     if(!trigged1)
  1665.     {
  1666.         t0 = millis();
  1667.         tv0 = micros();
  1668.         trigged1 = true;
  1669.     }
  1670. }
  1671.  
  1672. void trigger2()
  1673. {
  1674.     if(!trigged2)
  1675.     {
  1676.         t1 = millis();
  1677.         tv1 = micros();
  1678.         trigged2 = true;
  1679.     }
  1680. }
  1681.  
  1682. void pause()
  1683. {
  1684.     while(digitalRead(PAUSE)) {}
  1685. }
  1686.  
  1687. void affiche_points()
  1688. {
  1689.     reset_pts();
  1690.  
  1691.     switch(vunit)
  1692.     {
  1693.     case hms:
  1694.         digitalWrite(dpt0,1);
  1695.         digitalWrite(dpt1,1);
  1696.         break;
  1697.     case msc:
  1698.         digitalWrite(dpt1,1);
  1699.         digitalWrite(pt0,1);
  1700.         break;
  1701.     case ms:
  1702.         digitalWrite(pt1,1);
  1703.         break;
  1704.     default:
  1705.         break;
  1706.     }
  1707. }
  1708.  
  1709. void reset_pts()
  1710. {
  1711.     //Eteint tous les points
  1712.     digitalWrite(pt0,0); digitalWrite(pt1,0); digitalWrite(pt2,0);
  1713.     digitalWrite(dpt0,0); digitalWrite(dpt1,0);
  1714. }
  1715.  
  1716. void reset_digits()
  1717. {
  1718.     for(byte n=0; n<4; n++)
  1719.         digitalWrite(digit[n],0);
  1720.  
  1721.     for(byte i=0; i<6; i++)
  1722.     {
  1723.         digitalWrite(latch[i],1);
  1724.         digitalWrite(latch[i],0);
  1725.     }
  1726. }
  1727.  
  1728. void reset_rgb()
  1729. {
  1730.     //Remet les RGB sur Rouge
  1731.     digitalWrite(rgb_g,0); digitalWrite(rgb_b0,0); digitalWrite(rgb_b1,0); digitalWrite(rgb_r,1);
  1732. }
  1733.  
  1734. void reset_all()
  1735. {
  1736.     termine = false; trigged1 = false; trigged2 = false;
  1737.     reset_pts();
  1738.     reset_digits();
  1739.     reset_rgb();
  1740.     digitalWrite(SIG,0);
  1741.     digitalWrite(rgb_g,0); digitalWrite(rgb_r,1);
  1742. }
  1743.  
  1744.  
  1745. void relais()
  1746. {
  1747.     digitalWrite(SIG,1);
  1748.     digitalWrite(rgb_r,0);
  1749.     digitalWrite(rgb_g,1);
  1750. }
  1751.  
  1752. void loop()
  1753. {
  1754.     menu();
  1755.     mode();
  1756.     smode();
  1757.     unite();
  1758.     reglage();
  1759.     stb_ok();
  1760.     stb();
  1761.  
  1762.     lcd.setCursor(14,3); lcd.print(">RESET"); lcd.setCursor(14,3);
  1763.  
  1764.     while(!digitalRead(retour) && !digitalRead(ok)){}
  1765.         if (digitalRead(retour)) again = false; else if(digitalRead(ok)) again = true;
  1766.  
  1767.     reset_all();
  1768. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!