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/\
.....= ( ' .' ) =
...... ( '')_( '')
...................
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
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
}
}Miaouss
