Carte de gestion : guirlande solaire à led ws2812

La réalisation de la guirlande à base de leds adressable ws2812 et assez simple. Les leds adressables ont un gros avantage, c’est des pouvoirs changer de couleur à la demande avec un simple bout de code émis depuis un ardu ino par exemple.

réalisation de la guirlande



À présent attaquons-nous au cœur du sujet, la carte qui va gérer tout ce bordel!

Effectivement, une des lignes du cahier des charges de cette guirlande était d’être autonome car placé dans un endroit sans source d’énergie électrique.

Donc la solution sera évidemment avec une pile ou un accumulateur, et vous connaissez bien mon amour pour les accus du type 18650 et cela sera mon choix pour le stockage de l’énergie. Énergie qui viendra directement d’un panneaux solaire 30W que j’ai pue avoirs il y a quelques années à un très bon prix sur Ebay: https://www.youtube.com/watch?v=r9QulDtlmIk

J’ai dû réaliser la carte assez rapidement donc je me suis tournée vers des modules déjà tous fais ainsi qu’une plaque pcb de prototypage pour interconnectée tous ce beau monde.

Pour la régulation solaire j’ai simplement pris un module solaire vers USB qui nous sort un jolie 5v bien réguler hi hi . Pour la régulation de la batterie je ne vous présenterai pas le module à base de Tp4056 que j’ai utilisé qui est tellement connu et qui fais parfaitement le taf!

Bon assez parler, je vous propose directement le plan!





Rien de bien compliquer assurément, deux jeux de résistance pour créer un pont diviseur pour chopper la tension du panneau solaire qui nous sert à savoir quand allumer la guirlande via le relay.

Et un deuxième pour connaitre la tension aux bornes de la batterie, pour géré intelligemment celle-ci afin de pas l’amener en décharge profonde.

J’ai tenté de couper le jus via un motsfet plutôt que par un relay mais les leds ws2812 n’aiment pas trop, je suppose une tension revient via le pin 2 de l’arduino, même si aucun signale nés émis, étrange! Si vous avez une idée je suis tout ouï !

Bon allez du code stp :p

/** Code par MrMOI54 */
 float vPow = 5.7;
 float r1 = 33000;
 float r2 = 8200;
 float start = 0;
 float count = 0;
 float cycle = 9000000;

unsigned long previousMillis = 0;
unsigned long premillis = 0; 

 

#include <FastLED.h>

FASTLED_USING_NAMESPACE


#if defined(FASTLED_VERSION) && (FASTLED_VERSION < 3001000)
#warning "Requires FastLED 3.1 or later; check github for latest code."
#endif

#define DATA_PIN    2

#define LED_TYPE    WS2812
#define COLOR_ORDER GRB
#define NUM_LEDS    20
CRGB leds[NUM_LEDS];

#define BRIGHTNESS          10
#define FRAMES_PER_SECOND  120


 
 void setup() {
   

   delay(2000);
   Serial.begin(9600);

      
      FastLED.addLeds<LED_TYPE,DATA_PIN,COLOR_ORDER>(leds, NUM_LEDS).setCorrection(TypicalLEDStrip);
  //FastLED.addLeds<LED_TYPE,DATA_PIN,CLK_PIN,COLOR_ORDER>(leds, NUM_LEDS).setCorrection(TypicalLEDStrip);

  // set master brightness control
  FastLED.setBrightness(BRIGHTNESS);
 }

// List of patterns to cycle through.  Each is defined as a separate function below.
typedef void (*SimplePatternList[])();
SimplePatternList gPatterns = { rainbow, rainbowWithGlitter, firstlight, sinelon, juggle,  };

uint8_t gCurrentPatternNumber = 0; // Index number of which pattern is current
uint8_t gHue = 0; // rotating "base color" used by many of the patterns
 
 void loop() {

   unsigned long currentMillis = millis();
//////////////////////////////////////////////////////////////// Mesure tension //////////////////////////////////////////////////  
   float v = (analogRead(6) * vPow) / 1024.0;
   float v2 = v / (r2 / (r1 + r2));

   

   Serial.print(v2);
   Serial.println(" V_b");

   float vp = (analogRead(7) * vPow) / 1024.0;
   float vp2 = vp / (r2 / (r1 + r2));

   Serial.print(vp2);
   Serial.println(" V_P");

///////////////////////////////////////////////////////////// Démmarage cycle /////////////////////////////////////////////////   

   if ( vp2 <= 0.00 ) {

    start = 1;

    if ( count = 1 ){
    premillis = millis;
    count = 0 ;
   }
   
   }

////////////////////////////////////////////////////////// Variable tension batterie /////////////////////////////////////////



   
   if ( (v2 < 4.00) && (v2 >4.5)){

FastLED.setBrightness(125);
     
   }
   
    if ( (v2 < 3.8) && (v2 >3.99)){

FastLED.setBrightness(96);
     
   }

    if ( (v2 < 3.20) && (v2 >3.79)){

FastLED.setBrightness(86);
     
   }

if ( (v2 < 3.00) && (v2 >3.19)){

FastLED.setBrightness(40);
     
   }

    if ( (v2 < 2.8) && (v2 >2.99)){

FastLED.setBrightness(10);
     
   }
//////////////////////////////////////////////////////////  Cycle led ////////////////////////////////////////////////////////
   if(  v2 > 2.80 && start == 1 ){

   count = 1;
   
   if (currentMillis - premillis > cycle){
    start = 0;
     FastLED.clear();
    FastLED.show();
    digitalWrite(10, LOW);
    count = 0 ;
    delay(61200000);

    asm volatile (" jmp 0");
    
    
   }

   digitalWrite(10, HIGH);
    // Call the current pattern function once, updating the 'leds' array
  gPatterns[gCurrentPatternNumber]();

  // send the 'leds' array out to the actual LED strip
  FastLED.show();  
  // insert a delay to keep the framerate modest
  FastLED.delay(1000/FRAMES_PER_SECOND); 

  // do some periodic updates
  EVERY_N_MILLISECONDS( 20 ) { gHue++; } // slowly cycle the "base color" through the rainbow
  EVERY_N_SECONDS( 10 ) { nextPattern(); } // change patterns periodically

   }

   
  
   }

   #define ARRAY_SIZE(A) (sizeof(A) / sizeof((A)[0]))


   
//////////////////////////////////////////////////////////////////////  Cycle Commande led //////////////////////////////////////////////



void nextPattern()
{
  // add one to the current pattern number, and wrap around at the end
  gCurrentPatternNumber = (gCurrentPatternNumber + 1) % ARRAY_SIZE( gPatterns);
}

void rainbow() 
{
  // FastLED's built-in rainbow generator
  fill_rainbow( leds, NUM_LEDS, gHue, 7);
}

void rainbowWithGlitter() 
{
  // built-in FastLED rainbow, plus some random sparkly glitter
  rainbow();
  addGlitter(80);
}

void addGlitter( fract8 chanceOfGlitter) 
{
  if( random8() < chanceOfGlitter) {
    leds[ random16(NUM_LEDS) ] += CRGB::White;
  }
}


void firstlight() {
  
   for(int whiteLed = 0; whiteLed < NUM_LEDS; whiteLed = whiteLed + 1) {
      
      leds[whiteLed] = CRGB::White;

     
      FastLED.show();

      
      delay(100);

      
      leds[whiteLed] = CRGB::Black;
   }
}



void sinelon()
{
  // a colored dot sweeping back and forth, with fading trails
  fadeToBlackBy( leds, NUM_LEDS, 20);
  int pos = beatsin16( 13, 0, NUM_LEDS-1 );
  leds[pos] += CHSV( gHue, 255, 192);
}



void juggle() {
  // eight colored dots, weaving in and out of sync with each other
  fadeToBlackBy( leds, NUM_LEDS, 20);
  byte dothue = 0;
  for( int i = 0; i < 8; i++) {
    leds[beatsin16( i+7, 0, NUM_LEDS-1 )] |= CHSV(dothue, 200, 255);
    dothue += 32;
  }
 }

Dans cette version prototypée je me suis bien rendu compte de certains problèmes a l’usage sur le long terme ( 1 mois et demi) je devrais alors refaire une carte plus pousser et mieux réfléchis à l’approche de l’hiver prochain.

Effectivement, le convertisseur boost consomme quelque 50 ma en permanence car j’ai choisi un arduino pro mini en 5 v, de plus il aurait été préférable je pense de travailler avec une tension plus élevée (7.4v ?) afin de l’abaissée vers du 5v pour les leds plutôt que le contraire.

En tout cas ont tâché de régler tous c’est petit inconvénient pour la saison prochaine : D

février 21, 2020

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *