Discussion :

[ValentinRou]

Extrait de la librairie pour arduino! ça pourrait être interessant surtout que ça référe au chapitre 7.3.3! Reste plus qu'à trouver comment appliquer ça...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
void PCA9685::getPhaseCycle(int channel, uint16_t pwmAmount, uint16_t *phaseBegin, uint16_t *phaseEnd) {
    // Set delay
    if (channel < 0) {
        // All channels
        *phaseBegin = 0;
    }
    else if (_phaseBalancer == PCA9685_PhaseBalancer_Linear) {
        // Distribute high phase area over entire phase range to balance load.
        *phaseBegin = channel * (4096 / 16);
    }
    else if (_phaseBalancer == PCA9685_PhaseBalancer_Weaved) {
        // Distribute high phase area over entire phase range to balance load.
        *phaseBegin = phaseDistTable[channel];
    }
    else {
        *phaseBegin = 0;
    }
 
    // See datasheet section 7.3.3
    if (pwmAmount == 0) {
        // Full OFF => time_off[12] = 1;
        *phaseEnd = PCA9685_PWM_FULL;
    }
    else if (pwmAmount >= PCA9685_PWM_FULL) {
        // Full ON => time_on[12] = 1; time_off = ignored;
        *phaseBegin |= PCA9685_PWM_FULL;
        *phaseEnd = 0;
    }
    else {
        *phaseEnd = *phaseBegin + pwmAmount;
        if (*phaseEnd >= PCA9685_PWM_FULL)
            *phaseEnd -= PCA9685_PWM_FULL;
    }
}

[Delias]

Bonsoir Valentin

Le dernier extrait de la lib correspond à la doc du PCA9685, notamment les deux commentaires lignes 21 et 25 qui reprennent ce que j’expliquais (pour le OFF complet et pour le ON complet).
Est-ce que PCA9685_PWM_FULL est bien défini à 4096 (1'0000'0000'0000b) et non 4095 (1111'1111'1111b).

Après cela je ne vois pas et je n'ai pas le matos sous la main pour investiguer, désolé.

Delias

[technolog]

Bonjour,
Étant professeur de technologie j'aimerai monter ce projet à bien avec mes élèves.
Pouvez vous me donner le (ou les schéma), les plans et le programme, tous les documents nécessaire pour mener à bien ce projet.
Très intéressant.
Merci à vous et aux autres pour votre aide.

#### ne postez pas votre adresse mail directement. Il y a toujours un risque que quelqu'un l'ajoute a une mailing list à spamer

[ValentinRou]

Bonjour technolog,

J'ai donné la plupart des informations que vous recherchez, par contre je n'ai pas fait de plan de câblage, je l'avais dans ma tête et j'étais feignant à le retranscrire… mais le câblage est plutôt simple, vous aurez certaines infos directement dans le programme.
Est ce que votre projet sera une maquette? ou le but est de faire ce projet à taille réelle? Je pose cette question car si c'est une maquette avec par exemple une led par marche, vous n'aurez pas besoin de tous les éléments tel que les cartes mosfet du fait que la carte d'extension pwm ne pouvait pas gérer une grosse puissance.

[ValentinRou]

Je viens de me rendre compte que je n'avais pas posté le code final et fonctionnel (même si il est à rallonge, j'expliquerais pourquoi)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
/*ALLUMAGE PROGRESSIF ECLAIRAGE D'ESCALIER
  AVEC CARTE D'EXTENSION PWM 16 CANAUX
  Avec capteur ultrason en haut et bas des escaliers
  Principe recherché: détection de présence (avec capteur ultrason) en haut des escalier > allumage progressif du haut vers le bas
  puis délai et extinction progressive du haut vers le bas.
  Même principe à l'inverse avec le second capteur à ultrason.
  Capteur de luminosité pour que le système fonctionne que la nuit.
*/
 
#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>
 
Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver(); //chemin d'accès à la carte pwm
 
#define LEDMIN  0     // impulsion min (entre 0 et 4096)
#define LEDMAX  4096  //impulsion max (entre 0 et 4096)
#define trigPin 12    //Trig premier capteur
#define echoPin 11    //Echo premier capteur
#define trigPin2 13   //Trig2 second capteur
#define echoPin2 10   //Echo2 second capteur
int lumPin;           //variable état du contact du capteur de luminosité
boolean etatLumPin;
// Liste des leds
uint8_t led1 = 0;
uint8_t led2 = 1;
uint8_t led3 = 2;
uint8_t led4 = 3;
uint8_t led5 = 4;
uint8_t led6 = 5;
uint8_t led7 = 6;
uint8_t led8 = 7;
uint8_t led9 = 8;
uint8_t led10 = 9;
uint8_t led11 = 10;
uint8_t led12 = 11;
uint8_t led13 = 12;
uint8_t led14 = 13;
uint8_t led15 = 14;
uint8_t led16 = 15;
// capteur ultrason:
int mindist = 40; //distance en dessous de laquelle nous souhaitons démarrer le cycle d'allumage
long duration, distance; //capteur 1
long duration2, distance2; //capteur 2
 
void setup() {
 
  lumPin = 2;   //pin défini pour l'état du capteur de luminosité
  etatLumPin = 0;
 
  pinMode(lumPin, INPUT_PULLUP);
 
  Serial.begin(9600);
  pinMode(trigPin, OUTPUT);  //On defini Trig comme une sortie
  pinMode(echoPin, INPUT);   //On defini Echo comme une entree
  pinMode(trigPin2, OUTPUT); //On defini Trig2 comme une sortie
  pinMode(echoPin2, INPUT);  //On defini Echo2 comme une entree
 
  pwm.begin(); //demarrage carte pwm
  pwm.setPWMFreq(1000);  //reglage de la frequence
}
 
void loop() {
 
  boolean etatLumPin = digitalRead(lumPin);
  Serial.print("Capteur de luminosite : ");
  Serial.println(etatLumPin);
 
  if (etatLumPin) //condition "nuit" pour utilisation du système
  {
    //premier capteur à*ultrason:
 
    digitalWrite(trigPin, LOW);
    delayMicroseconds(2);
    digitalWrite(trigPin, HIGH);
    delayMicroseconds(10); //Trig envoi pendant 10ms
    digitalWrite(trigPin, LOW);
 
    duration = pulseIn(echoPin, HIGH);
    distance = duration * 340 / (2 * 10000);
    Serial.print("Distance1 : ");
    Serial.println(distance);
 
    // second capteur à ultrason:
 
    digitalWrite(trigPin2, LOW);
    delayMicroseconds(2);
    digitalWrite(trigPin2, HIGH);
    delayMicroseconds(10); //Trig envoi pendant 10ms
    digitalWrite(trigPin2, LOW);
 
    duration2 = pulseIn(echoPin2, HIGH);
    distance2 = duration2 * 340 / (2 * 10000);
    Serial.print("Distance2 : ");
    Serial.println(distance2);
 
 
    //Séquence 1:sens d'allumage de la led 1 à 16
 
    if (distance < mindist) { // si capteur détecte une distance en dessous de 50cm
 
      Serial.print("Séquence d'allumage 1");
 
      for (uint8_t led = 0 ; led < 16; led++) {
        for (uint16_t pulselen = LEDMIN; pulselen < LEDMAX; pulselen += 8) { //chiffre/nombre pair
          pwm.setPWM(led, 0, pulselen);
        }
      }
 
      delay(5000);// délai avant extinction progressive:
 
      for (uint16_t pulselen = LEDMAX; pulselen > LEDMIN; pulselen -= 2) {
        pwm.setPWM(led1, 0, pulselen);
      }
      pwm.setPWM(0, 0, 4096);
      for (uint16_t pulselen = LEDMAX; pulselen > LEDMIN; pulselen -= 2) {
        pwm.setPWM(led2, 0, pulselen);
      }
      pwm.setPWM(1, 0, 4096);
      for (uint16_t pulselen = LEDMAX; pulselen > LEDMIN; pulselen -= 2) {
        pwm.setPWM(led3, 0, pulselen);
      }
      pwm.setPWM(2, 0, 4096);
      for (uint16_t pulselen = LEDMAX; pulselen > LEDMIN; pulselen -= 2) {
        pwm.setPWM(led4, 0, pulselen);
      }
      pwm.setPWM(3, 0, 4096);
      for (uint16_t pulselen = LEDMAX; pulselen > LEDMIN; pulselen -= 2) {
        pwm.setPWM(led5, 0, pulselen);
      }
      pwm.setPWM(4, 0, 4096);
      for (uint16_t pulselen = LEDMAX; pulselen > LEDMIN; pulselen -= 2) {
        pwm.setPWM(led6, 0, pulselen);
      }
      pwm.setPWM(5, 0, 4096);
      for (uint16_t pulselen = LEDMAX; pulselen > LEDMIN; pulselen -= 2) {
        pwm.setPWM(led7, 0, pulselen);
      }
      pwm.setPWM(6, 0, 4096);
      for (uint16_t pulselen = LEDMAX; pulselen > LEDMIN; pulselen -= 2) {
        pwm.setPWM(led8, 0, pulselen);
      }
      pwm.setPWM(7, 0, 4096);
      for (uint16_t pulselen = LEDMAX; pulselen > LEDMIN; pulselen -= 2) {
        pwm.setPWM(led9, 0, pulselen);
      }
      pwm.setPWM(8, 0, 4096);
      for (uint16_t pulselen = LEDMAX; pulselen > LEDMIN; pulselen -= 2) {
        pwm.setPWM(led10, 0, pulselen);
      }
      pwm.setPWM(9, 0, 4096);
      for (uint16_t pulselen = LEDMAX; pulselen > LEDMIN; pulselen -= 2) {
        pwm.setPWM(led11, 0, pulselen);
      }
      pwm.setPWM(10, 0, 4096);
      for (uint16_t pulselen = LEDMAX; pulselen > LEDMIN; pulselen -= 2) {
        pwm.setPWM(led12, 0, pulselen);
      }
      pwm.setPWM(11, 0, 4096);
      for (uint16_t pulselen = LEDMAX; pulselen > LEDMIN; pulselen -= 2) {
        pwm.setPWM(led13, 0, pulselen);
      }
      pwm.setPWM(12, 0, 4096);
      for (uint16_t pulselen = LEDMAX; pulselen > LEDMIN; pulselen -= 2) {
        pwm.setPWM(led14, 0, pulselen);
      }
      pwm.setPWM(13, 0, 4096);
      for (uint16_t pulselen = LEDMAX; pulselen > LEDMIN; pulselen -= 2) {
        pwm.setPWM(led15, 0, pulselen);
      }
      pwm.setPWM(14, 0, 4096);
      for (uint16_t pulselen = LEDMAX; pulselen > LEDMIN; pulselen -= 2) {
        pwm.setPWM(led16, 0, pulselen);
      }
      pwm.setPWM(15, 0, 4096);
    }
 
 
 
    // Séquence 2: sens d'allumage de la led 16 à 1
 
    if (distance2 < mindist) { // si capteur détecte une distance en dessous de 50cm
 
      Serial.print("Séquence d'allumage 2");
 
      for (uint8_t led = 15 + 1 ; led > 0; led--) {
        for (uint16_t pulselen = LEDMIN; pulselen < LEDMAX; pulselen += 10) { //chiffre/nombre pair
          pwm.setPWM(led - 1, 0, pulselen);
        }
      }
 
      delay(5000);// délai avant extinction progressive:
 
 
      for (uint16_t pulselen = LEDMAX; pulselen > LEDMIN; pulselen -= 2) {
        pwm.setPWM(led16, 0, pulselen);
      }
      pwm.setPWM(15, 0, 4096);
      for (uint16_t pulselen = LEDMAX; pulselen > LEDMIN; pulselen -= 2) {
        pwm.setPWM(led15, 0, pulselen);
      }
      pwm.setPWM(14, 0, 4096);
      for (uint16_t pulselen = LEDMAX; pulselen > LEDMIN; pulselen -= 2) {
        pwm.setPWM(led14, 0, pulselen);
      }
      pwm.setPWM(13, 0, 4096);
      for (uint16_t pulselen = LEDMAX; pulselen > LEDMIN; pulselen -= 2) {
        pwm.setPWM(led13, 0, pulselen);
      }
      pwm.setPWM(12, 0, 4096);
      for (uint16_t pulselen = LEDMAX; pulselen > LEDMIN; pulselen -= 2) {
        pwm.setPWM(led12, 0, pulselen);
      }
      pwm.setPWM(11, 0, 4096);
      for (uint16_t pulselen = LEDMAX; pulselen > LEDMIN; pulselen -= 2) {
        pwm.setPWM(led11, 0, pulselen);
      }
      pwm.setPWM(10, 0, 4096);
      for (uint16_t pulselen = LEDMAX; pulselen > LEDMIN; pulselen -= 2) {
        pwm.setPWM(led10, 0, pulselen);
      }
      pwm.setPWM(9, 0, 4096);
      for (uint16_t pulselen = LEDMAX; pulselen > LEDMIN; pulselen -= 2) {
        pwm.setPWM(led9, 0, pulselen);
      }
      pwm.setPWM(8, 0, 4096);
      for (uint16_t pulselen = LEDMAX; pulselen > LEDMIN; pulselen -= 2) {
        pwm.setPWM(led8, 0, pulselen);
      }
      pwm.setPWM(7, 0, 4096);
      for (uint16_t pulselen = LEDMAX; pulselen > LEDMIN; pulselen -= 2) {
        pwm.setPWM(led7, 0, pulselen);
      }
      pwm.setPWM(6, 0, 4096);
      for (uint16_t pulselen = LEDMAX; pulselen > LEDMIN; pulselen -= 2) {
        pwm.setPWM(led6, 0, pulselen);
      }
      pwm.setPWM(5, 0, 4096);
      for (uint16_t pulselen = LEDMAX; pulselen > LEDMIN; pulselen -= 2) {
        pwm.setPWM(led5, 0, pulselen);
      }
      pwm.setPWM(4, 0, 4096);
      for (uint16_t pulselen = LEDMAX; pulselen > LEDMIN; pulselen -= 2) {
        pwm.setPWM(led4, 0, pulselen);
      }
      pwm.setPWM(3, 0, 4096);
      for (uint16_t pulselen = LEDMAX; pulselen > LEDMIN; pulselen -= 2) {
        pwm.setPWM(led3, 0, pulselen);
      }
      pwm.setPWM(2, 0, 4096);
      for (uint16_t pulselen = LEDMAX; pulselen > LEDMIN; pulselen -= 2) {
        pwm.setPWM(led2, 0, pulselen);
      }
      pwm.setPWM(1, 0, 4096);
      for (uint16_t pulselen = LEDMAX; pulselen > LEDMIN; pulselen -= 2) {
        pwm.setPWM(led1, 0, pulselen);
      }
      pwm.setPWM(0, 0, 4096);
    }
  }
}

Vous constaterez le retour à des fonctions répétées et lourdes, je sais qu'elles peuvent êtres simplifiées, mais quand elles sont simplifiées le code ne s'exécute pas très bien: les led ne s'éteignent pas totalement comme si le mode pwm n'arrivait pas à 0. Dès que j'utilise le code ci-dessus le problème disparait!

Voilà 8mois que mon escalier est équipé et ça marche parfaitement!

Un grand merci à tous ceux qui m'ont aidé.

[MathieuMW]

Bonjour ValentinRou,

Peux-tu nous fournir une photo de l’installation stp ?
Je cherche à faire moi-même un éclairage progressif mais je n’ai pas réussi à trouver ET le matériel ET le code sur le net en arduino...pourtant je vois pas mal de gens de faire eux même. Je ne m’y connais pas trop en programmation mais je peux suivre les étapes d’un DIY et ´manipuler’ un arduino.

Les solutions toutes prêtes, uniquement du module de contrôle, coûtent relativement cher (150-200€) mais j’aimerai m’en passer puisque c’est faisable soi-même, faut juste trouver le tuto et c’est tout le souci.
Merci de ton retour.

Salutations
Mathieu

[Ulrick4us]

Salut à tous,

Merci, je suis tellement heureux de trouver exactement ce dont j'ai besoin.
malheureusement je trouve ça un peu tard, j'ai exactement le même projet mais je l'ai abordé différemment.
J'ai 16 marche 8 capteurs,

Une alim 12V 300W 25A
un arduino uno
mon pwm 16 canaux est le même mais sous forme shield : Driver-I2C Servo PCA9685
16 commutateurs 15A 400W MOS FET
mes 8 capteurs sont des PIR : HC-SR505
j'ai presque 20m de LED 5630 5730 étanche DC12V 60 LED s/m
mises dans des quart de rond
+ 100 m de câble
le tout avec un interrupteur connecté sonoff (pour gérer avec google home)


pour l'instant j'en suis a gérer un capteur défaillant et faire mon code, je ne suis pas chez moi du coup je l'ai pas là pour le poster.

Mais j'ai eu le même problème de courant résiduel en fait c'est normal :

@ValentinRou
tu utilise son pulselen comme pas d'allumage/extinction pour gérer ta vitesse jusqu'a ce que pulselen > LEDMIN

ton LEDMIN=0
mais imagine tu a pulselen = 5 ta contition pulselen > LEDMIN est juste donc tu execute pulselen = pulselen - 2
alors tu a pulselen = 3 ta contition pulselen > LEDMIN est juste donc tu execute pulselen = pulselen - 2
alors tu a pulselen = 1 ta contition pulselen > LEDMIN n'est plus respecté ==>ta boucle est finie

mais tous as toujours pulselen = 1 !!!!
le voila ton courant résiduel.

de mon coté j'ai mis un truc du genre si pulselen <= pasdallumage (c'est mon 2 mis en variable) alors pulselen = 0

pour alléger ton code il y a F-leb qui te propose un truc pas mal que tu peux adapter aussi pour l'extinction:

Oups, je me suis fait avoir avec un entier non signé (led) qui tente de prendre une valeur négative en fin de boucle

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 for (uint8_t led = 15+1 ; led > 0; led--) {
      for (uint16_t pulselen = LEDMIN; pulselen < LEDMAX; pulselen +=15) {
      pwm.setPWM(led-1, 0, pulselen);
      }
    }

[Ulrick4us]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>
// called this way, it uses the default address 0x40
Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver();
// you can also call it with a different address you want
//Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver(0x41);
// you can also call it with a different address and I2C interface
//Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver(0x40, Wire);
 
 
 
int luminositemini=50;
int tempo_count = 0;
int lumdelai=300;         //delai d'allumage
int pasdallumage=10;
int intensitemaxi=3095;   //allumage maxi 4095 maxi
int nombredemarches=16;
int delaiavantextinction=8000;
int nombrecapteur=8;
int choixmarche[16]={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15} ;  //pin de chaque marche
int etat_marche[16]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0} ;  //luminosité de chaque marche
int choixcapteur[8]={2,3,4,5,6,7,8,9} ;  //pin de reception info capteurs PIR
int positcapteur[8]={1,3,5,7,9,11,13,15} ;  //position du capteur sur la marche X
int deltamarche;
unsigned long tempsdebuboucle;    
 
 
void setup() {
 Serial.begin(9600);  
 Serial.println("16 channel PWM test!");
 pwm.begin();
  // In theory the internal oscillator is 25MHz but it really isn't
  // that precise. You can 'calibrate' by tweaking this number till
  // you get the frequency you're expecting!
 pwm.setOscillatorFrequency(27000000);  // The int.osc. is closer to 27MHz
 pwm.setPWMFreq(1600);  // This is the maximum PWM frequency
 
  // if you want to really speed stuff up, you can go into 'fast 400khz I2C' mode
  // some i2c devices dont like this so much so if you're sharing the bus, watch
  // out for this!
 Wire.setClock(400000);
 
//for (int compteur=0; compteur<nombredemarches; compteur++){
//pinMode(choixmarche[compteur], OUTPUT);  // initialisation des sorties
//  }
 
for (int compteur=0; compteur<nombrecapteur; compteur++){
pinMode(choixcapteur[compteur], INPUT); 
 Serial.print("intit capt pin "); 
 Serial.println(choixcapteur[compteur]);} // initialisation des entrées
 
  Serial.println("INIT OK");
//------------------initialisation demarrage---------------
        int temppasdallumage=pasdallumage;
        int pasdallumage2=pasdallumage*1;
              for (int compteurmarche=0; compteurmarche<nombredemarches+2; compteurmarche++){   
              if (compteurmarche<nombredemarches){pasdallumage=pasdallumage2;changeetatmarche(compteurmarche,etat_marche[compteurmarche],2000);}
              if (compteurmarche>1){pasdallumage=pasdallumage2;changeetatmarche(compteurmarche-2,etat_marche[compteurmarche-2],luminositemini);}
              }
              pasdallumage=temppasdallumage;
}
 
//void changeetatmarche(int nummarche, int intdebut, int intfin);//????
 
void loop(){ ///////////LOOP/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
reset0:
 
if (digitalRead(choixcapteur[0])==1) {  //première marche detectée
 
  for (int compteur1for=0; compteur1for<=nombrecapteur; compteur1for++){              //detection des marches suivantes
 
Serial.print("compteur1for = ");
Serial.println(compteur1for);
 
 
 
 
//-------allumage de la premiere marche-----   
      if (compteur1for==0){ 
              Serial.println("MARCHE ZERO");
    deltamarche=positcapteur[compteur1for];      //compte le nombre de marche entre les capteurs
      int marcheencours = 0;                   //position du capteur d'avant
        for (int compt2=0; compt2 <= deltamarche; compt2++){          //allume les marches précedentes
changeetatmarche(marcheencours + compt2,etat_marche[marcheencours + compt2],intensitemaxi);
       delay(lumdelai); }
    }
 
 
 
 
tempsdebuboucle = millis(); // init d'un chrono
    while (digitalRead(choixcapteur[compteur1for])==0){                         // Boucle d'attente detection capteur
testdescapteursimplesssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss();
 
      if   (millis()-tempsdebuboucle >delaiavantextinction){                //boucle d'eteinte apres XXXX millisecondes
    for (int compt2=0; compt2 <= nombredemarches; compt2++){
 
     changeetatmarche(compt2 ,etat_marche[compt2],luminositemini);
      }
        if   (millis()-tempsdebuboucle >delaiavantextinction){delay(6000);Serial.println("RESET");goto reset0;}
      }
 
    }  
 
 
 
 
 
     if (compteur1for>0){                                                   //allumer toutes les marches précédentes
      Serial.println("Allumage des marche precedentes");
    deltamarche=positcapteur[compteur1for]-positcapteur[compteur1for-1];      //compte le nombre de marche entre les capteurs
      int marcheencours = positcapteur[compteur1for-1];                   //position du capteur d'avant
        for (int compt2=0; compt2 <= deltamarche-1; compt2++){          //allume les marches précedentes
changeetatmarche(marcheencours+1 + compt2,etat_marche[marcheencours-1 + compt2],intensitemaxi);
        }
    }
 
 
 
//changeetatmarche(positcapteur[compteur1for],etat_marche[positcapteur[compteur1for]],intensitemaxi); // allumage de la marche en cours de son etat à intensitemaxi
 
    if (positcapteur[compteur1for]< nombredemarches){ // allumage des marches suivantes
            Serial.println("Allumage des marche suivantes");
    deltamarche=positcapteur[compteur1for+1]-positcapteur[compteur1for];
    int luminositetemp=intensitemaxi;
     int marcheencours = positcapteur[compteur1for];
      for (int compt2=deltamarche-1; compt2 < deltamarche*2-1; compt2++){
luminositetemp=luminositetemp-intensitemaxi/5*2; //reglage de la baisse d'intensité pour les marches suivantes
        changeetatmarche(marcheencours + compt2,etat_marche[marcheencours + compt2],luminositetemp);
    delay(lumdelai);}
    }
 
 
  } //fin du premier for
} //fin du premier if
 
 }
//////////////////////////////////////////FONCTIONS///////////////////////////////////////////////////////////////////////
 
 
 
 
void changeetatmarche(int nummarche, int intdebut, int intfin){ // Fonction d'allumage
 
if (intdebut<intfin){
for (int intensitemarche=intdebut; intensitemarche<intfin+1; intensitemarche=intensitemarche+pasdallumage){
    pwm.setPWM(choixmarche[nummarche], 0, intensitemarche);  
#ifdef ESP8266
    yield();  // take a breather, required for ESP8266
#endif
}}
 
else{
  for (int intensitemarche=intdebut; intensitemarche>intfin; intensitemarche=intensitemarche-pasdallumage){
 
if (intensitemarche<=pasdallumage){intensitemarche=0;}         //sécurité pour bien eteindre si on est en dessous du pasdallumage
    pwm.setPWM(choixmarche[nummarche], 0, intensitemarche);  
#ifdef ESP8266
    yield();  // take a breather, required for ESP8266
#endif
}}
 
etat_marche[nummarche]=intfin; //inscription de l'état
 
// savoir ou en est le tableau des marches
    Serial.print("M:");
  Serial.print(nummarche);
   Serial.print(" tableau fct etat_marche : ("); //afficher le tableau d'etat
    for (int compteurmarche=0; compteurmarche<nombredemarches-1; compteurmarche++){   
    Serial.print(etat_marche[compteurmarche]);
    Serial.print(", ");   }
   Serial.print(etat_marche[nombredemarches-1]);
   Serial.println(")");
 
}
 
 
void eteindtout(){ // Fonction RAZ
  for (int intensitemarche=0; intensitemarche<16; intensitemarche++){
delay(lumdelai);
    pwm.setPWM(intensitemarche, 0, 0);  
#ifdef ESP8266
    yield();  // take a breather, required for ESP8266
#endif
}
 
}
 
void testdescapteurssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss(){ 
 for (int test=0; test<nombrecapteur; test++) { // test des capteurs
   Serial.print("intput n°");    Serial.print(test);       Serial.print(" | pin n°"); Serial.print(choixcapteur[test]); Serial.print(" | posit° capt "); Serial.print(positcapteur[test]);
 
   Serial.print(" = "); 
  Serial.println(digitalRead(choixcapteur[test]));}  // fin test des capteurs
  Serial.println("------fin test capteurs--------");
}
 
void testdescapteursimplesssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss(){ 
 
   Serial.print(" etat des capteurs : ("); 
 for (int test=0; test<nombrecapteur-1; test++) { // test des capteurs
  Serial.print(digitalRead(choixcapteur[test]));
   Serial.print(", "); 
}  
  Serial.print(digitalRead(choixcapteur[nombrecapteur]));
  Serial.println(")");
}
 
void dis(  char Stringtext[]){ 
Serial.print("---"); 
   Serial.println(Stringtext); 
}
void zensontoumescapteurs(){
  for (int test=0; test<nombrecapteur; test++) { // test des capteurs
   Serial.print("intput n°");    Serial.print(test);       Serial.print(" | pin n°"); Serial.print(choixcapteur[test]); Serial.print(" | posit° capt "); Serial.print(positcapteur[test]);
 
   Serial.print(" = "); 
  Serial.println(digitalRead(choixcapteur[test]));}  // fin test des capteurs
  Serial.println("--------------");
//delay(1500);
}

si vous avez des remarques ou suggestions d'amélioration n'hésitez pas, je suis preneur

[Didier_v]

Bonjour,
On trouve pas mal d'informations à propos d'un éclairage led progressif pour escalier mais rien n'est rassemblé au même endroit.
Qui pourrait faire un récapitulatif avec tout le matériel, le câblage et la programmation ?
Merci de la contribution