[Aide] Electronique sur projet Leds connectées avec un Wemos D1 mini

Plast'X

☢️ ☢️ ☢️ ☢️ ☢️
Bonjour à tous,

Je suis sur un projet depuis quelques temps pour reproduire les Aurora Nanoleaf à base d'impression 3D et Arduino Nano.

Comme vous pouvez le voir ici, cela fonctionne déjà bien :


J'aimerai upgrader mon projet avec une carte de type Arduino en WiFi sur base d'un ESP8266. J'ai choisi la carte Wemos D1 Mini V3.0.

Et comme sur le web on trouve tout, j'ai choisit d'utiliser le code de ce projet : Smart Nanoleaf
Le code est prêt à être utilisé, quelques paramètres à changer mais rien de compliqué.

Le soucis vient une fois que l'on allume le tout. J'ai ce qu'ils appellent des "glitch's" dans mes Leds à certains moments, pas tout le temps. D'après le mec du projet, c'est parce que le voltage en sortie de Data pour les Leds (désolé, je n'ai pas les bon termes) n'est pas assez élevé. J'ai donc suivi son conseil et acheté un Level Shifter qui permet donc d'élever le voltage "bas" à un voltage "haut" (explication ici).

Mais une fois branché comme suit, je n'ai plus rien qui s'allume :
circuit_logic_level_Steckplatine.jpg


Evidement, en directe sortie de la carte vers les Leds cela fonctionne.
J'ai donc relevé les voltages en sortie :
WemosD1_LevelShifter.jpg


Au final, ce Level Shifter ne sert pas à grand chose. Mais pourquoi ai-je des glitch's par moment en directe sortie?

Je me suis dit que j'allais mettre une simple résistance entre la sortie de la carte Wemos et les Leds comme actuellement entre la carte Arduino Nano et les Leds (une de 220 ohm) mais là, plus rien ne s'allume non plus o_O !

Je ne sais pas quoi faire donc.
Avez-vous une idée?


Petites précisions sur le matériel utilisé :
  • Alimentation de 5v 10A
  • Strip Leds Chinoises SMD5050
  • Bibliothèque FastLed pour Arduino
  • Condo de 1000uF branché sur la fiche d'alimentation (35v :rolleyes::oops:)
 

mayflower

Elite
Tu as bien ponté le in pour ton alimentation et le out vers tes leds?

Tu es sur de la puissance de sortie? tu a vérifié avec un voltmètre avant?

La résistance de ne sert a rien chaque led est déjà protéger par une résistance.

NB: c'est pas un level shifter qu'il te faut mais un booster

Supposition:

le level shifter ne donne plus assez de jus pour tes led.
Test 1 sans level shifter au voltmètre prend la mesure a la 1er led et dernière led

Test 2 avec level shifter au voltmètre prend la mesure a la 1er led et dernière led

Test 3 Test le out du level shifter
 
1er
OP
Plast'X

Plast'X

☢️ ☢️ ☢️ ☢️ ☢️
Merci de ta réponse, désolé du temps de la mienne...
Je vais essayer d'être clair :p

Tu as bien ponté le in pour ton alimentation et le out vers tes leds?
J'ai suivi la notice du Level Shifter qui donne l'exemple suivant :


To send a signal from the low-voltage side to the high-voltage side (e.g. from 3.3 V to 5 V), the signal must be input at TXI. It will pass through the converter and come out as a higher voltage on the TXO (transmit output) pin.
Comme je pensais que mon signal de sortie de la carte (pin D4) était trop bas, je l'ai donc branché en entrée TXI et la sortie TX0 au LED.

L'alimentation en 5V doit être la référence du Voltage haut pour moi et l'alimentation 3V celle de la référence du Voltage bas que j'ai donc branché respectivement en HV et LV. La masse elle, elle provient de l'alimentation 5V pour les deux.


Tu es sur de la puissance de sortie? tu a vérifié avec un voltmètre avant?
Je vérifié avec un voltmètre oui, mais, pas sûr de savoir le faire correctement pour mesurer la tension en V d'une sortie de "donnée"p pour les Leds (pin D4).
Car là, je vérifie à nouveau et j'ai des données différentes que celles que j'ai noté dans l'image.

En sortie de la carte (Pin D4) vers le Level shifter : 4,30V
En entrée du Level Shifter : Idem évidement.

En sortie du level shifter vers les Leds : 4,25V

Et juste après la première Led : 3,89V
Et après la dernière Led : 4,05V

Tout ceci est donc avec le Level Shifter.

Sans le level Shifter :
A noter que là, les Leds sont allumées car sans le Level Shifter, elles fonctionnent.

En sortie de la carte (Pin D4) vers le Level shifter : 4,30V

Juste après la première Led : 3,60V
Et après la dernière Led : 3,85V


La résistance de ne sert a rien chaque led est déjà protéger par une résistance.
Sans vouloir remettre tout en question mais, partout où il y a des tutos ils en mettent, regarde ici par exemple :


A 3:20 sur le schéma

Y'en a qui disent (sans savoir, j'y connais rien) que si pas de résistance, cela crame les led o_O


J'espère avoir été clair :rolleyes::oops:
 

[Clad]

Manipulateur de bits
C'est quoi tes leds ? Si tu as un lien pour que je regarde...
 
1er
OP
Plast'X

Plast'X

☢️ ☢️ ☢️ ☢️ ☢️
Oui, certaines des animations demande de souvent de changer de couleur, comme l'animation du feu par exemple. Je vais essayer de filmer quand ça arrive ce soir :)

amha pas besoin de shifters ni de resistance.
Ha, ok :/
Pq dans la vidéo de Adafruit ils en mettent une (de résistance)? Cela dépend des Led?
 

[Clad]

Manipulateur de bits
j'étais sur smartphone, du coup j'ai pas bien vu, mais ok ton µC fonctionne en 3,3V et tes leds en 5V. Du coup effectivement il vaut mieux augmenter la tension surtout si tu envois à une fréquence assez élevées les infos (sur la pin D des Leds)

Reste à voir si c'est bien branché et si le code a bien été modifié.

je regrde plus tard la suite.
 

[Clad]

Manipulateur de bits
En sortie de la carte (Pin D4) vers le Level shifter : 4,30V

Ca je ne comprends pas enfaite.

Pour mesurer la tension tu as fait comment ?


Et tant qu'à faire si tu peux me montrer les 2 codes en sketch (arduino) ca pourrait peut être nous éclaircir
 

mayflower

Elite
Perso je me suis posé la question, en prenant le shifter que pour la partie alimentation et il envoi les data directement de sa carte WiFi au led sans passer par le tx0?

La tension du d4 est constante ce n'est pas lui qui pose problème, mais son alimentation.
 

[Clad]

Manipulateur de bits
Perso je me suis posé la question, en prenant le shifter que pour la partie alimentation et il envoi les data directement de sa carte WiFi au led sans passer par le tx0?

La tension du d4 est constante ce n'est pas lui qui pose problème, mais son alimentation.
Tu parles de quel Tx0 ??

En tous cas la pin D4 est une data avec 0V pour les '0' logiques, et 3,3V pour les '1' logiques.

Ce qui veut dire que s'il mesure au volmètre
  • en Vdc il peut obtenir une valeur

0V si que des '0' transmis​
3,3V si que des '1' transmis​
1,65V si une une moyenne de si 50% de '0' et 50% de '1'​
  • En Vac+dc
0V si que des '0' transmis​
3,3V si que des '1' transmis​
2,608V si une une moyenne de si 50% de '0' et 50% de '1'​
donc pas possible supérieur à 3,3V ^^

Surement mal pointé la masse lors de la mesure ?

Mais dans tous les cas pas de souci de courant max débité par D4 car les Leds sont alimentées via Vcc et GND et le D4 sert uniquement à transmettre en série l'état des Leds RGB.

Concernant les glitchs, soit des problèmes de montage, soit de vitesse de transmission, soit problème wifi car cela foncitonnait en direct.

Peut être testé sans passer par le wifi en utilisant uniquement la carte ESP8266 ?
 
1er
OP
Plast'X

Plast'X

☢️ ☢️ ☢️ ☢️ ☢️
Pour mesurer la tension tu as fait comment ?
Justement, je ne suis pas sûr de bien prendre les tensions.
Je pointe en alternatif avec la borne positive sur le 5V et négative sur le Data. (J'ai vraiment un petit multimetre d'amateur... )

Et tant qu'à faire si tu peux me montrer les 2 codes en sketch (arduino) ca pourrait peut être nous éclaircir
Les deux codes? Celui de l'arduino Nano et celui du Wemos ?

Peut être testé sans passer par le wifi en utilisant uniquement la carte ESP8266 ?
Tu veux dire, utiliser un code simple qui n'utilise pas la fonction Wi-Fi de la carte?
 

[Clad]

Manipulateur de bits
Justement, je ne suis pas sûr de bien prendre les tensions.
Je pointe en alternatif avec la borne positive sur le 5V et négative sur le Data. (J'ai vraiment un petit multimetre d'amateur... )



Les deux codes? Celui de l'arduino Nano et celui du Wemos ?



Tu veux dire, utiliser un code simple qui n'utilise pas la fonction Wi-Fi de la carte?
Pour mesurer il faut mettre la borne + sur Data et la borne - sur un Gnd

Mais ca ne servira pas à grand chose vu que la sortie fluctue en fonction des données transmises.


Ce que je te propose :

1- est ce que le ruban Led fonctionne avec le code sur l'arduino ?
+ Si oui, alors le ruban Led n'a pas de problème.
+ Si oui, quel est la référence de ton arduino ? (afin de savoir si c'est des data en 5V ou en 3,3V).

- Si non, ben le ruban Led déconne


2- est ce que le ruban Led fonctionne en solo sur la carte ESP8266 sans utiliser de wifi.

+ Si oui alors la carte OK
- Si non, le problème vient de là


Si oui à 2 et lorsque tu utilises le wifi, alors le problème devrait venir de là.
Si non à 2, alors le problème vient du code, ou de la carte.

Dès que tout foncitonne à ce moment là tu peux rajouter le wifi.
 

[Clad]

Manipulateur de bits
Les deux codes? Celui de l'arduino Nano et celui du Wemos ?

Tu veux dire, utiliser un code simple qui n'utilise pas la fonction Wi-Fi de la carte?
oui et oui, car si j'ai compris


tu avais un code arduino que tu as c/c sur Wemos avec tes propores adaptation ?

On ne sait jamais, il se peut que les données soient envoyées à une vitesse différente via une fonction configurée differement sur le Wemos.
 
1er
OP
Plast'X

Plast'X

☢️ ☢️ ☢️ ☢️ ☢️
oui et oui, car si j'ai compris


tu avais un code arduino que tu as c/c sur Wemos avec tes propores adaptation ?

On ne sait jamais, il se peut que les données soient envoyées à une vitesse différente via une fonction configurée differement sur le Wemos.

Ok, avant de faire les tests, je pense qu'il est crucial de d'abord répondre à ces questions :

J'utilise donc une copie de l'Arduino Nano (leur site officiel renvoie directement sur BangGood).
Sur celui ci se trouve un code que j'ai "créé" à la façon de Frankenstein, j'ai prit des bouts de code à gauche et à droite pour que cela fonctionne avec un bouton poussoir dessus.

Ensuite sur le Wemos D1 Mini, le code est celui du gars qui a créé ce projet et j'ai juste copié/collé pour le compiler dans mon Wemos. J'ai juste changé quelques paramètres et inséré mes paramètres WiFi.

Je veux bien te mettre les codes de paramètres et de setup de chaque code mais ils sont assez long o_O
 

[Clad]

Manipulateur de bits
Ok, avant de faire les tests, je pense qu'il est crucial de d'abord répondre à ces questions :

J'utilise donc une copie de l'Arduino Nano (leur site officiel renvoie directement sur BangGood).
Sur celui ci se trouve un code que j'ai "créé" à la façon de Frankenstein, j'ai prit des bouts de code à gauche et à droite pour que cela fonctionne avec un bouton poussoir dessus.

Ensuite sur le Wemos D1 Mini, le code est celui du gars qui a créé ce projet et j'ai juste copié/collé pour le compiler dans mon Wemos. J'ai juste changé quelques paramètres et inséré mes paramètres WiFi.

Je veux bien te mettre les codes de paramètres et de setup de chaque code mais ils sont assez long o_O
Pour le Wemos, je vais sur le lien du mec qui a créé le projet, et en haut à droite je fais 'Download all files'. Mais dans l'archive je ne trouve aucun code source dedans ?

Du coup même si c'est long tu peux me l'envoyer par MP si tu preferes.

Enfin, moi je m'attendais à voir un code sketch style langage C, du coup peut être que je me plante..
 
1er
OP
Plast'X

Plast'X

☢️ ☢️ ☢️ ☢️ ☢️
Pour le Wemos, je vais sur le lien du mec qui a créé le projet, et en haut à droite je fais 'Download all files'. Mais dans l'archive je ne trouve aucun code source dedans ?

Du coup même si c'est long tu peux me l'envoyer par MP si tu preferes.

Enfin, moi je m'attendais à voir un code sketch style langage C, du coup peut être que je me plante..
Normalement oui mais je fais ça ce soir, là au boulot sur mon gsm ça va être compliqué :p
Merci :)
 
1er
OP
Plast'X

Plast'X

☢️ ☢️ ☢️ ☢️ ☢️
[Clad]

Voici le code qui se trouve sur l'Arduino Nano. Comme je l'ai dis, c'est un code que j'ai "construit" avec des bouts de code à gauche à droite. De plus j'ai des notions de bases, genre, je comprends les principes de base mais certaines choses m'échappe donc il se peut que tu y trouves des choses en doublons et/ou inutiles...

Paramètres et variables avant le Setup:
Code:
#include "FastLED.h"
#include <EEPROM.h>
 
#if defined(FASTLED_VERSION) && (FASTLED_VERSION < 3001000)
#warning "Requires FastLED 3.1 or later; check github for latest code."
#endif
 
 
//This is where we adjust things to match our unique project:
#define NUM_TILES 11    // adjust to set your number of leds per tiles
#define NUM_LEDS_TILES 12          // adjust to set your number of tiles
#define NUM_LEDS    (NUM_TILES * NUM_LEDS_TILES)      // adjust this to the number of LEDs you have: 16 or more
#define LED_TYPE    WS2811  // adjust this to the type of LEDS. This is for Neopixels
#define DATA_PIN    6        // adjust this to the pin you've connected your LEDs to 
#define BRIGHTNESS  50        // 255 is full brightness, 127 is half, 32 is an eighth.
//#define SATURATION  255    // 0-255, 0 is pure white, 255 is fully saturated color
#define BUTTON_PIN  2        // Connect the button to GND and one of the pins.
//#define COLOR_ORDER GRB    // Try mixing up the letters (RGB, GBR, BRG, etc) for a whole new world of color combinations
#define NUM_MODES 14          //Update this number to the highest number of "cases"
#define MASTER_DELAY 100      // adjust this to change the speed of changing colors in Gradient Random
 
CRGB leds[NUM_LEDS];
 
byte selectedEffect=0;
 
//___
uint16_t pixelsPerTile, numberOfTiles;
 
 
// ************************************************
//  ** Animation Config for Surrbral08 effects **
// ************************************************
 
// ten seconds per color palette makes a good demo
// 20-120 is better for deployment
uint8_t secondsPerPalette = 60;
 
// COOLING: How much does the air cool as it rises?
// Less cooling = taller flames.  More cooling = shorter flames.
// Default 50, suggested range 20-100
uint8_t cooling = 49;
 
// SPARKING: What chance (out of 255) is there that a new spark will be lit?
// Higher chance = more roaring fire.  Lower chance = more flickery fire.
// Default 120, suggested range 50-200.
uint8_t sparking = 160;
uint8_t speed = 20;
// ************************************************
 
// ************************************************
//    ** Values Config for Surrbral08 effects **
// ************************************************
 
#define ARRAY_SIZE(A) (sizeof(A) / sizeof((A)[0]))
#define MILLI_AMPS        3000  // IMPORTANT: set the max milli-Amps of your power supply (4A = 4000mA)
#define FRAMES_PER_SECOND  120    // here you can control the speed. With the Access Point / Web Server the animations run a bit slower.
 
///////////////////////////////////////////////////////////////////////
 
// Forward declarations of an array of cpt-city gradient palettes, and
// a count of how many there are.  The actual color palette definitions
// are at the bottom of this file.
extern const TProgmemRGBGradientPalettePtr gGradientPalettes[];
 
uint8_t gCurrentPaletteNumber = 0;
 
CRGBPalette16 gCurrentPalette(CRGB::Black);
CRGBPalette16 gTargetPalette(gGradientPalettes[0]);
 
CRGBPalette16 IceColors_p = CRGBPalette16(CRGB::Black, CRGB::Blue, CRGB::Aqua, CRGB::White);
 
uint8_t currentPatternIndex = 0; // Index number of which pattern is current
uint8_t autoplay = 0;
 
uint8_t allLeafs = 1;    // Sets if all leafs should get the same color
uint8_t selectedLeaf = 1;    // Sets position of leaf to color
 
uint8_t autoplayDuration = 10;
unsigned long autoPlayTimeout = 0;
 
uint8_t currentPaletteIndex = 0;
 
uint8_t gHue = 0; // rotating "base color" used by many of the patterns
 
CRGB solidColor = CRGB::Blue;
 
// scale the brightness of all pixels down
void dimAll(byte value)
{
  for (int i = 0; i < NUM_LEDS; i++) {
    leds[i].nscale8(value);
  }
}
 
typedef void(*Pattern)();
typedef Pattern PatternList[];
typedef struct {
  Pattern pattern;
  String name;
} PatternAndName;
typedef PatternAndName PatternAndNameList[];
 
#include "Twinkles.h"
#include "TwinkleFOX.h"
#include "GradientPalettes.h"
 
typedef struct {
  CRGBPalette16 palette;
  String name;
} PaletteAndName;
typedef PaletteAndName PaletteAndNameList[];
 
const CRGBPalette16 palettes[] = {
  RainbowColors_p,
  RainbowStripeColors_p,
  CloudColors_p,
  LavaColors_p,
  OceanColors_p,
  ForestColors_p,
  PartyColors_p,
  HeatColors_p
};
 
const uint8_t paletteCount = ARRAY_SIZE(palettes);
 
const String paletteNames[paletteCount] = {
  "Rainbow",
  "Rainbow Stripe",
  "Cloud",
  "Lava",
  "Ocean",
  "Forest",
  "Party",
  "Heat",
};
 
 
// ************************************************
//    ** End Values for Surrbral08 effects **
// ************************************************
Le Setup :
Code:
void setup() {
  delay( 2000 ); // power-up safety delay
  FastLED.addLeds<LED_TYPE, DATA_PIN, GRB>(leds, NUM_LEDS).setCorrection( TypicalLEDStrip );
  FastLED.setBrightness(BRIGHTNESS);
  digitalWrite (BUTTON_PIN, HIGH);  // internal pull-up resistor
  attachInterrupt (digitalPinToInterrupt (BUTTON_PIN), changeEffect, CHANGE); // pressed
  Serial.begin(9600);
 
  pixelsPerTile = NUM_LEDS_TILES; // Set the default pixel grouping to one full tile at a time
  numberOfTiles = NUM_TILES; // I don't know why I put this here it never changes at runtime...but I suppose it could for some reason...
 
  FastLED.setMaxPowerInVoltsAndMilliamps(5, MILLI_AMPS);
 
}
Le Loop :
Code:
void loop() {
    // Add entropy to random number generator; we use a lot of it.
  random16_add_entropy(random(65535));
 
// ************************************************
//            ** Use for ColoWaves **
// ************************************************
 
// change to a new cpt-city gradient palette
  EVERY_N_SECONDS(secondsPerPalette) {
    gCurrentPaletteNumber = addmod8(gCurrentPaletteNumber, 1, gGradientPaletteCount);
    gTargetPalette = gGradientPalettes[gCurrentPaletteNumber];
  }
 
  EVERY_N_MILLISECONDS(80) {
    // slowly blend the current palette to the next
    nblendPaletteTowardPalette(gCurrentPalette, gTargetPalette, 8);
    gHue++;  // slowly cycle the "base color" through the rainbow
  }
//************************************************
 
  EEPROM.get(0,selectedEffect);
 
  if(selectedEffect>NUM_MODES) {
    selectedEffect=0;
    EEPROM.put(0,0);
  }
 
  switch(selectedEffect) {
 
               
  case 0  : {
              // Juggle - no parameters
              juggle();
              break;
              }
 
  case 1  : {
              // radialPaletteShift - no parameters
              radialPaletteShift();
              break;
            }
 
  case 2  : {
              // pride - no parameters
              pride();
              break;
            }
 
  case 3  : {
              // water - parameters of speed,
              water(40);
              break;
            }
 
  case 4  : {
              // fire - parameters of speed,
              fire(20);
              break;
            }
             
  case 5  : {
              // confettiFullTiles - no parameters - From Phouky
              confettiFullTile();
              break;
            }
           
  case 6  : {
              // ColorWavesWithPalettes by Mark Kriegsman: https://gist.github.com/kriegsman/8281905786e8b2632aeb
              colorwaves(leds, NUM_TILES * 3, gCurrentPalette);
              break;
            }
 
  case 7  : {
              // confetti - no parameters,
              confetti();
              break;
            }           
 
  case 8  : {
              // Cloud Twinkles - no parameters - from Surrbradl08's Smart Nanoleaf Replica (Thingiverse n° 3354082)
              cloudTwinkles();
              break;
            }
 
  case 9  : {
              // Red and Blue Twinkles - no parameters
              redBlueTwinkles();
              break;
              }
 
  case 10 : {
              // Incandescent Twinkles - no parameters - from Surrbradl08's Smart Nanoleaf Replica (Thingiverse n° 3354082)
              incandescentTwinkles();
              break;
            }
 
  case 11 : {
              // SummerTime Twinkles - no parameters,
              SummerTimeTwinkles();
              break;
            } 
 
  case 12 : {
              // Lava Twinkles - no parameters - from Surrbradl08's Smart Nanoleaf Replica (Thingiverse n° 3354082)
              lavaTwinkles();
              break;
              }
 
  case 13 : {
              // Calmy Evening Twinkles - no parameters,
              CalmyEveningTwinkles();
              break;
            }
 
  case 14  : {
              // Ocean Twinkles - no parameters - from Surrbradl08's Smart Nanoleaf Replica (Thingiverse n° 3354082)
              oceanTwinkles();
              break;
              }
/*             
  case 11  : {
              // bpm - no parameters
              bpm();
              break;
            }
 
 
  case 12  : {
              // Sinelon - no parameters
              sinelon();
              break;
              }           
*/
 
  }
 
  FastLED.show();
  // insert a delay to keep the framerate modest
  FastLED.delay(1000 / FRAMES_PER_SECOND);
}

Voici le code qui se trouve sur le Wemos D1 Mini
Ici, le code, c'est du copié/collé depuis son projet.
Il faut juste créer un onglet avec les paramètres de son Wifi et paramétrer ce qui se trouve dans la partie Config :
Code:
//-----------------------------------------CONFIG-----------------------------------------//
#define LEAFCOUNT 11
#define PIXELS_PER_LEAF 12
 
#define DATA_PIN      D4          // The pin where the data line is connected to
#define LED_TYPE      WS2811
#define COLOR_ORDER  GRB        // Color order, if e.g. your Colors are swapped then change the order, (RGB, RBG, GBR, GRB, BRG, BGR)
 
#define MILLI_AMPS        10000  // IMPORTANT: set the max milli-Amps of your power supply (4A = 4000mA)
#define FRAMES_PER_SECOND  120    // here you can control the speed. With the Access Point / Web Server the animations run a bit slower.
const bool apMode = false;        // Set to true if the esp8266 should open an Access-Point
 
 
// Animation Config:
// ten seconds per color palette makes a good demo
// 20-120 is better for deployment
uint8_t secondsPerPalette = 60;
 
// COOLING: How much does the air cool as it rises?
// Less cooling = taller flames.  More cooling = shorter flames.
// Default 50, suggested range 20-100
uint8_t cooling = 49;
 
// SPARKING: What chance (out of 255) is there that a new spark will be lit?
// Higher chance = more roaring fire.  Lower chance = more flickery fire.
// Default 120, suggested range 50-200.
uint8_t sparking = 160;
 
uint8_t speed = 20;
 
//---------------------------------------CONFIG END---------------------------------------//
Voici les variables avant le Setup :
Code:
//#define FASTLED_ALLOW_INTERRUPTS 1
//#define INTERRUPT_THRESHOLD 1
#define FASTLED_INTERRUPT_RETRY_COUNT 0
 
#include <FastLED.h>
FASTLED_USING_NAMESPACE
 
extern "C" {
#include "user_interface.h"
}
 
#include <ESP8266WiFi.h>
//#include <ESP8266mDNS.h>
#include <ESP8266WebServer.h>
#include <ESP8266HTTPUpdateServer.h>
//#include <WebSocketsServer.h>
#include <FS.h>
#include <EEPROM.h>
//#include <IRremoteESP8266.h>
#include "GradientPalettes.h"
 
#define ARRAY_SIZE(A) (sizeof(A) / sizeof((A)[0]))
 
#include "Field.h"
 
//#define RECV_PIN D4
//IRrecv irReceiver(RECV_PIN);
 
//#include "Commands.h"
 
ESP8266WebServer webServer(80);
//WebSocketsServer webSocketsServer = WebSocketsServer(81);
ESP8266HTTPUpdateServer httpUpdateServer;
 
#include "FSBrowser.h"
 
 
#define NUM_LEDS (PIXELS_PER_LEAF * LEAFCOUNT)
 
 
#include "Secrets.h" // this file is intentionally not included in the sketch, so nobody accidentally commits their secret information.
// create a Secrets.h file with the following:
 
// AP mode password
// const char WiFiAPPSK[] = "your-password";
 
// Wi-Fi network to connect to (if not in AP mode)
// char* ssid = "your-ssid";
// char* password = "your-password";
 
 
CRGB leds[NUM_LEDS];
 
const uint8_t brightnessCount = 5;
uint8_t brightnessMap[brightnessCount] = { 16, 32, 64, 128, 255 };
uint8_t brightnessIndex = 0;
 
char vals[4 + LEAFCOUNT * 5][4] = {""};
 
///////////////////////////////////////////////////////////////////////
 
// Forward declarations of an array of cpt-city gradient palettes, and
// a count of how many there are.  The actual color palette definitions
// are at the bottom of this file.
extern const TProgmemRGBGradientPalettePtr gGradientPalettes[];
 
uint8_t gCurrentPaletteNumber = 0;
 
CRGBPalette16 gCurrentPalette(CRGB::Black);
CRGBPalette16 gTargetPalette(gGradientPalettes[0]);
 
CRGBPalette16 IceColors_p = CRGBPalette16(CRGB::Black, CRGB::Blue, CRGB::Aqua, CRGB::White);
 
uint8_t currentPatternIndex = 0; // Index number of which pattern is current
uint8_t autoplay = 0;
 
uint8_t allLeafs = 1;    // Sets if all leafs should get the same color
uint8_t selectedLeaf = 1;    // Sets position of leaf to color
 
uint8_t autoplayDuration = 10;
unsigned long autoPlayTimeout = 0;
 
uint8_t currentPaletteIndex = 0;
 
uint8_t gHue = 0; // rotating "base color" used by many of the patterns
 
uint8_t breathe = 0;  // value for starting custom pattern
uint8_t breathe_dir = 1;  // 1== rising
char cpattern[500] = "";
 
CRGB solidColor = CRGB::Blue;
 
// scale the brightness of all pixels down
void dimAll(byte value)
{
  for (int i = 0; i < NUM_LEDS; i++) {
    leds[i].nscale8(value);
  }
}
 
typedef void(*Pattern)();
typedef Pattern PatternList[];
typedef struct {
  Pattern pattern;
  String name;
} PatternAndName;
typedef PatternAndName PatternAndNameList[];
 
#include "Twinkles.h"
#include "TwinkleFOX.h"
 
// List of patterns to cycle through.  Each is defined as a separate function below.
 
PatternAndNameList patterns = {
  { pride,                  "Pride" },
  { colorWaves,            "Color Waves" },
 
  // twinkle patterns
  { rainbowTwinkles,        "Rainbow Twinkles" },
  { snowTwinkles,          "Snow Twinkles" },
  { cloudTwinkles,          "Cloud Twinkles" },
  { incandescentTwinkles,  "Incandescent Twinkles" },
 
  // TwinkleFOX patterns
  { retroC9Twinkles,        "Retro C9 Twinkles" },
  { redWhiteTwinkles,      "Red & White Twinkles" },
  { blueWhiteTwinkles,      "Blue & White Twinkles" },
  { redGreenWhiteTwinkles,  "Red, Green & White Twinkles" },
  { fairyLightTwinkles,    "Fairy Light Twinkles" },
  { snow2Twinkles,          "Snow 2 Twinkles" },
  { hollyTwinkles,          "Holly Twinkles" },
  { iceTwinkles,            "Ice Twinkles" },
  { partyTwinkles,          "Party Twinkles" },
  { forestTwinkles,        "Forest Twinkles" },
  { lavaTwinkles,          "Lava Twinkles" },
  { fireTwinkles,          "Fire Twinkles" },
  { cloud2Twinkles,        "Cloud 2 Twinkles" },
  { oceanTwinkles,          "Ocean Twinkles" },
 
  { rainbow,                "Rainbow" },
  { rainbowWithGlitter,    "Rainbow With Glitter" },
  { rainbowSolid,          "Solid Rainbow" },
  { confetti,              "Confetti" },
  { sinelon,                "Sinelon" },
  { bpm,                    "Beat" },
  { juggle,                "Juggle" },
  { fire,                  "Fire" },
  { water,                  "Water" },
 
  { showSolidColor,        "Solid Color" },
 
  { SetCustomPattern,      "Custom Pattern"}
};
 
const uint8_t patternCount = ARRAY_SIZE(patterns);
 
typedef struct {
  CRGBPalette16 palette;
  String name;
} PaletteAndName;
typedef PaletteAndName PaletteAndNameList[];
 
const CRGBPalette16 palettes[] = {
  RainbowColors_p,
  RainbowStripeColors_p,
  CloudColors_p,
  LavaColors_p,
  OceanColors_p,
  ForestColors_p,
  PartyColors_p,
  HeatColors_p
};
 
const uint8_t paletteCount = ARRAY_SIZE(palettes);
 
const String paletteNames[paletteCount] = {
  "Rainbow",
  "Rainbow Stripe",
  "Cloud",
  "Lava",
  "Ocean",
  "Forest",
  "Party",
  "Heat",
};
 
#include "Fields.h"
Ensuite le Setup :
Code:
void setup() {
  WiFi.setSleepMode(WIFI_NONE_SLEEP);
 
  Serial.begin(115200);
  delay(100);
  Serial.setDebugOutput(true);
 
  FastLED.addLeds<LED_TYPE, DATA_PIN, COLOR_ORDER>(leds, NUM_LEDS);        // for WS2812 (Neopixel)
  FastLED.setDither(false);
  FastLED.setCorrection(TypicalLEDStrip);
  FastLED.setBrightness(brightness);
  FastLED.setMaxPowerInVoltsAndMilliamps(5, MILLI_AMPS);
  fill_solid(leds, NUM_LEDS, CRGB::Black);
  FastLED.show();
 
  EEPROM.begin(512);
  loadSettings();
 
  FastLED.setBrightness(brightness);
 
  //  irReceiver.enableIRIn(); // Start the receiver
 
  Serial.println();
  Serial.print(F("Heap: ")); Serial.println(system_get_free_heap_size());
  Serial.print(F("Boot Vers: ")); Serial.println(system_get_boot_version());
  Serial.print(F("CPU: ")); Serial.println(system_get_cpu_freq());
  Serial.print(F("SDK: ")); Serial.println(system_get_sdk_version());
  Serial.print(F("Chip ID: ")); Serial.println(system_get_chip_id());
  Serial.print(F("Flash ID: ")); Serial.println(spi_flash_get_id());
  Serial.print(F("Flash Size: ")); Serial.println(ESP.getFlashChipRealSize());
  Serial.print(F("Vcc: ")); Serial.println(ESP.getVcc());
  Serial.println();
 
  SPIFFS.begin();
  {
    Serial.println("SPIFFS contents:");
 
    Dir dir = SPIFFS.openDir("/");
    while (dir.next()) {
      String fileName = dir.fileName();
      size_t fileSize = dir.fileSize();
      Serial.printf("FS File: %s, size: %s\n", fileName.c_str(), String(fileSize).c_str());
    }
    Serial.printf("\n");
  }
 
  //disabled due to https://github.com/jasoncoon/esp8266-fastled-webserver/issues/62
  //initializeWiFi();
 
  if (apMode)
  {
    WiFi.mode(WIFI_AP);
 
    // Do a little work to get a unique-ish name. Append the
    // last two bytes of the MAC (HEX'd) to "Thing-":
    uint8_t mac[WL_MAC_ADDR_LENGTH];
    WiFi.softAPmacAddress(mac);
    String macID = String(mac[WL_MAC_ADDR_LENGTH - 2], HEX) +
                  String(mac[WL_MAC_ADDR_LENGTH - 1], HEX);
    macID.toUpperCase();
    String AP_NameString = "HexaLeaf_Lights" ; // + macID;
 
    char AP_NameChar[AP_NameString.length() + 1];
    memset(AP_NameChar, 0, AP_NameString.length() + 1);
 
    for (int i = 0; i < AP_NameString.length(); i++)
      AP_NameChar[i] = AP_NameString.charAt(i);
 
    WiFi.softAP(AP_NameChar, WiFiAPPSK);
 
    Serial.printf("Connect to Wi-Fi access point: %s\n", AP_NameChar);
    Serial.println("and open http://192.168.4.1 in your browser");
  }
  else
  {
    WiFi.mode(WIFI_STA);
    Serial.printf("Connecting to %s\n", ssid);
    if (String(WiFi.SSID()) != String(ssid)) {
      WiFi.begin(ssid, password);
    }
  }
 
  httpUpdateServer.setup(&webServer);
 
  webServer.on("/all", HTTP_GET, []() {
    String json = getFieldsJson(fields, fieldCount);
    webServer.send(200, "text/json", json);
  });
 
  webServer.on("/fieldValue", HTTP_GET, []() {
    String name = webServer.arg("name");
    String value = getFieldValue(name, fields, fieldCount);
    webServer.send(200, "text/json", value);
  });
 
  webServer.on("/fieldValue", HTTP_POST, []() {
    String name = webServer.arg("name");
    String value = webServer.arg("value");
    String newValue = setFieldValue(name, value, fields, fieldCount);
    webServer.send(200, "text/json", newValue);
  });
 
  webServer.on("/power", HTTP_POST, []() {
    String value = webServer.arg("value");
    setPower(value.toInt());
    sendInt(power);
  });
 
  webServer.on("/cooling", HTTP_POST, []() {
    String value = webServer.arg("value");
    cooling = value.toInt();
    broadcastInt("cooling", cooling);
    sendInt(cooling);
  });
 
  webServer.on("/sparking", HTTP_POST, []() {
    String value = webServer.arg("value");
    sparking = value.toInt();
    broadcastInt("sparking", sparking);
    sendInt(sparking);
  });
 
  webServer.on("/speed", HTTP_POST, []() {
    String value = webServer.arg("value");
    speed = value.toInt();
    broadcastInt("speed", speed);
    sendInt(speed);
  });
 
  webServer.on("/twinkleSpeed", HTTP_POST, []() {
    String value = webServer.arg("value");
    twinkleSpeed = value.toInt();
    if (twinkleSpeed < 0) twinkleSpeed = 0;
    else if (twinkleSpeed > 8) twinkleSpeed = 8;
    broadcastInt("twinkleSpeed", twinkleSpeed);
    sendInt(twinkleSpeed);
  });
 
  webServer.on("/twinkleDensity", HTTP_POST, []() {
    String value = webServer.arg("value");
    twinkleDensity = value.toInt();
    if (twinkleDensity < 0) twinkleDensity = 0;
    else if (twinkleDensity > 8) twinkleDensity = 8;
    broadcastInt("twinkleDensity", twinkleDensity);
    sendInt(twinkleDensity);
  });
 
  webServer.on("/solidColor", HTTP_POST, []() {
    String r = webServer.arg("r");
    String g = webServer.arg("g");
    String b = webServer.arg("b");
    setSolidColor(r.toInt(), g.toInt(), b.toInt());
    sendString(String(solidColor.r) + "," + String(solidColor.g) + "," + String(solidColor.b));
    Serial.println(String(solidColor.r) + "," + String(solidColor.g) + "," + String(solidColor.b));
  });
 
  webServer.on("/pattern", HTTP_POST, []() {
    String value = webServer.arg("value");
    if (value.toInt() <= 29)
    {
      setPattern(value.toInt());
      sendInt(currentPatternIndex);
    }
  });
 
  webServer.on("/patternName", HTTP_POST, []() {
    String value = webServer.arg("value");
    setPatternName(value);
    sendInt(currentPatternIndex);
  });
 
  webServer.on("/palette", HTTP_POST, []() {
    String value = webServer.arg("value");
    setPalette(value.toInt());
    sendInt(currentPaletteIndex);
  });
 
  webServer.on("/paletteName", HTTP_POST, []() {
    String value = webServer.arg("value");
    setPaletteName(value);
    sendInt(currentPaletteIndex);
  });
 
  webServer.on("/brightness", HTTP_POST, []() {
    String value = webServer.arg("value");
    setBrightness(value.toInt());
    sendInt(brightness);
  });
 
  webServer.on("/autoplay", HTTP_POST, []() {
    String value = webServer.arg("value");
    setAutoplay(value.toInt());
    sendInt(autoplay);
  });
 
  webServer.on("/autoplayDuration", HTTP_POST, []() {
    String value = webServer.arg("value");
    setAutoplayDuration(value.toInt());
    sendInt(autoplayDuration);
  });
 
  webServer.on("/allLeafs", HTTP_POST, []() {
    String value = webServer.arg("value");
    setAllLeafs(value.toInt());
    sendInt(allLeafs);
  });
 
  webServer.on("/selectedLeaf", HTTP_POST, []() {
    String value = webServer.arg("value");
    setSelectedLeaf(value.toInt());
    sendInt(selectedLeaf);
  });
 
 
  webServer.on("/custom", HTTP_POST, []() {
    String value = webServer.arg("value");
    Serial.println(value);
    value.toCharArray(cpattern, 500);
    Serial.println(value);
    sendString(value);
    setPattern(30);
  });
 
 
  //list directory
  webServer.on("/list", HTTP_GET, handleFileList);
  //load editor
  webServer.on("/edit", HTTP_GET, []() {
    if (!handleFileRead("/edit.htm")) webServer.send(404, "text/plain", "FileNotFound");
  });
  //create file
  webServer.on("/edit", HTTP_PUT, handleFileCreate);
  //delete file
  webServer.on("/edit", HTTP_DELETE, handleFileDelete);
  //first callback is called after the request has ended with all parsed arguments
  //second callback handles file uploads at that location
  webServer.on("/edit", HTTP_POST, []() {
    webServer.send(200, "text/plain", "");
  }, handleFileUpload);
 
  webServer.serveStatic("/", SPIFFS, "/", "max-age=86400");
 
  webServer.begin();
  Serial.println("HTTP web server started");
 
  //  webSocketsServer.begin();
  //  webSocketsServer.onEvent(webSocketEvent);
  //  Serial.println("Web socket server started");
 
  autoPlayTimeout = millis() + (autoplayDuration * 1000);
}
Une partie de paramètres/variables entre le Setup et le Loop:

Code:
void sendInt(uint8_t value)
{
  sendString(String(value));
}
 
void sendString(String value)
{
  webServer.send(200, "text/plain", value);
}
 
void broadcastInt(String name, uint8_t value)
{
  String json = "{\"name\":\"" + name + "\",\"value\":" + String(value) + "}";
  //  webSocketsServer.broadcastTXT(json);
}
 
void broadcastString(String name, String value)
{
  String json = "{\"name\":\"" + name + "\",\"value\":\"" + String(value) + "\"}";
  //  webSocketsServer.broadcastTXT(json);
}
Et enfin le Loop:
Code:
void loop() {
  // Add entropy to random number generator; we use a lot of it.
  random16_add_entropy(random(65535));
 
  //  dnsServer.processNextRequest();
  //  webSocketsServer.loop();
  webServer.handleClient();
 
  //  handleIrInput();
 
  if (power == 0) {
    fill_solid(leds, NUM_LEDS, CRGB::Black);
    FastLED.show();
    // FastLED.delay(15);
    return;
  }
 
  static bool hasConnected = false;
  EVERY_N_SECONDS(1) {
    if (WiFi.status() != WL_CONNECTED) {
      //      Serial.printf("Connecting to %s\n", ssid);
      hasConnected = false;
    }
    else if (!hasConnected) {
      hasConnected = true;
      Serial.print("Connected! Open http://");
      Serial.print(WiFi.localIP());
      Serial.println(" in your browser");
    }
  }
 
  // EVERY_N_SECONDS(10) {
  //  Serial.print( F("Heap: ") ); Serial.println(system_get_free_heap_size());
  // }
 
  // change to a new cpt-city gradient palette
  EVERY_N_SECONDS(secondsPerPalette) {
    gCurrentPaletteNumber = addmod8(gCurrentPaletteNumber, 1, gGradientPaletteCount);
    gTargetPalette = gGradientPalettes[gCurrentPaletteNumber];
  }
 
  EVERY_N_MILLISECONDS(80) {
    // slowly blend the current palette to the next
    nblendPaletteTowardPalette(gCurrentPalette, gTargetPalette, 8);
    gHue++;  // slowly cycle the "base color" through the rainbow
  }
 
  EVERY_N_MILLIS_I(thistimer, 128-(speed/2)) {
    if (breathe_dir == 1)breathe++; else breathe--;
    if (breathe >= 255)breathe_dir = 0;
    else if (breathe <= 0) breathe_dir = 1;
    //Serial.println(breathe);
  }
  thistimer.setPeriod(64-(speed/4));
 
  if (autoplay && (millis() > autoPlayTimeout)) {
    adjustPattern(true);
    autoPlayTimeout = millis() + (autoplayDuration * 1000);
  }
 
  // Call the current pattern function once, updating the 'leds' array
  patterns[currentPatternIndex].pattern();
 
  FastLED.show();
 
  // insert a delay to keep the framerate modest
  FastLED.delay(1000 / FRAMES_PER_SECOND);
}
A savoir que dans les deux cas il y a des onglets avec d'autres codes mais qui servent dans la majorités des cas aux animations et/ou au WebServer (mise en pages et autres objets sur la page web)

J'espère que cela sera visible :oops: sinon y'a le GitHub pour le projet Smart NanoLeaf
 

[Clad]

Manipulateur de bits
C'est bien visible merci (je c/c dans un editeur donc no souci).

Peux tu faire les tests cités plus haut pour voir déjà si on peut éliminer des suspects de la liste des problèmes possibles ?

Si un des tests tu ne sais pas comment faire ou si t'es pas sur tiens moi au jus.


Tu peux aussi tester de changer la ligne 42 de to void loop pour rafraichir plus doucement les Leds pour voir si les glitchs disparaissent :
EVERY_N_MILLISECONDS(200)
au lieu de EVERY_N_MILLISECONDS(80)
 
Haut