Eclairage escalier ruban LED couleur progressif

Bonjour,

J’ai en projet l’installation d’un éclairage LED sur un escalier.
On trouve pas mal de publication sur le sujet mais jamais rien de complet (schéma câblage + code).

Je débute et je me retrouve déjà confronté à un problème d’alimentation.
Si j’augmente le nombre de LED, le temps d’allumage entre les LED n’est pas constant et si j’en ajoute encore, ça ne fonctionne plus.

Mon but final:
Un éclairage de 17 marches avec un nombre de LED identique par marche (5, 10, 20, peut importe t’en que ça allume assez).
Un capteur de mouvement en bas et un en haut.
Un capteur de lumière pour désactiver l’éclairage quand il fait jour.

Bref, quelque chose comme ça: kit eclairage escalier led progressif disponible sur materiel-hi-tech.fr - YouTube

Merci de votre aide.

Didier

L'image :

Ton message n'est pas clair, et le code pas facile à lire. Est-ce bien le code que tu utilises ? Si oui, poste le entre balises CODE.

J'ai l'impression que tu n'appelles jamais la fonction setColor, donc tes couleurs restent à 0 et rien ne doit s'allumer.

Pour l'alimentation, il te faut une alim 5V qui délivre un courant suffisant pour tes LEDs. Ce courant est en gros 60mA fois le nombre total de LEDs.

Ensuite, regarde ce lien qui présente les bonnes pratiques en matière d'utlisation (alim, branchement) des Néopixels.

Je débute, désolé si je n’emploie pas les bon termes pour m’exprimer.

Le code fonctionne.
Si je défini le nombre de NUMPIXELS à 10 par exemple ça défile
Si je défini le nombre de NUMPIXELS à 19, ça va défile moins vite
Si je défini le nombre de NUMPIXELS à 68, ça va plus

J’ai réglé l’alim sur 5V 5A.
0,06A * 68 = 4.08A donc je suis bon.

Voici mon code:

#include <Adafruit_NeoPixel.h>
#define PIN 6 // input pin Neopixel is attached to
#define NUMPIXELS 68 // number of neopixels in strip
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);

int delayval = 10; // timing delay in milliseconds
int redColor = 0;
int greenColor = 0;
int blueColor = 0;

void setup() {
// Initialize the NeoPixel library.
pixels.begin();
}
void loop() {
setColor();
for (int i=0; i < NUMPIXELS; i++) {
// pixels.Color takes RGB values, from 0,0,0 up to 255,255,255
pixels.setPixelColor(i, pixels.Color(redColor, greenColor, blueColor));
// This sends the updated pixel color to the hardware.
pixels.show();
// Delay for a period of time (in milliseconds).
delay(delayval);
}
}
// setColor()
// picks random values to set for RGB
void setColor(){
redColor = random(0, 255);
greenColor = random(0,255);
blueColor = random(0, 255);
}

Il manque les balises CODE, mais c’est déjà mieux.

Le fonction setColor peut se faire comme ça (entre balises :slight_smile: )

setPixelColor(uint16_t n, uint8_t r, uint8_t g, uint8_t b);

Ton code deviendrait alors :

#include <Adafruit_NeoPixel.h>
#define PIN 6    // input pin Neopixel is attached to
#define NUMPIXELS      68 // number of neopixels in strip
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);

int delayval = 10; // timing delay in milliseconds
byte redColor = 0;
byte greenColor = 0;
byte blueColor = 0;

void setup() {
  // Initialize the NeoPixel library.
  pixels.begin();
}
void loop() {
  setColor();
  for (int i = 0; i < NUMPIXELS; i++) {
    pixels.setPixelColor(i, redColor, greenColor, blueColor);
    pixels.show();
    delay(delayval);
  }
}
// picks random values to set for RGB
void setColor() {
  redColor = random(256);
  greenColor = random(256);
  blueColor = random(256);
}

Je ne vois rien qui fasse que les LEDs ne s’allument pas. J’ai déjà utilisé des bandeaux de près de 100 LEDs sans aucun problème. Je n’utilisais pas cette bibliothèque mais plutôt FastLED, mais il n’y a pas de raison que ça ne marche pas.

Le problème vient peut-être du fait que tu utilises des int au lieu de bytes pour les couleurs…

Bonjour,

Il n'y a pas de problème dans ton code. Regardes du coté hard.
Vérifies le cablage de tes leds

Assure toi du bon type de Strip led utilisée a tu vraiment un WS2812 !

Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);

NEO_KHZ800 800 KHz bitstream (most NeoPixel products w/WS2812 LEDs)
NEO_KHZ400 400 KHz (classic 'v1' (not v2) FLORA pixels, WS2811 drivers)
NEO_GRB Pixels are wired for GRB bitstream (most NeoPixel products)
NEO_RGB Pixels are wired for RGB bitstream (v1 FLORA pixels, not v2)
NEO_RGBW Pixels are wired for RGBW bitstream (NeoPixel RGBW products)

et sur la strip ya une flech -> que tu doit orienté le signal car de l'autre sence sa fonctionne pas

Merci pour votre retour et votre aide.
Je n'ai pas encore de hardware.
Je n'en suis encore qu'à la simulation sur Tinkercard.
Je devrais recevoir tout le matériels pour moi tester.

Je vous reviens quand j'ai câblé.

A bientôt

Bonjour,

Voila, j’ai reçus le matériel et j’ai pu tester.
Le code fonctionne bel et bien mais ce n’est pas vraiment ce que je cherche.

Ce code est une base pour mon projet mais je n’y comprends pas tout.

Qui peut détailler pas à pas en argumentant les paramètres?

Merci

#include <Adafruit_NeoPixel.h>
#define PIN 2
#define NUMPIXELS 300

Adafruit_NeoPixel strip = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);

 unsigned long timeOut=60000;      // timestamp to remember when the PIR was triggered.
 int downUp = 0;                   // variable to rememer the direction of travel up or down the stairs
 int irPinTop = 5;                 // PIN du PIR en haut
 int irPinBottom =7;               // PIN du PIR en bas
 int irValueTop = LOW;             // Variable to hold the PIR status
 int irValueBottom = LOW;          // Variable to hold the PIR status
 int ledPin = 13;                  // LED 13 de la carte Arduino quand detection d'un PIR
 int colourArray[350];             // An array to hold RGB values
 int change = 1;                   // used in 'breathing' the LED's
 int breathe = 0;                  // used in 'breathing' the LED's


void setup() {
 strip.begin();
 strip.setBrightness(25);              //Luminosite
 strip.show();                         // Initialize all pixels to 'off'
 pinMode(ledPin, OUTPUT);              // initilise the onboard pin 13 LED as an indicator
 pinMode(irPinTop, INPUT_PULLUP);      // for PIR at top of stairs initialise the input pin and use the internal restistor
 pinMode(irPinBottom, INPUT_PULLUP);   // for PIR at bottom of stairs initialise the input pin and use the internal restistor
 delay (2);                            // it takes the sensor 0.2 seconds to scan the area around it before it can

}

void loop() {



   irValueTop = digitalRead(irPinTop);             // Constantly poll the PIR at the top of the stairs
   irValueBottom = digitalRead(irPinBottom);       // Constantly poll the PIR at the bottom of the stairs
   
   if (irValueTop == HIGH && downUp != 2)  {
     timeOut=millis();
     downUp = 1;
     topdown();                                                  // lights up the strip from top down
     delay(100);
     for (int x = 0; x < 100; x++){                              //start loop for twinkling
     int randomled = random(0, 299);                             //choose random led to twinklke
     int delaytimeon = random(20, 50);                           //choose how long to stay on full brightness
     int delaytimeoff = random(5, 50);                           //choose how long before next led sparkle
     strip.setPixelColor(randomled, strip.Color(255,255,255));   //set choosen pixel to full brightness
     strip.show();
     delay(delaytimeon);
     strip.setPixelColor(randomled, strip.Color(125,125,125));   //set the same choosen pixel back to normal brightness
     strip.show();
     delay(delaytimeoff);
     } //repeat cycle
     

   }

   if (irValueBottom == HIGH && downUp != 1)  {
     timeOut=millis();
     downUp = 2;
     bottomup();                                                 // lights up the strip from bottom up
     delay(100);
     for (int x = 0; x < 100; x++){                              //start loop for twinkling
     int randomled = random(0, 299);                             //choose random led to twinklke
     int delaytimeon = random(20, 50);                           //choose how long to stay on full brightness
     int delaytimeoff = random(5, 50);                           //choose how long before next led sparkle
     strip.setPixelColor(randomled, strip.Color(255,255,255));   //set choosen pixel to full brightness
     strip.show();
     delay(delaytimeon);
     strip.setPixelColor(randomled, strip.Color(125,125,125));   //set the same choosen pixel back to normal brightness
     strip.show();
     delay(delaytimeoff);
     } //repeat cycle 
     
   }

   if (timeOut+10000 < millis() && timeOut+15000 < millis()) {     //switch off LED's in the direction of travel.
      if (downUp == 1) {
         colourWipeDown(strip.Color(0, 0, 0), 1);                  // Off
         delay(1000);

           for (int x = 0; x < 100; x++){
           strip.setPixelColor(0, strip.Color(0,0,x));             //put the led 0 on a dim standby state      
           strip.show();
           delay(50);
      }
      }
      
      if (downUp == 2)  {
       colourWipeUp(strip.Color(0, 0, 0), 1);   // Off
       delay(1000);
           for (int x = 0; x < 100; x++){
           strip.setPixelColor(0, strip.Color(0,0,x));             //put the led 0 a on a dim standby state        
           strip.show();
           delay(50);
      }
      }
      
     downUp = 0;
   }
     delay(100);
     
     
}

void topdown() {
   colourWipeDown(strip.Color(125, 125, 125), 25 );                 // Warm White
   
}



void bottomup() {
   colourWipeUp(strip.Color(125, 125, 125), 25);                    // Warm White

 }


                                                                    // Fade light each step strip
void colourWipeDown(uint32_t c, uint16_t wait) {

 for (uint16_t j = 0; j < 300; j++){
 int start = strip.numPixels()/300 *j;    
       for (uint16_t i = start; i < start + 1; i++){
   strip.setPixelColor(i, c);
       }
     strip.show();  
 delay(5);
 }

}


void clearStrip(){
 for (int l=0; l<strip.numPixels(); l++){
   strip.setPixelColor(l, (0,0,0));
 }
      
}
                                                                     // Fade light each step strip
void colourWipeUp(uint32_t c, uint16_t wait) {
  for (uint16_t j = 300; j > 0; j--){
  int start = strip.numPixels()/300 *j;
         for (uint16_t i = start; i > start - 1; i--){
         strip.setPixelColor(i-1, c);
        }
         strip.show();
 delay(5);
 }  

}

Je peux t’aider à comprendre le fonctionnement et les problèmes liés au sketch, mais pas le détailler ligne par ligne car il est un peu long.

D’abord, tu déclares le nombre de LEDS :

#define NUMPIXELS 300

Il faut en profiter pour changer toutes les occurences de ‘300’ dans le sketch par ‘NUMPIXELS’. Tu n’auras ainsi qu’une seule ligne à modifier si tu change le nombre de LEDS.
Par exemple :

void colourWipeUp(uint32_t c, uint16_t wait) {
  for (uint16_t j = 300; j > 0; j--) {
    int start = strip.numPixels() / 300 * j;

Ensuite, les variables :

unsigned long timeOut = 60000;    // timestamp to remember when the PIR was triggered.
int downUp = 0;                   // variable to rememer the direction of travel up or down the stairs
int irPinTop = 5;                 // PIN du PIR en haut
int irPinBottom = 7;              // PIN du PIR en bas
int irValueTop = LOW;             // Variable to hold the PIR status
int irValueBottom = LOW;          // Variable to hold the PIR status
int ledPin = 13;                  // LED 13 de la carte Arduino quand detection d'un PIR
int colourArray[350];             // An array to hold RGB values
int change = 1;                   // used in 'breathing' the LED's
int breathe = 0;                  // used in 'breathing' the LED's

Vérifie une par une qu’elles sont utilisées dans ton code. Ainsi colourArray n’est utilisé nulle part, tu peux l’enlever.

Le setup :

void setup() {
  strip.begin();
  strip.setBrightness(25);              //Luminosite
  strip.show();                         // Initialize all pixels to 'off'
  pinMode(ledPin, OUTPUT);              // initilise the onboard pin 13 LED as an indicator
  pinMode(irPinTop, INPUT_PULLUP);      // for PIR at top of stairs initialise the input pin and use the internal restistor
  pinMode(irPinBottom, INPUT_PULLUP);   // for PIR at bottom of stairs initialise the input pin and use the internal restistor
  delay (2);                            // it takes the sensor 0.2 seconds to scan the area around it before it can
}

Il initialise le strip et les pins. Note que les pins en INPUT_PULLUP renvoient LOW quand elles sont activées.

Les fonctions :

clearStrip : éteint toutes les LEDS.

colourWipeDown : bizarre… Le commentaire ne veut rien dire à mon avis.

// Fade light each step strip
void colourWipeDown(uint32_t c, uint16_t wait) {
  for (uint16_t j = 0; j < 300; j++) {
    int start = strip.numPixels() / 300 * j;
    for (uint16_t i = start; i < start + 1; i++) {
      strip.setPixelColor(i, c);
    }
    strip.show();
    delay(5);
  }
}

L’argument wait n’est pas utilisé, je suppose qu’il devrait être dans le delay :

delay(wait);

Ceci

    for (uint16_t i = start; i < start + 1; i++) {
      strip.setPixelColor(i, c);
    }

me semble équivalent à

strip.setPixelColor(start, c);

Ce code me semble aberrant. S’il a pour objectif d’allumer toutes les LEDS da bas en haut une par une avec un délais, il est plus simple de faire

// Fade light each step strip
void colourWipeDown(uint32_t c, uint16_t wait) {
  for (uint16_t j = 0; j < strip.numPixels(); j++) {
    strip.setPixelColor(j, c);
    strip.show();
    delay(wait);
  }
}

Même chose pour colourWipeUp.

La loop est assez compliquée, elle aussi. Elle commence par lire les capteurs IR.
Ensuite vient :

  if (irValueTop == HIGH && downUp != 2)  {
    timeOut = millis();
    downUp = 1;
    topdown();                                                  // lights up the strip from top down
    delay(100);
    for (int x = 0; x < 100; x++) {                             //start loop for twinkling
      int randomled = random(0, 299);                             //choose random led to twinklke
      int delaytimeon = random(20, 50);                           //choose how long to stay on full brightness
      int delaytimeoff = random(5, 50);                           //choose how long before next led sparkle
      strip.setPixelColor(randomled, strip.Color(255, 255, 255)); //set choosen pixel to full brightness
      strip.show();
      delay(delaytimeon);
      strip.setPixelColor(randomled, strip.Color(125, 125, 125)); //set the same chosen pixel back to normal brightness
      strip.show();
      delay(delaytimeoff);
    } //repeat cycle
  }

downUp est une variable qui vaut 1 ou 2 selon le sens de déplacement. Mais je ne sais pas dire ce qui correspond à quelle valeur.
irValueTop est à HIGH si le capteur ne détecte rien : alors si downUp vaut 1 ou 0, on le met à 1, on appelle colourWipeDown puis il fait clignoter 100 LEDS prises au hasard. Cette ligne suppose un strip de 300 LEDS:

int randomled = random(0, 299);

Il vaut mieux sécuriser avec

int randomled = random(0, NUMPIXELS -1);

Le bloc suivant fait la même chose avec l’autre capteur et l’autre sens.

Le reste est aussi bizarre :

  if (timeOut + 10000 < millis() && timeOut + 15000 < millis()) { //switch off LED's in the direction of travel.
    if (downUp == 1) {
      colourWipeDown(strip.Color(0, 0, 0), 1);                  // Off
      delay(1000);

      for (int x = 0; x < 100; x++) {
        strip.setPixelColor(0, strip.Color(0, 0, x));           //put the led 0 on a dim standby state
        strip.show();
        delay(50);
      }
    }

    if (downUp == 2)  {
      colourWipeUp(strip.Color(0, 0, 0), 1);   // Off
      delay(1000);
      for (int x = 0; x < 100; x++) {
        strip.setPixelColor(0, strip.Color(0, 0, x));           //put the led 0 a on a dim standby state
        strip.show();
        delay(50);
      }
    }
    downUp = 0;
  }

Le test

if (timeOut + 10000 < millis() && timeOut + 15000 < millis())

est équivalent à

if (timeOut + 15000 < millis())

Ensuite, selon le sens il éteint toutes les LEDS, en utilisant colourWipeDown au lieu de la fonction clearStrip qui est censée servir à ça… Puis il dimme la LED 0 pendant 5 secondes !!! Cette partie est bloquante : si un capteur détecte un passage pendant ce temps, il ne sera pas pris en compte.

Enfin downUp est mis à 0.

Voilà, j’ai du mal à comprendre ce code et son objectif. Je code personnellement assez mal, mais là c’est fait avec les pieds… :confused:

→ A mon avis, tu aurais intérêt à bien définir ce que tu veux faire avec ces LEDS et écrire un code propre par toi même. Tu apprendras bien mieux et on t’aidera en cas de problème…

Merci pour ces explications.

Le code n’est pas le mien et celui qui me l’a donné m’avait déjà dit qu’il l’avait fait à partir de plusieurs sources et qu’il y avait certainement des lignes inutiles.

Mon but final est d’arriver à allumer marche par marche (17LEDs par marche) un escalier de 17 marches de bas en haut lorsqu’on monte avec une extinction de bas en haut après un délais et inversement lorsqu’on descend.
Le schéma est fait sur base de 4 LEDs par marche mais il en faut 17 par marche

Les flash aléatoires sont pas mal mais pas indispensable.
Certaines LED qui restent allumées quand rien ne se passe n’est pas indispensable.

Il y a déjà eu des projets d’escaliers lumineux sur le forum français. Cherche les et lis les commentaires. Ça t’aidera à prendre en compte des cas particuliers, comme par exemple que doit-il se passer si on détecte une descente pendant que quelqu’un monte…

Il est toujours important de bien définir son projet avant de se lancer dans la programmation, afin de savoir quelle forme on va donner au programme (programme linéaire, bloquant ou pas, machine d’états, etc).

J’ai déjà parcouru le forum mais je n’ai rien trouvé qui correspond.

Le problème des forum c’est que la plus part des personnes qui y répondent sont des avertis.
C’est bien beau de modifier des lignes de code par d’autre mais pourquoi le faire dans tous les sens au lieu de suivre l’ordre.

Comme j’ai dit lors de l’ouverture du post, je suis un débutant.
Je ne demande pas forcement la solution sur un plateau mais des explications clairs et compréhensibles.

Si on parcours de long en large les forums, partout on voit plein de code, des lignes à rajouter par ici et par là mais jamais rien en une seule pièce.

Donc plutôt que de modifier un code existant, qui peut me dire où je peux trouver une documentation pour apprendre les bases.

Merci

Je pensais plus à lire les messages pour voir les fonctions du système que tu veux construire et les problèmes qui peuvent se poser (comme celui que j'ai indiqué : croisement dans l'escalier, mais aussi deux personnes descendent à quelques secondes d'intervalle).

Si tu veux les bases de programmation et l'application à Arduino, il y a des liens dans les messages épinglés en haut du forum.

alors si on veut parler de problème, en voici déjà un:

Le code que j’ai actuellement allume les LEDs en mode chenillard.
J’aimerai allumer 17 LEDs en une fois puis 17 autres et ainsi de suite 17X avec un delay entre chaque série.

Pour le début je sais qu’il y a ça:

#include <Adafruit_NeoPixel.h>
#define PIN 2                         // PIN connectee au ruban
#define NUMPIXELS 289          // Nombre de LED sur le ruban
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);

Ensuite il y a ça, mais déjà à cette étape ça se complique pour moi.
timeOut=60000, je suppose que c’est un delay sans nouvelle détection.
Je vois pas à quoi servent les int downup, change et breathe.
La PIN 13 de la carte mère ne s’allume pas lorqu’il y a une détection.

  unsigned long timeOut=60000;       // Delais sans nouvelle detection
  int downUp = 0;                            // variable to rememer the direction of travel up or down the stairs
  int irPinTop = 5;                            // PIN du PIR en haut
  int irPinBottom =7;                        // PIN du PIR en bas
  int irValueTop = LOW;                    // Variable to hold the PIR status
  int irValueBottom = LOW;              // Variable to hold the PIR status
  int ledPin = 13;                            // LED 13 de la carte Arduino quand detection d'un PIR
  int change = 1;                            // used in 'breathing' the LED's ??
  int breathe = 0;                           // used in 'breathing' the LED's ??

Suivi de ça:

void setup() {
  strip.begin();
  strip.setBrightness(25);                         // Reglage de la luminosite
  strip.show();                                         // Initialize all pixels to 'off'
  pinMode(ledPin, OUTPUT);                     // initilise the onboard pin 13 LED as an indicator
  pinMode(irPinTop, INPUT_PULLUP);         // for PIR at top of stairs initialise the input pin and use the internal restistor 
  pinMode(irPinBottom, INPUT_PULLUP);   // for PIR at bottom of stairs initialise the input pin and use the internal restistor
  delay (2);                                             // it takes the sensor 0.2 seconds to scan the area around it 
                                                                  before it can

}

Avec ça, y a déjà de quoi faire je pense, on verra pour la suite

Merci

Bon, alors voila un début de code :

#include <Adafruit_NeoPixel.h>
#define PIN 2
#define NUMMARCHES 17  // Nombre de marches
#define NUMLEDSPM 17    // Nombre de LED par marche
#define NUMPIXELS (NUMMARCHES * NUMLEDSPM)
Adafruit_NeoPixel strip = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);

const int irPinTop = 5;   // PIN du PIR en haut
const int irPinBottom = 7; // PIN du PIR en bas
int irValueTop = LOW;    // Variable to hold the PIR status
int irValueBottom = LOW; // Variable to hold the PIR status
const int ledPin = 13;    // LED 13 de la carte Arduino quand detection d'un PIR
byte red = 125;
byte green = 125;
byte blue = 125;

void setup() {
  Serial.begin(115200);
  strip.begin();
  strip.setBrightness(25);              //Luminosite
  strip.show();                         // Initialize all pixels to 'off'
  pinMode(ledPin, OUTPUT);              // initilise the onboard pin 13 LED as an indicator
  pinMode(irPinTop, INPUT_PULLUP);      // for PIR at top of stairs initialise the input pin and use the internal restistor
  pinMode(irPinBottom, INPUT_PULLUP);   // for PIR at bottom of stairs initialise the input pin and use the internal restistor
  delay (2);                            // it takes the sensor 0.2 seconds to scan the area around it before it can
}

void loop() {
  irValueTop = digitalRead(irPinTop);        // Constantly poll the PIR at the top of the stairs
  irValueBottom = digitalRead(irPinBottom);  // Constantly poll the PIR at the bottom of the stairs

  if (!irValueTop)    allumeHautBas (strip.Color(red, green, blue), 100);
  if (!irValueBottom) allumeBasHaut (strip.Color(red, green, blue), 100);
}

void clearStrip() {
  for (int l = 0; l < strip.numPixels(); l++)
    strip.setPixelColor(l, (0, 0, 0));
}

void allumeHautBas(uint32_t color, int wait) {
  clearStrip();
  for (int i = 0; i < NUMMARCHES; i++) {
    for (int j = 0; j < NUMLEDSPM; j++)
      strip.setPixelColor(j + i * NUMLEDSPM, color);
    strip.show();
    delay(wait);
  }
}

void allumeBasHaut(uint32_t color, int wait) {
  clearStrip();
  for (int i = NUMMARCHES - 1; i >= 0; i++) {
    for (int j = 0; j < NUMLEDSPM; j++)
      strip.setPixelColor(j + i * NUMLEDSPM, color);
    strip.show();
    delay(wait);
  }
}

Je n’ai pas testé ni vérifié qu’il compile.

Si ça ne fonctionne pas comme prévu, genre sapin de Noël sans attendre les capteurs, enlève les ‘!’ dans les lignes :

  if (!irValueTop)    allumeHautBas (strip.Color(red, green, blue), 100);
  if (!irValueBottom) allumeBasHaut (strip.Color(red, green, blue), 100);

Tu peux changer les couleurs en jouant avec les variables red, green et blue.

Le code compile sans erreur mais il ne fonctionne pas correctement.

Au début, le ruban s'allume LED par LED jusqu'au bout puis s'éteint sauf quelques LED en bout de ruban et après, plus rien ne bouge.

Il se fait un peu tard pour moi y regardé mais je vais essayer de comprendre pourquoi demain.

Merci

D’où l’intérêt de bien définir ce que tu veux.
Le code allume les LEDS par groupes de 17, avec 0.1s de délai entre chaque groupe. D’où l’impression que ça va très vite.
Si tu veux plus de temporisation, augmente le 100 dans ces lignes :

  if (!irValueTop)    allumeHautBas (strip.Color(red, green, blue), 100);
  if (!irValueBottom) allumeBasHaut (strip.Color(red, green, blue), 100);

Ou bien définis le délai avant :

  int duration = 600;
  if (!irValueTop)    allumeHautBas (strip.Color(red, green, blue), duration);
  if (!irValueBottom) allumeBasHaut (strip.Color(red, green, blue), duration);

Si tu veux que les groupes s’éteignent au fur et à mesure, il faut modifier le code :

void allumeHautBas(uint32_t color, int wait) {
  clearStrip();
  for (int i = 0; i < NUMMARCHES; i++) {
    for (int j = 0; j < NUMLEDSPM; j++)
      strip.setPixelColor(j + i * NUMLEDSPM, color);
    strip.show();
    delay(wait);
    for (int j = 0; j < NUMLEDSPM; j++)
      strip.setPixelColor(j + i * NUMLEDSPM, 0);
  }
}

void allumeBasHaut(uint32_t color, int wait) {
  clearStrip();
  for (int i = NUMMARCHES - 1; i >= 0; i++) {
    for (int j = 0; j < NUMLEDSPM; j++)
      strip.setPixelColor(j + i * NUMLEDSPM, color);
    strip.show();
    delay(wait);
    for (int j = 0; j < NUMLEDSPM; j++)
      strip.setPixelColor(j + i * NUMLEDSPM, 0);
  }
}

Le fait que quelques leds restent allumées est bizarre…

J’ai testé ce matin:

J’ai supprimé ce qui concerne la PIN 13 car ça ne marche pas et ce n’est pas une priorité.
J’ai adapté le temps d’allumage à 700.
J’ai ajouté la ligne de code int duration qui est plus facile à modifier dans le futur.
Les points d’exclamation sont à supprimer pour le bon fonctionnement.
Quand il y a une détection du bas PIN 7, ça ne marche pas.
Dans l’idéal, un allumage progressif par marches serait bien.

Utilisation:
Il devrait y avoir une temporisation après l’allumage des 17 marches pour éteindre dans le même ordre que l’allumage.

Donc je devrais ajouter un delay suivi d’une mise à 0, 0, 0 progressive avant le code d’extinction.
Ajouter un code pour allumer marche par marche en mode DIM UP.
Ajouter un code pour extenction en mode DIM DOWN

J’ai la logique mais pas la pratique pour le code.

J’ai télécharger le cours comme tu me l’as indiqué mais je n’en suis qu’a la page 65 sur 300 LOL

#include <Adafruit_NeoPixel.h>
#define PIN 2
#define NUMMARCHES 17  		// Nombre de marches
#define NUMLEDSPM 17    		// Nombre de LED par marche
#define NUMPIXELS (NUMMARCHES * NUMLEDSPM)
Adafruit_NeoPixel strip = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);

const int irPinTop = 5;   	// PIN du PIR en haut
const int irPinBottom = 7; 	// PIN du PIR en bas
int irValueTop = LOW;    		// Variable to hold the PIR status
int irValueBottom = LOW; 		// Variable to hold the PIR status
byte red = 125;
byte green = 125;
byte blue = 125;

void setup() {
  Serial.begin(115200);
  strip.begin();
  strip.setBrightness(25);              // Réglage de la luminosite
  strip.show();                         // Initialize all pixels to 'off'
  pinMode(irPinTop, INPUT_PULLUP);      // for PIR at top of stairs initialise the input pin and use the internal restistor
  pinMode(irPinBottom, INPUT_PULLUP);   // for PIR at bottom of stairs initialise the input pin and use the internal restistor
  delay (2);                            // it takes the sensor 0.2 seconds to scan the area around it before it can
}

void loop() {
  irValueTop = digitalRead(irPinTop);        // Constantly poll the PIR at the top of the stairs
  irValueBottom = digitalRead(irPinBottom);  // Constantly poll the PIR at the bottom of the stairs

  int duration = 700;				// Temps de progression d'allumage
  
  if (irValueTop)    allumeHautBas (strip.Color(red, green, blue), duration);
  if (irValueBottom) allumeBasHaut (strip.Color(red, green, blue), duration);
}

void clearStrip() {
  for (int l = 0; l < strip.numPixels(); l++)
    strip.setPixelColor(l, (0, 0, 0));
}

void allumeHautBas(uint32_t color, int wait) {
  clearStrip();
  for (int i = 0; i < NUMMARCHES; i++) {
    for (int j = 0; j < NUMLEDSPM; j++)
      strip.setPixelColor(j + i * NUMLEDSPM, color);
    strip.show();
    delay(wait);
  }
}

void allumeBasHaut(uint32_t color, int wait) {
  clearStrip();
  for (int i = NUMMARCHES - 1; i >= 0; i++) {
    for (int j = 0; j < NUMLEDSPM; j++)
      strip.setPixelColor(j + i * NUMLEDSPM, color);
    strip.show();
    delay(wait);
  }
}

Merci

Evidemment, j’ai fait une erreur, c’est i-- :

  for (int i = NUMMARCHES - 1; i >= 0; i--) {

J’ai ajouté une extinction des marches une par une, et un temps d’attente à la fin.

#include <Adafruit_NeoPixel.h>
#define PIN 2
#define NUMMARCHES 17      // Nombre de marches
#define NUMLEDSPM 17        // Nombre de LED par marche
#define NUMPIXELS (NUMMARCHES * NUMLEDSPM)
Adafruit_NeoPixel strip = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);

const int irPinTop = 5;     // PIN du PIR en haut
const int irPinBottom = 7;  // PIN du PIR en bas
int irValueTop = LOW;       // Variable to hold the PIR status
int irValueBottom = LOW;    // Variable to hold the PIR status
byte red = 125;
byte green = 125;
byte blue = 125;

void setup() {
  Serial.begin(115200);
  strip.begin();
  strip.setBrightness(25);              // Réglage de la luminosite
  strip.show();                         // Initialize all pixels to 'off'
  pinMode(irPinTop, INPUT_PULLUP);      // for PIR at top of stairs initialise the input pin and use the internal restistor
  pinMode(irPinBottom, INPUT_PULLUP);   // for PIR at bottom of stairs initialise the input pin and use the internal restistor
  delay (2);                            // it takes the sensor 0.2 seconds to scan the area around it before it can
}

void loop() {
  irValueTop = digitalRead(irPinTop);        // Constantly poll the PIR at the top of the stairs
  irValueBottom = digitalRead(irPinBottom);  // Constantly poll the PIR at the bottom of the stairs

  int durMarche = 700;   // Temps de progression d'allumage entre marche
  int durLed = 70;       // Temps de progression d'allumage dans la marche
  int durFinal = 4000;   // Attente avant d'éteindre les marches

  if (irValueTop)    allumeHautBas (strip.Color(red, green, blue), durMarche, durLEd, durFinal);
  if (irValueBottom) allumeBasHaut (strip.Color(red, green, blue), durMarche, durLEd, durFinal);
}

void clearStrip() {
  for (int l = 0; l < strip.numPixels(); l++)
    strip.setPixelColor(l, (0, 0, 0));
}

void allumeHautBas(uint32_t color, int waitMarche, int waitLeds, int waitFinal) {
  clearStrip();
  for (int i = 0; i < NUMMARCHES; i++) {
    for (int j = 0; j < NUMLEDSPM; j++) {
      strip.setPixelColor(j + i * NUMLEDSPM, color);
      strip.show();
      delay(waitLeds);
    }
    delay(waitMarche);
  }
  delay(waitFinal);
  for (int i = 0; i < NUMMARCHES; i++) {
    for (int j = 0; j < NUMLEDSPM; j++) {
      strip.setPixelColor(j + i * NUMLEDSPM, 0);
      strip.show();
      delay(waitLeds);
    }
    delay(waitMarche);
  }
}

void allumeBasHaut(uint32_t color, int waitMarche, int waitLeds, int waitFinal) {
  clearStrip();
  for (int i = NUMMARCHES - 1; i >= 0; i--) {
    for (int j = 0; j < NUMLEDSPM; j++) {
      strip.setPixelColor(j + i * NUMLEDSPM, color);
      strip.show();
      delay(waitLeds);
    }
    delay(waitMarche);
  }
  delay(waitFinal);
  for (int i = NUMMARCHES - 1; i >= 0; i--) {
    for (int j = 0; j < NUMLEDSPM; j++) {
      strip.setPixelColor(j + i * NUMLEDSPM, 0);
      strip.show();
      delay(waitLeds);
    }
    delay(waitMarche);
  }
}

Le code devient maintenant très bloquant : on a 17 * 70ms pour l’allumage d’une marche, fois 17 marches plus 700 ms d’attente par marche, multiplié par 2 pour l’extinction avec 4 secondes d’attente entre les deux phases : près de 28 secondes de bloquage. Pendant ce blocage, les capteurs ne sont pas interrogés.

Si ça te convient, on peut rester sur cette architecture de code, sinon, il faut passer à un code sous forme de machine d’états. Ce sera plus complexe à coder mais plus propre. Tu peux lire le tuto de J-M-L dans la page des tutos du forum pour avoir une idée.

Le fait qu'il ne soit pas détecté de mouvement pendant une phase montante ou descendante n'est pas un problème.

Il y avait un problème d'écriture dans "durLed" et "durLEd"

La fonction DIM UP et DIM DOWN n'est pas un chenillard par marche mais une progression de % luminosité de l'allumage des 17 LEDs par marche.

Je vais chercher le tuto de J-M-L