Les Tutos d'Enzo #03 Tableau de maître Lumineux sur batterie

Retrouvez sur cette page tous les tutos d' enzo Image
Avatar de l’utilisateur
miaouss
Messages : 9
Inscription : 09 juil. 2018, 22:23

Les Tutos d'Enzo #03 Tableau de maître Lumineux sur batterie

Message par miaouss » 18 déc. 2018, 02:44

Ce Projet se trouve également sur le projecthub Arduino Create à cette adresse :

https://create.arduino.cc/projecthub/mi ... ree-6a7907


Cette vidéo ne reflète pas la totalité du projet, il est bien plus compliqué et cool que sur la vidéo.
(Il m'aurai fallut filmer 2 mois non stop pour vous montrer sinon)
https://video-cdg2-1.xx.fbcdn.net/v/t42 ... e=5C18CA19

........./\0/\
.....= ( ' .' ) =
...... ( '')_( '')
...................

Image

Ce projet a pour but d'animer un tableau de peinture et de le faire vivre dans le noir.
Les principales formules que j'ai trouvé pour ce projet sont:
Les leds des joyaux qui scintillent aléatoirement par couleur.
Le Loop complet du code ne s’exécute qu'une seul fois par jour pour conserver la batterie le plus longtemps possible grasse à un capteur photorésistance.
Le tableau ne s'allumera qu'une fois la nuit tombé, à peu près 15 minutes après, le capteur de luminosité à taré (sa valeur de déclenchement) pour en profiter été comme hiver et donc de pouvoir en profité dans une tranche horaire où je suis sur d’être chez moi.
La fonction Watchdog a été intégré au projet pour l'économie max de la batterie,


1- le test de luminosité a lieu toutes les 15 min quand il fait jour. puis se remet en veille si il fait toujours jour.

2- On passe le drapeau à = 0 (ce drapeau représente le lancement du programme pour qu'il ne soit exécuté qu'une fois par jour, vous comprendrez en lisant la suite).

3- Si il fait nuit, une pose de 15 min sans rien allumé le temps que le capteur détecte bel et bien la nuit (pour évite le clignotement du passage ou la valeur du capteur afficherait une donnée instable entre jour et nuit)

4- le programme du scintillement des leds s’exécute pendant 10 min.

5- 2 eme pose du programme, on éteint tout. Et on économise la batterie.

6- 2 eme démarrage du programme, on allume tout pendant 10 min

7- 3 eme pose

8 - 3 eme démarrage du programme

9 - pose

10 - Démarrage

11 - Pose

12 - Démarrage

13 - Pose

14 - Dernier démarrage du programme de la soirée, une variante par rapport au autre.
Les leds blanche sont éteintes pour indiquer que c'est le dernier allumage du tableau de la soirée.
Après ces 10 min, le tableau passera en mode veille prolongé jusqu’à ce que le jour du lendemain vienne informé le capteur de luminosité, ce qui remettra la variable du drapeau à = 1 pour autorisé l’exécution de tout le programme que nous venons de passer en revue une foie la nuit tombé.

Dans mon expérience, j'ai deux batterie Li-Iion de 3,7V en parallèle et le tableau reste actif pendant plus de deux mois sans y toucher. Je pense que ce programme pourrai être très efficace avec une batterie de très bonne qualité. je n'ai pas testé.

Désolé pour le code répétitif, mais à l’époque de sa conception j'étais débutant et je ne maîtrisais pas les "Fonctions" du code Arduino.

J' ai utilisé un Atmega avec le Bootloader Arduino à 8mhz du Quartz interne.

https://www.facebook.com/photo.php?fbid ... wy03HcfwyD

https://www.facebook.com/photo.php?fbid ... 4JxIdUWLGd

https://www.facebook.com/10000935990461 ... rdJdxsSSUC

https://www.facebook.com/10000935990461 ... 793901034/

https://www.facebook.com/10000935990461 ... 096992837/

https://www.facebook.com/10000935990461 ... 339887746/

https://www.facebook.com/photo.php?fbid ... hGhbYH-Hsk

https://www.facebook.com/10000935990461 ... FXl-vbzpy9

https://www.facebook.com/photo.php?fbid ... p2JuwZRIs3

https://www.facebook.com/10000935990461 ... GgNFn4mZFy

https://www.facebook.com/10000935990461 ... 259704954/

https://www.facebook.com/10000935990461 ... 329704947/

https://www.facebook.com/10000935990461 ... 139704866/

https://scontent-cdg2-1.xx.fbcdn.net/v/ ... e=5C940EC5

https://scontent-cdg2-1.xx.fbcdn.net/v/ ... e=5C9990E1

https://scontent-cdg2-1.xx.fbcdn.net/v/ ... e=5CA785DB

https://scontent-cdg2-1.xx.fbcdn.net/v/ ... e=5CD64CE2







Image

Image

Image

Image

Image

Image

Image

Image

Image

Image

Image


Code pour les testes (en mode Rapide)

Code : Tout sélectionner

//variable du programe led du tableau + capteur photorésistance
int ledRouge;

int ledVerte;

int luminositeValeur;

int ledBleu;

int LedBlanche;

int luminositeOff;

int luminositeOn;

int bichette;

int brightnessRouge;

int brightnessVerte;

int brightnessBleu;

int brightnessBlanche;

int fadeAmount;

int valeurLedMaxRouge;

int temps;

int valeurLedMinRouge;

int valeurLedMinVerte;

int valeurLedMaxVerte;

int valeurLedMinBleu;

int valeurLedMaxBleu;

int valeurLedMinBlanche;

int valeurLedMaxBlanche;

long math_random_int(int a,int b) {
  if (a > b) {
    // Swap a and b to ensure a is smaller.
    int c = a;
    a = b;
    b = c;
  }
  return random(a,b);
}

//vatriable du sleep mode WDT
#include <avr/power.h>
#include <avr/sleep.h>
#include <avr/wdt.h>
 
#ifndef cbi
#  define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit))
#endif
#ifndef sbi
#  define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit))
#endif
 
volatile boolean f_wdt=1;
 
// Watchdog Interrupt Service / is executed when watchdog timed out
ISR(WDT_vect) {
  f_wdt=1;  // set global flag
}
 
//****************************************************************
// 0=16ms, 1=32ms,2=64ms,3=128ms,4=250ms,5=500ms
// 6=1 sec,7=2 sec, 8=4 sec, 9=8 sec


void setup_watchdog(int ii) {
  byte bb;
  int ww;
  if (ii > 9 ) ii=9;
  bb=ii & 7;
  if (ii > 7) bb|= (1<<5);
  bb|= (1<<WDCE);
  ww=bb;
  MCUSR &= ~(1<<WDRF);
  // start timed sequence
  WDTCSR |= (1<<WDCE) | (1<<WDE);
  // set new watchdog timeout value
  WDTCSR = bb;
  WDTCSR |= _BV(WDIE);
}
 
//****************************************************************  
// set system into the sleep state
// system wakes up when wtchdog is timed out
void system_sleep() {
  cbi(ADCSRA,ADEN);  // switch Analog to Digitalconverter OFF
  set_sleep_mode(SLEEP_MODE_PWR_DOWN); // sleep mode is set here
  sleep_enable();
  sleep_mode();                        // System sleeps here
  sleep_disable();              // System continues execution here when watchdog timed out
  sbi(ADCSRA,ADEN);                    // switch Analog to Digitalconverter ON
}
 
void setup() {

//setup du programe led du tableau + capteur photorésistance
  ledRouge = 10;
  ledVerte = 5;
  ledBleu = 6;
  LedBlanche = 9;
  brightnessRouge = 100;
  brightnessVerte = 100;
  brightnessBleu = 100;
  brightnessBlanche = 100;
  fadeAmount = 8;
  temps = 10;
  valeurLedMinRouge = 30;
  valeurLedMaxRouge = 240;
  valeurLedMinVerte = 15;
  valeurLedMaxVerte = 90;
  valeurLedMinBleu = 50;
  valeurLedMaxBleu = 255;
  valeurLedMinBlanche = 100;
  valeurLedMaxBlanche = 120;
  luminositeOff = 460;
  luminositeOn = 480;
  luminositeValeur = 0;

  pinMode(A2, INPUT);
  Serial.begin(9600);
  pinMode(ledRouge, OUTPUT);
  pinMode(ledVerte, OUTPUT);
  pinMode(ledBleu, OUTPUT);
  pinMode(LedBlanche, OUTPUT);

//setup du sleep mode WDT

  Serial.println ("setup");
  //Optimisation de la consommation
 //power_adc_disable(); // Convertisseur Analog / Digital pour les entrées analogiques
power_spi_disable();
 power_twi_disable();
 // Si pas besoin de communiquer par l'usb
 //power_usart0_disable();
 //Extinction des timers, attention timer0 utilisé par millis ou delay
//power_timer0_disable(); 
 //power_timer1_disable();
 power_timer2_disable();
// other stuff you want to setup
  cbi( SMCR,SE );      // sleep enable, power down mode
  cbi( SMCR,SM0 );     // power down mode 
  sbi( SMCR,SM1 );     // power down mode
  cbi( SMCR,SM2 );     // power down mode
  setup_watchdog(9);
}



void loop()
{

//#0 **********Teste de luminosité*******
  Serial.println(analogRead(A2),DEC);
  //Serial.println(luminositeValeur,DEC);
  if (analogRead(A2) < luminositeOff) { //initialisation calibration pour éviter l'entre deux valeurs au moment precis entre jour et nuit (allumage qui clignote car il ne fait ni nuit ni jour)
    luminositeValeur = 2;                     

  } else if (analogRead(A2) > luminositeOn) {
    luminositeValeur = 0;
  }


//#1 **********Si il fait jour -> extinction de toutes les LEDs**********  
  if (luminositeValeur < 1) { //extinction des alimentation Led
    analogWrite(ledRouge, 0);
    analogWrite(ledVerte, 0);
    analogWrite(ledBleu, 0);
    analogWrite(LedBlanche, 0);
    delay (10);


    //#1.1 *********Mode veille************
 for (int count = 1; count < 15; count++) { // compte de 0 à 114( 113X) la valeur du setup_watchdod()
                                               //ex si setup_watchdog(9) "9 = 8s" 9 x 8s = 72s 
                                               // 15 min = 900s <=> 900/8s = 112.5s ~=113s
         if (f_wdt==1) // wait for timed out watchdog
         system_sleep();
  }
    if (f_wdt==1) // wait for timed out watchdog
  
    f_wdt=0;   
  // do some stuff
  Serial.println ("awake1");
  delay (10);
  system_sleep(); // when we wake up, we’ll return to the top of the loop


  }


//#2 *********Sinon, il fait nuit ***********
else {


//#3 ********1er pause, Attente de quelques instants avant démarage du programme*******
for (int count = 1; count < 20; count++) { // compte de 0 à 114( 113X) la valeur du setup_watchdod()
                                               //ex si setup_watchdog(9) "9 = 8s" 9 x 8s = 72s 
                                               // 15 min = 900s <=> 900/8s = 112.5s ~=113s
         if (f_wdt==1) // wait for timed out watchdog
         system_sleep();
  }
    if (f_wdt==1) // wait for timed out watchdog
  
    f_wdt=0;   
  // do some stuff
  Serial.println ("awake2");
  delay (10);
  system_sleep(); // when we wake up, we’ll return to the top of the loop


  

  //#4 *******Démarage du programe pour un sertin temps avant de fair une pose*****
for (int count = 0; count < 2250; count++) { //Temps total du programme allumé 40 mseconde (15000 tours = 10 min)


 bichette = math_random_int(1, 10);
    analogWrite(ledRouge, brightnessRouge);
    if (bichette % 2 == 0) {
      if (brightnessRouge > valeurLedMaxRouge) {
        brightnessRouge = (valeurLedMaxRouge + valeurLedMinRouge) / 2;

      } else {
        brightnessRouge = brightnessRouge + fadeAmount;

      }
      delay(temps);

    }
    if (bichette % 2 == 1) {
      if (brightnessRouge < valeurLedMinRouge) {
        brightnessRouge = (valeurLedMaxRouge + valeurLedMinRouge) / 2;

      } else {
        brightnessRouge = brightnessRouge - fadeAmount;

      }
      delay(temps);

    }
    bichette = math_random_int(1, 10);
    analogWrite(ledVerte, brightnessVerte);
    if (bichette % 2 == 0) {
      if (brightnessVerte > valeurLedMaxVerte) {
        brightnessVerte = (valeurLedMaxVerte + valeurLedMinVerte) / 2;

      } else {
        brightnessVerte = brightnessVerte + fadeAmount;

      }
      delay(temps);

    }
    if (bichette % 2 == 1) {
      if (brightnessVerte < valeurLedMinVerte) {
        brightnessVerte = (valeurLedMaxVerte + valeurLedMinVerte) / 2;

      } else {
        brightnessVerte = brightnessVerte - fadeAmount;

      }
      delay(temps);

    }
    bichette = math_random_int(1, 10);
    analogWrite(ledBleu, brightnessBleu);
    if (bichette % 2 == 0) {
      if (brightnessBleu > valeurLedMaxBleu) {
        brightnessBleu = (valeurLedMaxBleu + valeurLedMinBleu) / 2;

      } else {
        brightnessBleu = brightnessBleu + fadeAmount;

      }
      delay(temps);

    }
    if (bichette % 2 == 1) {
      if (brightnessBleu < valeurLedMinBleu) {
        brightnessBleu = (valeurLedMaxBleu + valeurLedMinBleu) / 2;

      } else {
        brightnessBleu = brightnessBleu - fadeAmount;

      }
      delay(temps);

    }
    bichette = math_random_int(1, 10);
    analogWrite(LedBlanche, brightnessBlanche);
    if (bichette % 2 == 0) {
      if (brightnessBlanche > valeurLedMaxBlanche) {
        brightnessBlanche = (valeurLedMaxBlanche + valeurLedMinBlanche) / 2;

      } else {
        brightnessBlanche = brightnessBlanche + fadeAmount;

      }
      delay(temps);

    }
    if (bichette % 2 == 1) {
      if (brightnessBlanche < valeurLedMinBlanche) {
        brightnessBlanche = (valeurLedMaxBlanche + valeurLedMinBlanche) / 2;

      } else {
        brightnessBlanche = brightnessBlanche - fadeAmount;

      }
      delay(temps);

      }
     }
      //#5 ********2er pause, Attente de quelques instants avant de continué le programme*******
     {
          //on étin les leds
           analogWrite(ledRouge, 0);
           analogWrite(ledVerte, 0);
           analogWrite(ledBleu, 0);
           analogWrite(LedBlanche, 0);
           delay (10);

            //on passe en mode sleep
            for (int count = 1; count < 20; count++) { // compte de 0 à 114( 113X) la valeur du setup_watchdod()
                                               //ex si setup_watchdog(9) "9 = 8s" 9 x 8s = 72s 
                                               // 15 min = 900s <=> 900/8s = 112.5s ~=113s
            if (f_wdt==1) // wait for timed out watchdog
            system_sleep();
             }
            if (f_wdt==1) // wait for timed out watchdog
  
            f_wdt=0;   
            // do some stuff
            Serial.println ("awake3");
            delay (10);
            system_sleep(); // when we wake up, we’ll return to the top of the loop

//6 *******Démarage du programe pour un sertin temps avant de fair une pose*****
for (int count = 0; count < 2250; count++) { //Temps total du programme allumé 40 mseconde (15000 tours = 10 min)


 bichette = math_random_int(1, 10);
    analogWrite(ledRouge, brightnessRouge);
    if (bichette % 2 == 0) {
      if (brightnessRouge > valeurLedMaxRouge) {
        brightnessRouge = (valeurLedMaxRouge + valeurLedMinRouge) / 2;

      } else {
        brightnessRouge = brightnessRouge + fadeAmount;

      }
      delay(temps);

    }
    if (bichette % 2 == 1) {
      if (brightnessRouge < valeurLedMinRouge) {
        brightnessRouge = (valeurLedMaxRouge + valeurLedMinRouge) / 2;

      } else {
        brightnessRouge = brightnessRouge - fadeAmount;

      }
      delay(temps);

    }
    bichette = math_random_int(1, 10);
    analogWrite(ledVerte, brightnessVerte);
    if (bichette % 2 == 0) {
      if (brightnessVerte > valeurLedMaxVerte) {
        brightnessVerte = (valeurLedMaxVerte + valeurLedMinVerte) / 2;

      } else {
        brightnessVerte = brightnessVerte + fadeAmount;

      }
      delay(temps);

    }
    if (bichette % 2 == 1) {
      if (brightnessVerte < valeurLedMinVerte) {
        brightnessVerte = (valeurLedMaxVerte + valeurLedMinVerte) / 2;

      } else {
        brightnessVerte = brightnessVerte - fadeAmount;

      }
      delay(temps);

    }
    bichette = math_random_int(1, 10);
    analogWrite(ledBleu, brightnessBleu);
    if (bichette % 2 == 0) {
      if (brightnessBleu > valeurLedMaxBleu) {
        brightnessBleu = (valeurLedMaxBleu + valeurLedMinBleu) / 2;

      } else {
        brightnessBleu = brightnessBleu + fadeAmount;

      }
      delay(temps);

    }
    if (bichette % 2 == 1) {
      if (brightnessBleu < valeurLedMinBleu) {
        brightnessBleu = (valeurLedMaxBleu + valeurLedMinBleu) / 2;

      } else {
        brightnessBleu = brightnessBleu - fadeAmount;

      }
      delay(temps);

    }
    bichette = math_random_int(1, 10);
    analogWrite(LedBlanche, brightnessBlanche);
    if (bichette % 2 == 0) {
      if (brightnessBlanche > valeurLedMaxBlanche) {
        brightnessBlanche = (valeurLedMaxBlanche + valeurLedMinBlanche) / 2;

      } else {
        brightnessBlanche = brightnessBlanche + fadeAmount;

      }
      delay(temps);

    }
    if (bichette % 2 == 1) {
      if (brightnessBlanche < valeurLedMinBlanche) {
        brightnessBlanche = (valeurLedMaxBlanche + valeurLedMinBlanche) / 2;

      } else {
        brightnessBlanche = brightnessBlanche - fadeAmount;

      }
      delay(temps);

      }
     }
      //#7 ********2er pause, Attente de quelques instants avant de continué le programme*******
     {
          //on étin les leds
           analogWrite(ledRouge, 0);
           analogWrite(ledVerte, 0);
           analogWrite(ledBleu, 0);
           analogWrite(LedBlanche, 0);
           delay (10);

            //on passe en mode sleep
            for (int count = 1; count < 20; count++) { // compte de 0 à 114( 113X) la valeur du setup_watchdod()
                                               //ex si setup_watchdog(9) "9 = 8s" 9 x 8s = 72s 
                                               // 15 min = 900s <=> 900/8s = 112.5s ~=113s
            if (f_wdt==1) // wait for timed out watchdog
            system_sleep();
             }
            if (f_wdt==1) // wait for timed out watchdog
  
            f_wdt=0;   
            // do some stuff
            Serial.println ("awake4");
            delay (10);
            system_sleep(); // when we wake up, we’ll return to the top of the loop

                  //8 *******Démarage du programe pour un sertin temps avant de fair une pose*****
for (int count = 0; count < 2250; count++) { //Temps total du programme allumé 40 mseconde (15000 tours = 10 min)


 bichette = math_random_int(1, 10);
    analogWrite(ledRouge, brightnessRouge);
    if (bichette % 2 == 0) {
      if (brightnessRouge > valeurLedMaxRouge) {
        brightnessRouge = (valeurLedMaxRouge + valeurLedMinRouge) / 2;

      } else {
        brightnessRouge = brightnessRouge + fadeAmount;

      }
      delay(temps);

    }
    if (bichette % 2 == 1) {
      if (brightnessRouge < valeurLedMinRouge) {
        brightnessRouge = (valeurLedMaxRouge + valeurLedMinRouge) / 2;

      } else {
        brightnessRouge = brightnessRouge - fadeAmount;

      }
      delay(temps);

    }
    bichette = math_random_int(1, 10);
    analogWrite(ledVerte, brightnessVerte);
    if (bichette % 2 == 0) {
      if (brightnessVerte > valeurLedMaxVerte) {
        brightnessVerte = (valeurLedMaxVerte + valeurLedMinVerte) / 2;

      } else {
        brightnessVerte = brightnessVerte + fadeAmount;

      }
      delay(temps);

    }
    if (bichette % 2 == 1) {
      if (brightnessVerte < valeurLedMinVerte) {
        brightnessVerte = (valeurLedMaxVerte + valeurLedMinVerte) / 2;

      } else {
        brightnessVerte = brightnessVerte - fadeAmount;

      }
      delay(temps);

    }
    bichette = math_random_int(1, 10);
    analogWrite(ledBleu, brightnessBleu);
    if (bichette % 2 == 0) {
      if (brightnessBleu > valeurLedMaxBleu) {
        brightnessBleu = (valeurLedMaxBleu + valeurLedMinBleu) / 2;

      } else {
        brightnessBleu = brightnessBleu + fadeAmount;

      }
      delay(temps);

    }
    if (bichette % 2 == 1) {
      if (brightnessBleu < valeurLedMinBleu) {
        brightnessBleu = (valeurLedMaxBleu + valeurLedMinBleu) / 2;

      } else {
        brightnessBleu = brightnessBleu - fadeAmount;

      }
      delay(temps);

    }
    bichette = math_random_int(1, 10);
    analogWrite(LedBlanche, brightnessBlanche);
    if (bichette % 2 == 0) {
      if (brightnessBlanche > valeurLedMaxBlanche) {
        brightnessBlanche = (valeurLedMaxBlanche + valeurLedMinBlanche) / 2;

      } else {
        brightnessBlanche = brightnessBlanche + fadeAmount;

      }
      delay(temps);

    }
    if (bichette % 2 == 1) {
      if (brightnessBlanche < valeurLedMinBlanche) {
        brightnessBlanche = (valeurLedMaxBlanche + valeurLedMinBlanche) / 2;

      } else {
        brightnessBlanche = brightnessBlanche - fadeAmount;

      }
      delay(temps);

      }
     }
      //#9 ********2er pause, Attente de quelques instants avant de continué le programme*******
     {
          //on étin les leds
           analogWrite(ledRouge, 0);
           analogWrite(ledVerte, 0);
           analogWrite(ledBleu, 0);
           analogWrite(LedBlanche, 0);
           delay (10);

            //on passe en mode sleep
            for (int count = 1; count < 20; count++) { // compte de 0 à 114( 113X) la valeur du setup_watchdod()
                                               //ex si setup_watchdog(9) "9 = 8s" 9 x 8s = 72s 
                                               // 15 min = 900s <=> 900/8s = 112.5s ~=113s
            if (f_wdt==1) // wait for timed out watchdog
            system_sleep();
             }
            if (f_wdt==1) // wait for timed out watchdog
  
            f_wdt=0;   
            // do some stuff
            Serial.println ("awake5");
            delay (10);
            system_sleep(); // when we wake up, we’ll return to the top of the loop

      //10 *******Démarage du programe pour un sertin temps avant de fair une pose*****
for (int count = 0; count < 2250; count++) { //Temps total du programme allumé 40 mseconde (15000 tours = 10 min)


 bichette = math_random_int(1, 10);
    analogWrite(ledRouge, brightnessRouge);
    if (bichette % 2 == 0) {
      if (brightnessRouge > valeurLedMaxRouge) {
        brightnessRouge = (valeurLedMaxRouge + valeurLedMinRouge) / 2;

      } else {
        brightnessRouge = brightnessRouge + fadeAmount;

      }
      delay(temps);

    }
    if (bichette % 2 == 1) {
      if (brightnessRouge < valeurLedMinRouge) {
        brightnessRouge = (valeurLedMaxRouge + valeurLedMinRouge) / 2;

      } else {
        brightnessRouge = brightnessRouge - fadeAmount;

      }
      delay(temps);

    }
    bichette = math_random_int(1, 10);
    analogWrite(ledVerte, brightnessVerte);
    if (bichette % 2 == 0) {
      if (brightnessVerte > valeurLedMaxVerte) {
        brightnessVerte = (valeurLedMaxVerte + valeurLedMinVerte) / 2;

      } else {
        brightnessVerte = brightnessVerte + fadeAmount;

      }
      delay(temps);

    }
    if (bichette % 2 == 1) {
      if (brightnessVerte < valeurLedMinVerte) {
        brightnessVerte = (valeurLedMaxVerte + valeurLedMinVerte) / 2;

      } else {
        brightnessVerte = brightnessVerte - fadeAmount;

      }
      delay(temps);

    }
    bichette = math_random_int(1, 10);
    analogWrite(ledBleu, brightnessBleu);
    if (bichette % 2 == 0) {
      if (brightnessBleu > valeurLedMaxBleu) {
        brightnessBleu = (valeurLedMaxBleu + valeurLedMinBleu) / 2;

      } else {
        brightnessBleu = brightnessBleu + fadeAmount;

      }
      delay(temps);

    }
    if (bichette % 2 == 1) {
      if (brightnessBleu < valeurLedMinBleu) {
        brightnessBleu = (valeurLedMaxBleu + valeurLedMinBleu) / 2;

      } else {
        brightnessBleu = brightnessBleu - fadeAmount;

      }
      delay(temps);

    }
    bichette = math_random_int(1, 10);
    analogWrite(LedBlanche, brightnessBlanche);
    if (bichette % 2 == 0) {
      if (brightnessBlanche > valeurLedMaxBlanche) {
        brightnessBlanche = (valeurLedMaxBlanche + valeurLedMinBlanche) / 2;

      } else {
        brightnessBlanche = brightnessBlanche + fadeAmount;

      }
      delay(temps);

    }
    if (bichette % 2 == 1) {
      if (brightnessBlanche < valeurLedMinBlanche) {
        brightnessBlanche = (valeurLedMaxBlanche + valeurLedMinBlanche) / 2;

      } else {
        brightnessBlanche = brightnessBlanche - fadeAmount;

      }
      delay(temps);

      }
     }
      //#11 ********2er pause, Attente de quelques instants avant de continué le programme*******
     {
          //on étin les leds
           analogWrite(ledRouge, 0);
           analogWrite(ledVerte, 0);
           analogWrite(ledBleu, 0);
           analogWrite(LedBlanche, 0);
           delay (10);

            //on passe en mode sleep
            for (int count = 1; count < 20; count++) { // compte de 0 à 114( 113X) la valeur du setup_watchdod()
                                               //ex si setup_watchdog(9) "9 = 8s" 9 x 8s = 72s 
                                               // 15 min = 900s <=> 900/8s = 112.5s ~=113s
            if (f_wdt==1) // wait for timed out watchdog
            system_sleep();
             }
            if (f_wdt==1) // wait for timed out watchdog
  
            f_wdt=0;   
            // do some stuff
            Serial.println ("awake6");
            delay (10);
            system_sleep(); // when we wake up, we’ll return to the top of the loop

      //12 *******Démarage du programe pour un sertin temps avant de fair une pose*****
for (int count = 0; count < 2250; count++) { //Temps total du programme allumé 40 mseconde (15000 tours = 10 min)


 bichette = math_random_int(1, 10);
    analogWrite(ledRouge, brightnessRouge);
    if (bichette % 2 == 0) {
      if (brightnessRouge > valeurLedMaxRouge) {
        brightnessRouge = (valeurLedMaxRouge + valeurLedMinRouge) / 2;

      } else {
        brightnessRouge = brightnessRouge + fadeAmount;

      }
      delay(temps);

    }
    if (bichette % 2 == 1) {
      if (brightnessRouge < valeurLedMinRouge) {
        brightnessRouge = (valeurLedMaxRouge + valeurLedMinRouge) / 2;

      } else {
        brightnessRouge = brightnessRouge - fadeAmount;

      }
      delay(temps);

    }
    bichette = math_random_int(1, 10);
    analogWrite(ledVerte, brightnessVerte);
    if (bichette % 2 == 0) {
      if (brightnessVerte > valeurLedMaxVerte) {
        brightnessVerte = (valeurLedMaxVerte + valeurLedMinVerte) / 2;

      } else {
        brightnessVerte = brightnessVerte + fadeAmount;

      }
      delay(temps);

    }
    if (bichette % 2 == 1) {
      if (brightnessVerte < valeurLedMinVerte) {
        brightnessVerte = (valeurLedMaxVerte + valeurLedMinVerte) / 2;

      } else {
        brightnessVerte = brightnessVerte - fadeAmount;

      }
      delay(temps);

    }
    bichette = math_random_int(1, 10);
    analogWrite(ledBleu, brightnessBleu);
    if (bichette % 2 == 0) {
      if (brightnessBleu > valeurLedMaxBleu) {
        brightnessBleu = (valeurLedMaxBleu + valeurLedMinBleu) / 2;

      } else {
        brightnessBleu = brightnessBleu + fadeAmount;

      }
      delay(temps);

    }
    if (bichette % 2 == 1) {
      if (brightnessBleu < valeurLedMinBleu) {
        brightnessBleu = (valeurLedMaxBleu + valeurLedMinBleu) / 2;

      } else {
        brightnessBleu = brightnessBleu - fadeAmount;

      }
      delay(temps);

    }
    bichette = math_random_int(1, 10);
    analogWrite(LedBlanche, brightnessBlanche);
    if (bichette % 2 == 0) {
      if (brightnessBlanche > valeurLedMaxBlanche) {
        brightnessBlanche = (valeurLedMaxBlanche + valeurLedMinBlanche) / 2;

      } else {
        brightnessBlanche = brightnessBlanche + fadeAmount;

      }
      delay(temps);

    }
    if (bichette % 2 == 1) {
      if (brightnessBlanche < valeurLedMinBlanche) {
        brightnessBlanche = (valeurLedMaxBlanche + valeurLedMinBlanche) / 2;

      } else {
        brightnessBlanche = brightnessBlanche - fadeAmount;

      }
      delay(temps);

      }
     }
      //#13********2er pause, Attente de quelques instants avant de continué le programme*******
     {
          //on étin les leds
           analogWrite(ledRouge, 0);
           analogWrite(ledVerte, 0);
           analogWrite(ledBleu, 0);
           analogWrite(LedBlanche, 0);
           delay (10);

            //on passe en mode sleep
            for (int count = 1; count < 20; count++) { // compte de 0 à 114( 113X) la valeur du setup_watchdod()
                                               //ex si setup_watchdog(9) "9 = 8s" 9 x 8s = 72s 
                                               // 15 min = 900s <=> 900/8s = 112.5s ~=113s
            if (f_wdt==1) // wait for timed out watchdog
            system_sleep();
             }
            if (f_wdt==1) // wait for timed out watchdog
  
            f_wdt=0;   
            // do some stuff
            Serial.println ("awake7");
            delay (10);
            system_sleep(); // when we wake up, we’ll return to the top of the loop

      //14 *******Démarage du programe pour un sertin temps avant de fair une pose*****
for (int count = 0; count < 2250; count++) { //Temps total du programme allumé 40 mseconde (15000 tours = 10 min)


 bichette = math_random_int(1, 10);
    analogWrite(ledRouge, brightnessRouge);
    if (bichette % 2 == 0) {
      if (brightnessRouge > valeurLedMaxRouge) {
        brightnessRouge = (valeurLedMaxRouge + valeurLedMinRouge) / 2;

      } else {
        brightnessRouge = brightnessRouge + fadeAmount;

      }
      delay(temps);

    }
    if (bichette % 2 == 1) {
      if (brightnessRouge < valeurLedMinRouge) {
        brightnessRouge = (valeurLedMaxRouge + valeurLedMinRouge) / 2;

      } else {
        brightnessRouge = brightnessRouge - fadeAmount;

      }
      delay(temps);

    }
    bichette = math_random_int(1, 10);
    analogWrite(ledVerte, brightnessVerte);
    if (bichette % 2 == 0) {
      if (brightnessVerte > valeurLedMaxVerte) {
        brightnessVerte = (valeurLedMaxVerte + valeurLedMinVerte) / 2;

      } else {
        brightnessVerte = brightnessVerte + fadeAmount;

      }
      delay(temps);

    }
    if (bichette % 2 == 1) {
      if (brightnessVerte < valeurLedMinVerte) {
        brightnessVerte = (valeurLedMaxVerte + valeurLedMinVerte) / 2;

      } else {
        brightnessVerte = brightnessVerte - fadeAmount;

      }
      delay(temps);

    }
    bichette = math_random_int(1, 10);
    analogWrite(ledBleu, brightnessBleu);
    if (bichette % 2 == 0) {
      if (brightnessBleu > valeurLedMaxBleu) {
        brightnessBleu = (valeurLedMaxBleu + valeurLedMinBleu) / 2;

      } else {
        brightnessBleu = brightnessBleu + fadeAmount;

      }
      delay(temps);

    }
    if (bichette % 2 == 1) {
      if (brightnessBleu < valeurLedMinBleu) {
        brightnessBleu = (valeurLedMaxBleu + valeurLedMinBleu) / 2;

      } else {
        brightnessBleu = brightnessBleu - fadeAmount;

      }
      delay(temps);

    //}
    //bichette = math_random_int(1, 10);
    //analogWrite(LedBlanche, brightnessBlanche);
    //if (bichette % 2 == 0) {
     // if (brightnessBlanche > valeurLedMaxBlanche) {
       // brightnessBlanche = (valeurLedMaxBlanche + valeurLedMinBlanche) / 2;

      //} else {
        //brightnessBlanche = brightnessBlanche + fadeAmount;

      //}
      delay(temps);

    }
    if (bichette % 2 == 1) {
      if (brightnessBlanche < valeurLedMinBlanche) {
        brightnessBlanche = (valeurLedMaxBlanche + valeurLedMinBlanche) / 2;

      } else {
        brightnessBlanche = brightnessBlanche - fadeAmount;

      }
      delay(temps);

      }
     }
      //#15 ********2er pause, Attente de quelques instants avant de continué le programme*******
     {
          //on étin les leds
           analogWrite(ledRouge, 0);
           analogWrite(ledVerte, 0);
           analogWrite(ledBleu, 0);
           analogWrite(LedBlanche, 0);
           delay (10);

            //on passe en mode sleep
            for (unsigned long count = 1; count < 100; count++) { // compte de 0 à 114( 113X) la valeur du setup_watchdod()
                                               //ex si setup_watchdog(9) "9 = 8s" 9 x 8s = 72s 
                                               // 15 min = 900s <=> 900/8s = 112.5s ~=113s
            if (f_wdt==1) // wait for timed out watchdog
            system_sleep();
             }
            if (f_wdt==1) // wait for timed out watchdog
  
            f_wdt=0;   
            // do some stuff
            Serial.println ("awake8");
            delay (10);
            system_sleep(); // when we wake up, we’ll return to the top of the loop

      
      }
      }
      }
      }
      }
    }
}
}

Code en temps réél :

Code : Tout sélectionner

//variable du programe led du tableau + capteur photorsistance
int ledRouge;

int ledVerte;

int luminositeValeur;

int ledBleu;

int LedBlanche;

int luminositeOff;

int luminositeOn;

int bichette;

int brightnessRouge;

int brightnessVerte;

int brightnessBleu;

int brightnessBlanche;

int fadeAmount;

int valeurLedMaxRouge;

int temps;

int valeurLedMinRouge;

int valeurLedMinVerte;

int valeurLedMaxVerte;

int valeurLedMinBleu;

int valeurLedMaxBleu;

int valeurLedMinBlanche;

int valeurLedMaxBlanche;

int drapeau; //marqueur pour executer qu'un foie le programe par nuit

long math_random_int(int a,int b) {
  if (a > b) {
    // Swap a and b to ensure a is smaller.
    int c = a;
    a = b;
    b = c;
  }
  return random(a,b);
}

//vatriable du sleep mode WDT
#include <avr/power.h>
#include <avr/sleep.h>
#include <avr/wdt.h>
 
#ifndef cbi
#  define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit))
#endif
#ifndef sbi
#  define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit))
#endif
 
volatile boolean f_wdt=1;
 
// Watchdog Interrupt Service / is executed when watchdog timed out
ISR(WDT_vect) {
  f_wdt=1;  // set global flag
}
 
//****************************************************************
// 0=16ms, 1=32ms,2=64ms,3=128ms,4=250ms,5=500ms
// 6=1 sec,7=2 sec, 8=4 sec, 9=8 sec


void setup_watchdog(int ii) {
  byte bb;
  int ww;
  if (ii > 9 ) ii=9;
  bb=ii & 7;
  if (ii > 7) bb|= (1<<5);
  bb|= (1<<WDCE);
  ww=bb;
  MCUSR &= ~(1<<WDRF);
  // start timed sequence
  WDTCSR |= (1<<WDCE) | (1<<WDE);
  // set new watchdog timeout value
  WDTCSR = bb;
  WDTCSR |= _BV(WDIE);
}
 
//****************************************************************  
// set system into the sleep state
// system wakes up when wtchdog is timed out
void system_sleep() {
  cbi(ADCSRA,ADEN);  // switch Analog to Digitalconverter OFF
  set_sleep_mode(SLEEP_MODE_PWR_DOWN); // sleep mode is set here
  sleep_enable();
  sleep_mode();                        // System sleeps here
  sleep_disable();              // System continues execution here when watchdog timed out
  sbi(ADCSRA,ADEN);                    // switch Analog to Digitalconverter ON
}
 
void setup() {

//setup du programe led du tableau + capteur photorsistance
  ledRouge = 10;
  ledVerte = 5;
  ledBleu = 6;
  LedBlanche = 9;
  brightnessRouge = 100;
  brightnessVerte = 100;
  brightnessBleu = 100;
  brightnessBlanche = 100;
  fadeAmount = 8;
  temps = 10;
  valeurLedMinRouge = 30;
  valeurLedMaxRouge = 240;
  valeurLedMinVerte = 15;
  valeurLedMaxVerte = 90;
  valeurLedMinBleu = 50;
  valeurLedMaxBleu = 255;
  valeurLedMinBlanche = 100;
  valeurLedMaxBlanche = 120;
  luminositeOff = 460;
  luminositeOn = 480;
  luminositeValeur = 0;
  drapeau = 0;

  pinMode(A2, INPUT);
  Serial.begin(9600);
  pinMode(ledRouge, OUTPUT);
  pinMode(ledVerte, OUTPUT);
  pinMode(ledBleu, OUTPUT);
  pinMode(LedBlanche, OUTPUT);

//setup du sleep mode WDT

  Serial.println ("setup");
  //Optimisation de la consommation
 //power_adc_disable(); // Convertisseur Analog / Digital pour les entres analogiques
power_spi_disable();
 power_twi_disable();
 // Si pas besoin de communiquer par l'usb
 //power_usart0_disable();
 //Extinction des timers, attention timer0 utilis par millis ou delay
//power_timer0_disable(); 
 //power_timer1_disable();
 power_timer2_disable();
// other stuff you want to setup
  cbi( SMCR,SE );      // sleep enable, power down mode
  cbi( SMCR,SM0 );     // power down mode 
  sbi( SMCR,SM1 );     // power down mode
  cbi( SMCR,SM2 );     // power down mode
  setup_watchdog(9);
}



void loop()
{

//#0 **********Teste de luminosit*******
  Serial.println(analogRead(A2),DEC);
  //Serial.println(luminositeValeur,DEC);
  if (analogRead(A2) < luminositeOff) { //initialisation calibration pour viter l'entre deux valeurs au moment precis entre jour et nuit (allumage qui clignote car il ne fait ni nuit ni jour)
    luminositeValeur = 2;                     

  } else if (analogRead(A2) > luminositeOn) {
    luminositeValeur = 0;
  }


//#1 **********Si il fait jour -> extinction de toutes les LEDs**********  
  if (luminositeValeur < 1) { //extinction des alimentation Led
    analogWrite(ledRouge, 0);
    analogWrite(ledVerte, 0);
    analogWrite(ledBleu, 0);
    analogWrite(LedBlanche, 0);
    drapeau = 0;
    delay (10);


    //#1.1 *********Mode veille************
 for (int count = 1; count < 150; count++) { // compte de 0  114( 113X) la valeur du setup_watchdod()
                                               //ex si setup_watchdog(9) "9 = 8s" 9 x 8s = 72s 
                                               // 15 min = 900s <=> 900/8s = 112.5s ~=113s
         if (f_wdt==1) // wait for timed out watchdog
         system_sleep();
  }
    if (f_wdt==1) // wait for timed out watchdog
  
    f_wdt=0;   
  // do some stuff
  Serial.println ("awake1");
  delay (10);
  system_sleep(); // when we wake up, well return to the top of the loop


  }


//#2 *********Sinon, il ne fait pas nuit  ***********
else if (drapeau == 0){


//#3 ********1er pause, Attente de quelques instants avant dmarage du programme*******
for (int count = 1; count < 200; count++) { // compte de 0  114( 113X) la valeur du setup_watchdod()
                                               //ex si setup_watchdog(9) "9 = 8s" 9 x 8s = 72s 
                                               // 15 min = 900s <=> 900/8s = 112.5s ~=113s
         if (f_wdt==1) // wait for timed out watchdog
         system_sleep();
  }
    if (f_wdt==1) // wait for timed out watchdog
  
    f_wdt=0;   
  // do some stuff
  Serial.println ("awake2");
  delay (10);
  system_sleep(); // when we wake up, well return to the top of the loop


  

  //#4 *******Dmarage du programe pour un sertin temps avant de fair une pose*****
for (int count = 0; count < 22500; count++) { //Temps total du programme allum 40 mseconde (15000 tours = 10 min)


 bichette = math_random_int(1, 10);
    analogWrite(ledRouge, brightnessRouge);
    if (bichette % 2 == 0) {
      if (brightnessRouge > valeurLedMaxRouge) {
        brightnessRouge = (valeurLedMaxRouge + valeurLedMinRouge) / 2;

      } else {
        brightnessRouge = brightnessRouge + fadeAmount;

      }
      delay(temps);

    }
    if (bichette % 2 == 1) {
      if (brightnessRouge < valeurLedMinRouge) {
        brightnessRouge = (valeurLedMaxRouge + valeurLedMinRouge) / 2;

      } else {
        brightnessRouge = brightnessRouge - fadeAmount;

      }
      delay(temps);

    }
    bichette = math_random_int(1, 10);
    analogWrite(ledVerte, brightnessVerte);
    if (bichette % 2 == 0) {
      if (brightnessVerte > valeurLedMaxVerte) {
        brightnessVerte = (valeurLedMaxVerte + valeurLedMinVerte) / 2;

      } else {
        brightnessVerte = brightnessVerte + fadeAmount;

      }
      delay(temps);

    }
    if (bichette % 2 == 1) {
      if (brightnessVerte < valeurLedMinVerte) {
        brightnessVerte = (valeurLedMaxVerte + valeurLedMinVerte) / 2;

      } else {
        brightnessVerte = brightnessVerte - fadeAmount;

      }
      delay(temps);

    }
    bichette = math_random_int(1, 10);
    analogWrite(ledBleu, brightnessBleu);
    if (bichette % 2 == 0) {
      if (brightnessBleu > valeurLedMaxBleu) {
        brightnessBleu = (valeurLedMaxBleu + valeurLedMinBleu) / 2;

      } else {
        brightnessBleu = brightnessBleu + fadeAmount;

      }
      delay(temps);

    }
    if (bichette % 2 == 1) {
      if (brightnessBleu < valeurLedMinBleu) {
        brightnessBleu = (valeurLedMaxBleu + valeurLedMinBleu) / 2;

      } else {
        brightnessBleu = brightnessBleu - fadeAmount;

      }
      delay(temps);

    }
    bichette = math_random_int(1, 10);
    analogWrite(LedBlanche, brightnessBlanche);
    if (bichette % 2 == 0) {
      if (brightnessBlanche > valeurLedMaxBlanche) {
        brightnessBlanche = (valeurLedMaxBlanche + valeurLedMinBlanche) / 2;

      } else {
        brightnessBlanche = brightnessBlanche + fadeAmount;

      }
      delay(temps);

    }
    if (bichette % 2 == 1) {
      if (brightnessBlanche < valeurLedMinBlanche) {
        brightnessBlanche = (valeurLedMaxBlanche + valeurLedMinBlanche) / 2;

      } else {
        brightnessBlanche = brightnessBlanche - fadeAmount;

      }
      delay(temps);

      }
     }
      //#5 ********2er pause, Attente de quelques instants avant de continu le programme*******
     {
          //on tin les leds
           analogWrite(ledRouge, 0);
           analogWrite(ledVerte, 0);
           analogWrite(ledBleu, 0);
           analogWrite(LedBlanche, 0);
           delay (10);

            //on passe en mode sleep
            for (int count = 1; count < 400; count++) { // compte de 0  114( 113X) la valeur du setup_watchdod()
                                               //ex si setup_watchdog(9) "9 = 8s" 9 x 8s = 72s 
                                               // 15 min = 900s <=> 900/8s = 112.5s ~=113s
            if (f_wdt==1) // wait for timed out watchdog
            system_sleep();
             }
            if (f_wdt==1) // wait for timed out watchdog
  
            f_wdt=0;   
            // do some stuff
            Serial.println ("awake3");
            delay (10);
            system_sleep(); // when we wake up, well return to the top of the loop

//6 *******Dmarage du programe pour un sertin temps avant de fair une pose*****
for (int count = 0; count < 22500; count++) { //Temps total du programme allum 40 mseconde (15000 tours = 10 min)


 bichette = math_random_int(1, 10);
    analogWrite(ledRouge, brightnessRouge);
    if (bichette % 2 == 0) {
      if (brightnessRouge > valeurLedMaxRouge) {
        brightnessRouge = (valeurLedMaxRouge + valeurLedMinRouge) / 2;

      } else {
        brightnessRouge = brightnessRouge + fadeAmount;

      }
      delay(temps);

    }
    if (bichette % 2 == 1) {
      if (brightnessRouge < valeurLedMinRouge) {
        brightnessRouge = (valeurLedMaxRouge + valeurLedMinRouge) / 2;

      } else {
        brightnessRouge = brightnessRouge - fadeAmount;

      }
      delay(temps);

    }
    bichette = math_random_int(1, 10);
    analogWrite(ledVerte, brightnessVerte);
    if (bichette % 2 == 0) {
      if (brightnessVerte > valeurLedMaxVerte) {
        brightnessVerte = (valeurLedMaxVerte + valeurLedMinVerte) / 2;

      } else {
        brightnessVerte = brightnessVerte + fadeAmount;

      }
      delay(temps);

    }
    if (bichette % 2 == 1) {
      if (brightnessVerte < valeurLedMinVerte) {
        brightnessVerte = (valeurLedMaxVerte + valeurLedMinVerte) / 2;

      } else {
        brightnessVerte = brightnessVerte - fadeAmount;

      }
      delay(temps);

    }
    bichette = math_random_int(1, 10);
    analogWrite(ledBleu, brightnessBleu);
    if (bichette % 2 == 0) {
      if (brightnessBleu > valeurLedMaxBleu) {
        brightnessBleu = (valeurLedMaxBleu + valeurLedMinBleu) / 2;

      } else {
        brightnessBleu = brightnessBleu + fadeAmount;

      }
      delay(temps);

    }
    if (bichette % 2 == 1) {
      if (brightnessBleu < valeurLedMinBleu) {
        brightnessBleu = (valeurLedMaxBleu + valeurLedMinBleu) / 2;

      } else {
        brightnessBleu = brightnessBleu - fadeAmount;

      }
      delay(temps);

    }
    bichette = math_random_int(1, 10);
    analogWrite(LedBlanche, brightnessBlanche);
    if (bichette % 2 == 0) {
      if (brightnessBlanche > valeurLedMaxBlanche) {
        brightnessBlanche = (valeurLedMaxBlanche + valeurLedMinBlanche) / 2;

      } else {
        brightnessBlanche = brightnessBlanche + fadeAmount;

      }
      delay(temps);

    }
    if (bichette % 2 == 1) {
      if (brightnessBlanche < valeurLedMinBlanche) {
        brightnessBlanche = (valeurLedMaxBlanche + valeurLedMinBlanche) / 2;

      } else {
        brightnessBlanche = brightnessBlanche - fadeAmount;

      }
      delay(temps);

      }
     }
      //#7 ********2er pause, Attente de quelques instants avant de continu le programme*******
     {
          //on tin les leds
           analogWrite(ledRouge, 0);
           analogWrite(ledVerte, 0);
           analogWrite(ledBleu, 0);
           analogWrite(LedBlanche, 0);
           delay (10);

            //on passe en mode sleep
            for (int count = 1; count < 400; count++) { // compte de 0  114( 113X) la valeur du setup_watchdod()
                                               //ex si setup_watchdog(9) "9 = 8s" 9 x 8s = 72s 
                                               // 15 min = 900s <=> 900/8s = 112.5s ~=113s
            if (f_wdt==1) // wait for timed out watchdog
            system_sleep();
             }
            if (f_wdt==1) // wait for timed out watchdog
  
            f_wdt=0;   
            // do some stuff
            Serial.println ("awake4");
            delay (10);
            system_sleep(); // when we wake up, well return to the top of the loop

                  //8 *******Dmarage du programe pour un sertin temps avant de fair une pose*****
for (int count = 0; count < 22500; count++) { //Temps total du programme allum 40 mseconde (15000 tours = 10 min)


 bichette = math_random_int(1, 10);
    analogWrite(ledRouge, brightnessRouge);
    if (bichette % 2 == 0) {
      if (brightnessRouge > valeurLedMaxRouge) {
        brightnessRouge = (valeurLedMaxRouge + valeurLedMinRouge) / 2;

      } else {
        brightnessRouge = brightnessRouge + fadeAmount;

      }
      delay(temps);

    }
    if (bichette % 2 == 1) {
      if (brightnessRouge < valeurLedMinRouge) {
        brightnessRouge = (valeurLedMaxRouge + valeurLedMinRouge) / 2;

      } else {
        brightnessRouge = brightnessRouge - fadeAmount;

      }
      delay(temps);

    }
    bichette = math_random_int(1, 10);
    analogWrite(ledVerte, brightnessVerte);
    if (bichette % 2 == 0) {
      if (brightnessVerte > valeurLedMaxVerte) {
        brightnessVerte = (valeurLedMaxVerte + valeurLedMinVerte) / 2;

      } else {
        brightnessVerte = brightnessVerte + fadeAmount;

      }
      delay(temps);

    }
    if (bichette % 2 == 1) {
      if (brightnessVerte < valeurLedMinVerte) {
        brightnessVerte = (valeurLedMaxVerte + valeurLedMinVerte) / 2;

      } else {
        brightnessVerte = brightnessVerte - fadeAmount;

      }
      delay(temps);

    }
    bichette = math_random_int(1, 10);
    analogWrite(ledBleu, brightnessBleu);
    if (bichette % 2 == 0) {
      if (brightnessBleu > valeurLedMaxBleu) {
        brightnessBleu = (valeurLedMaxBleu + valeurLedMinBleu) / 2;

      } else {
        brightnessBleu = brightnessBleu + fadeAmount;

      }
      delay(temps);

    }
    if (bichette % 2 == 1) {
      if (brightnessBleu < valeurLedMinBleu) {
        brightnessBleu = (valeurLedMaxBleu + valeurLedMinBleu) / 2;

      } else {
        brightnessBleu = brightnessBleu - fadeAmount;

      }
      delay(temps);

    }
    bichette = math_random_int(1, 10);
    analogWrite(LedBlanche, brightnessBlanche);
    if (bichette % 2 == 0) {
      if (brightnessBlanche > valeurLedMaxBlanche) {
        brightnessBlanche = (valeurLedMaxBlanche + valeurLedMinBlanche) / 2;

      } else {
        brightnessBlanche = brightnessBlanche + fadeAmount;

      }
      delay(temps);

    }
    if (bichette % 2 == 1) {
      if (brightnessBlanche < valeurLedMinBlanche) {
        brightnessBlanche = (valeurLedMaxBlanche + valeurLedMinBlanche) / 2;

      } else {
        brightnessBlanche = brightnessBlanche - fadeAmount;

      }
      delay(temps);

      }
     }
      //#9 ********2er pause, Attente de quelques instants avant de continu le programme*******
     {
          //on tin les leds
           analogWrite(ledRouge, 0);
           analogWrite(ledVerte, 0);
           analogWrite(ledBleu, 0);
           analogWrite(LedBlanche, 0);
           delay (10);

            //on passe en mode sleep
            for (int count = 1; count < 400; count++) { // compte de 0  114( 113X) la valeur du setup_watchdod()
                                               //ex si setup_watchdog(9) "9 = 8s" 9 x 8s = 72s 
                                               // 15 min = 900s <=> 900/8s = 112.5s ~=113s
            if (f_wdt==1) // wait for timed out watchdog
            system_sleep();
             }
            if (f_wdt==1) // wait for timed out watchdog
  
            f_wdt=0;   
            // do some stuff
            Serial.println ("awake5");
            delay (10);
            system_sleep(); // when we wake up, well return to the top of the loop

      //10 *******Dmarage du programe pour un sertin temps avant de fair une pose*****
for (int count = 0; count < 22500; count++) { //Temps total du programme allum 40 mseconde (15000 tours = 10 min)


 bichette = math_random_int(1, 10);
    analogWrite(ledRouge, brightnessRouge);
    if (bichette % 2 == 0) {
      if (brightnessRouge > valeurLedMaxRouge) {
        brightnessRouge = (valeurLedMaxRouge + valeurLedMinRouge) / 2;

      } else {
        brightnessRouge = brightnessRouge + fadeAmount;

      }
      delay(temps);

    }
    if (bichette % 2 == 1) {
      if (brightnessRouge < valeurLedMinRouge) {
        brightnessRouge = (valeurLedMaxRouge + valeurLedMinRouge) / 2;

      } else {
        brightnessRouge = brightnessRouge - fadeAmount;

      }
      delay(temps);

    }
    bichette = math_random_int(1, 10);
    analogWrite(ledVerte, brightnessVerte);
    if (bichette % 2 == 0) {
      if (brightnessVerte > valeurLedMaxVerte) {
        brightnessVerte = (valeurLedMaxVerte + valeurLedMinVerte) / 2;

      } else {
        brightnessVerte = brightnessVerte + fadeAmount;

      }
      delay(temps);

    }
    if (bichette % 2 == 1) {
      if (brightnessVerte < valeurLedMinVerte) {
        brightnessVerte = (valeurLedMaxVerte + valeurLedMinVerte) / 2;

      } else {
        brightnessVerte = brightnessVerte - fadeAmount;

      }
      delay(temps);

    }
    bichette = math_random_int(1, 10);
    analogWrite(ledBleu, brightnessBleu);
    if (bichette % 2 == 0) {
      if (brightnessBleu > valeurLedMaxBleu) {
        brightnessBleu = (valeurLedMaxBleu + valeurLedMinBleu) / 2;

      } else {
        brightnessBleu = brightnessBleu + fadeAmount;

      }
      delay(temps);

    }
    if (bichette % 2 == 1) {
      if (brightnessBleu < valeurLedMinBleu) {
        brightnessBleu = (valeurLedMaxBleu + valeurLedMinBleu) / 2;

      } else {
        brightnessBleu = brightnessBleu - fadeAmount;

      }
      delay(temps);

    }
    bichette = math_random_int(1, 10);
    analogWrite(LedBlanche, brightnessBlanche);
    if (bichette % 2 == 0) {
      if (brightnessBlanche > valeurLedMaxBlanche) {
        brightnessBlanche = (valeurLedMaxBlanche + valeurLedMinBlanche) / 2;

      } else {
        brightnessBlanche = brightnessBlanche + fadeAmount;

      }
      delay(temps);

    }
    if (bichette % 2 == 1) {
      if (brightnessBlanche < valeurLedMinBlanche) {
        brightnessBlanche = (valeurLedMaxBlanche + valeurLedMinBlanche) / 2;

      } else {
        brightnessBlanche = brightnessBlanche - fadeAmount;

      }
      delay(temps);

      }
     }
      //#11 ********2er pause, Attente de quelques instants avant de continu le programme*******
     {
          //on tin les leds
           analogWrite(ledRouge, 0);
           analogWrite(ledVerte, 0);
           analogWrite(ledBleu, 0);
           analogWrite(LedBlanche, 0);
           delay (10);

            //on passe en mode sleep
            for (int count = 1; count < 400; count++) { // compte de 0  114( 113X) la valeur du setup_watchdod()
                                               //ex si setup_watchdog(9) "9 = 8s" 9 x 8s = 72s 
                                               // 15 min = 900s <=> 900/8s = 112.5s ~=113s
            if (f_wdt==1) // wait for timed out watchdog
            system_sleep();
             }
            if (f_wdt==1) // wait for timed out watchdog
  
            f_wdt=0;   
            // do some stuff
            Serial.println ("awake6");
            delay (10);
            system_sleep(); // when we wake up, well return to the top of the loop

      //12 *******Dmarage du programe pour un sertin temps avant de fair une pose*****
for (int count = 0; count < 22500; count++) { //Temps total du programme allum 40 mseconde (15000 tours = 10 min)


 bichette = math_random_int(1, 10);
    analogWrite(ledRouge, brightnessRouge);
    if (bichette % 2 == 0) {
      if (brightnessRouge > valeurLedMaxRouge) {
        brightnessRouge = (valeurLedMaxRouge + valeurLedMinRouge) / 2;

      } else {
        brightnessRouge = brightnessRouge + fadeAmount;

      }
      delay(temps);

    }
    if (bichette % 2 == 1) {
      if (brightnessRouge < valeurLedMinRouge) {
        brightnessRouge = (valeurLedMaxRouge + valeurLedMinRouge) / 2;

      } else {
        brightnessRouge = brightnessRouge - fadeAmount;

      }
      delay(temps);

    }
    bichette = math_random_int(1, 10);
    analogWrite(ledVerte, brightnessVerte);
    if (bichette % 2 == 0) {
      if (brightnessVerte > valeurLedMaxVerte) {
        brightnessVerte = (valeurLedMaxVerte + valeurLedMinVerte) / 2;

      } else {
        brightnessVerte = brightnessVerte + fadeAmount;

      }
      delay(temps);

    }
    if (bichette % 2 == 1) {
      if (brightnessVerte < valeurLedMinVerte) {
        brightnessVerte = (valeurLedMaxVerte + valeurLedMinVerte) / 2;

      } else {
        brightnessVerte = brightnessVerte - fadeAmount;

      }
      delay(temps);

    }
    bichette = math_random_int(1, 10);
    analogWrite(ledBleu, brightnessBleu);
    if (bichette % 2 == 0) {
      if (brightnessBleu > valeurLedMaxBleu) {
        brightnessBleu = (valeurLedMaxBleu + valeurLedMinBleu) / 2;

      } else {
        brightnessBleu = brightnessBleu + fadeAmount;

      }
      delay(temps);

    }
    if (bichette % 2 == 1) {
      if (brightnessBleu < valeurLedMinBleu) {
        brightnessBleu = (valeurLedMaxBleu + valeurLedMinBleu) / 2;

      } else {
        brightnessBleu = brightnessBleu - fadeAmount;

      }
      delay(temps);

    }
    bichette = math_random_int(1, 10);
    analogWrite(LedBlanche, brightnessBlanche);
    if (bichette % 2 == 0) {
      if (brightnessBlanche > valeurLedMaxBlanche) {
        brightnessBlanche = (valeurLedMaxBlanche + valeurLedMinBlanche) / 2;

      } else {
        brightnessBlanche = brightnessBlanche + fadeAmount;

      }
      delay(temps);

    }
    if (bichette % 2 == 1) {
      if (brightnessBlanche < valeurLedMinBlanche) {
        brightnessBlanche = (valeurLedMaxBlanche + valeurLedMinBlanche) / 2;

      } else {
        brightnessBlanche = brightnessBlanche - fadeAmount;

      }
      delay(temps);

      }
     }
      //#13********2er pause, Attente de quelques instants avant de continu le programme*******
     {
          //on tin les leds
           analogWrite(ledRouge, 0);
           analogWrite(ledVerte, 0);
           analogWrite(ledBleu, 0);
           analogWrite(LedBlanche, 0);
           delay (10);

            //on passe en mode sleep
            for (int count = 1; count < 400; count++) { // compte de 0  114( 113X) la valeur du setup_watchdod()
                                               //ex si setup_watchdog(9) "9 = 8s" 9 x 8s = 72s 
                                               // 15 min = 900s <=> 900/8s = 112.5s ~=113s
            if (f_wdt==1) // wait for timed out watchdog
            system_sleep();
             }
            if (f_wdt==1) // wait for timed out watchdog
  
            f_wdt=0;   
            // do some stuff
            Serial.println ("awake7");
            delay (10);
            system_sleep(); // when we wake up, well return to the top of the loop

      //14 *******Dmarage du programe pour un sertin temps avant de fair une pose*****
for (int count = 0; count < 22500; count++) { //Temps total du programme allum 40 mseconde (15000 tours = 10 min)


 bichette = math_random_int(1, 10);
    analogWrite(ledRouge, brightnessRouge);
    if (bichette % 2 == 0) {
      if (brightnessRouge > valeurLedMaxRouge) {
        brightnessRouge = (valeurLedMaxRouge + valeurLedMinRouge) / 2;

      } else {
        brightnessRouge = brightnessRouge + fadeAmount;

      }
      delay(temps);

    }
    if (bichette % 2 == 1) {
      if (brightnessRouge < valeurLedMinRouge) {
        brightnessRouge = (valeurLedMaxRouge + valeurLedMinRouge) / 2;

      } else {
        brightnessRouge = brightnessRouge - fadeAmount;

      }
      delay(temps);

    }
    bichette = math_random_int(1, 10);
    analogWrite(ledVerte, brightnessVerte);
    if (bichette % 2 == 0) {
      if (brightnessVerte > valeurLedMaxVerte) {
        brightnessVerte = (valeurLedMaxVerte + valeurLedMinVerte) / 2;

      } else {
        brightnessVerte = brightnessVerte + fadeAmount;

      }
      delay(temps);

    }
    if (bichette % 2 == 1) {
      if (brightnessVerte < valeurLedMinVerte) {
        brightnessVerte = (valeurLedMaxVerte + valeurLedMinVerte) / 2;

      } else {
        brightnessVerte = brightnessVerte - fadeAmount;

      }
      delay(temps);

    }
    bichette = math_random_int(1, 10);
    analogWrite(ledBleu, brightnessBleu);
    if (bichette % 2 == 0) {
      if (brightnessBleu > valeurLedMaxBleu) {
        brightnessBleu = (valeurLedMaxBleu + valeurLedMinBleu) / 2;

      } else {
        brightnessBleu = brightnessBleu + fadeAmount;

      }
      delay(temps);

    }
    if (bichette % 2 == 1) {
      if (brightnessBleu < valeurLedMinBleu) {
        brightnessBleu = (valeurLedMaxBleu + valeurLedMinBleu) / 2;

      } else {
        brightnessBleu = brightnessBleu - fadeAmount;

      }
      delay(temps);

    //}
    //bichette = math_random_int(1, 10);
    //analogWrite(LedBlanche, brightnessBlanche);
    //if (bichette % 2 == 0) {
     // if (brightnessBlanche > valeurLedMaxBlanche) {
       // brightnessBlanche = (valeurLedMaxBlanche + valeurLedMinBlanche) / 2;

      //} else {
        //brightnessBlanche = brightnessBlanche + fadeAmount;

      //}
      delay(temps);

    }
    if (bichette % 2 == 1) {
      if (brightnessBlanche < valeurLedMinBlanche) {
        brightnessBlanche = (valeurLedMaxBlanche + valeurLedMinBlanche) / 2;

      } else {
        brightnessBlanche = brightnessBlanche - fadeAmount;

      }
      delay(temps);

      }
     }
      //#15 ********2er pause, Attente de quelques instants avant de continu le programme*******
     {
          //on tin les leds
           analogWrite(ledRouge, 0);
           analogWrite(ledVerte, 0);
           analogWrite(ledBleu, 0);
           analogWrite(LedBlanche, 0);
           drapeau = 1;
           delay (10);

            //on passe en mode sleep
            for (unsigned long count = 1; count < 150; count++) { // compte de 0  114( 113X) la valeur du setup_watchdod()
                                               //ex si setup_watchdog(9) "9 = 8s" 9 x 8s = 72s 
                                               // 15 min = 900s <=> 900/8s = 112.5s ~=113s
            if (f_wdt==1) // wait for timed out watchdog
            system_sleep();
             }
            if (f_wdt==1) // wait for timed out watchdog
  
            f_wdt=0;   
            // do some stuff
            Serial.println ("awake8");
            delay (10);
            system_sleep(); // when we wake up, well return to the top of the loop

      
      }
      }
      }
      }
      }
     }
    }
   else {
    //on passe en mode sleep
            for (unsigned long count = 1; count < 150; count++) { // compte de 0  114( 113X) la valeur du setup_watchdod()
                                               //ex si setup_watchdog(9) "9 = 8s" 9 x 8s = 72s 
                                               // 15 min = 900s <=> 900/8s = 112.5s ~=113s
            if (f_wdt==1) // wait for timed out watchdog
            system_sleep();
             }
            if (f_wdt==1) // wait for timed out watchdog
  
            f_wdt=0;   
            // do some stuff
            Serial.println ("awake8");
            delay (10);
            system_sleep(); // when we wake up, well return to the top of the loop

   }
}
Mes sources :


Miaouss Image

Avatar de l’utilisateur
ricola
Messages : 453
Inscription : 01 juil. 2018, 23:11

Re: Les Tutos d'Enzo #03 Tableau de maître Lumineux sur batterie

Message par ricola » 18 déc. 2018, 07:14

Image
Le monde se compose en 10 catégories : ceux qui comprennent le binaire et les autres :lol:

Répondre