Go Down

Topic: testbericht zum WS2812 (Read 63775 times) previous topic - next topic

Eisebaer

hi, uwe,

mit     "iaz hett's mi foscht"    komm' ich klar, aber woher kommt   "fregiert"     ?

erkenne da keinen wortstamm...

gruß stefan

uxomm

Quote
In Anlehnung an die It Sprache sagen wir: "iaz hett's mi foscht fregiert".


Tippe auf:
fregare (reiben, aber auch betrügen)
fregatura - Betrug, Reinfall

:-)

Gruß
Udo
Always decouple electronic circuitry.

Helmuth

#212
Aug 21, 2014, 09:19 am Last Edit: Aug 21, 2014, 09:42 am by Helmuth Reason: 1
@Eisebaer: Ich liebe Deine Kommentare!

@sschultewolter: Zum schnell faden habe ich immer diese Tabelle von Paul Stoffregen verwendet

Code: [Select]
//Gamma Correction Curve
uint8_t const exp_gamma[256] PROGMEM=
{0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,3,3,3,3,3,
4,4,4,4,4,5,5,5,5,5,6,6,6,7,7,7,7,8,8,8,9,9,9,10,10,10,11,11,12,12,12,13,13,14,14,14,15,15,
16,16,17,17,18,18,19,19,20,20,21,21,22,23,23,24,24,25,26,26,27,28,28,29,30,30,31,32,32,33,
34,35,35,36,37,38,39,39,40,41,42,43,44,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,70,71,72,73,74,75,77,78,79,80,82,83,84,85,87,89,91,92,93,95,96,98,
99,100,101,102,105,106,108,109,111,112,114,115,117,118,120,121,123,125,126,128,130,131,133,
135,136,138,140,142,143,145,147,149,151,152,154,156,158,160,162,164,165,167,169,171,173,175,
177,179,181,183,185,187,190,192,194,196,198,200,202,204,207,209,211,213,216,218,220,222,225,
227,229,232,234,236,239,241,244,246,249,251,253,254,255
};


Seit FastLED v2.1 Temporal Dithering unterstuetzt hat sich das aber auch erledigt und man kann auch ohne Korrekturtabellen sehr schoen weich im unteren Bereich faden, jedenfalls wenn die Striplaenge >100 fps erlaubt (sonst nehmen sensible Menschen ein leichtes flimmern wahr). Das entspricht ca. 300 LEDs an einem Strang.
Falls nicht bekannt: Beim Dithering wird sozusagen die Hardware PWM der LEDs durch eine Software PWM moduliert, um die gefuehlte Aufloesung im unteren Bereich deutlich zu erhoehen und das logarithmische Helligkeitempfinden des menschlichen Auges auszugleichen. Macht aber nur bei langsamen Fades wirklich Sinn.  

@Uwe: Mir ist kein Grund bekannt, FastLED nicht zu verwenden. Kenne nichts, was kleiner kompiliert, weniger RAM braucht oder flexibler in der Anwendung waere. Ausser vielleicht, man ist Copy + Paste Artist und probiert mal schnell fremden Code aus...  ;)

Farbreihenfolge wird beim Initialisieren festgelegt:

Code: [Select]
FastLED.addLeds<CHIPSET, LED_PIN, COLOR_ORDER>(leds, NUM_LEDS);

Bei COLOR_ORDER einfach RGB oder GRB oder sonstwas eintragen und fertig.

Gruss

Helmuth

sschultewolter


@Uwe: Mir ist kein Grund bekannt, FastLED nicht zu verwenden. Kenne nichts, was kleiner kompiliert, weniger RAM braucht oder flexibler in der Anwendung waere. Ausser vielleicht, man ist Copy + Paste Artist und probiert mal schnell fremden Code aus...  ;)

https://github.com/cpldcpu/light_ws2812

Hab nur die AVR-GCC Variante im Einsatz, die für Arduino noch nicht getestet. Sollte aber deutlich kleiner sein. Aber es fehlt einiges an Komfort aus der FastLed-Libary.

Habe mir die meisten Funktionen dafür selber zusammengebastelt um sie Projektorientiert zu nutzen.
Orginal Atmel AVRISP mkII zu verkaufen. Anfrage per PN ;)

Kramie

Hy, an alle! Super Forum.

Ich bin kompletter Neuling auf dem Gebiet Arduino und Programmieren, trotzdem hatte ich mir in den Kopf gesetzt eine Treppenbeleuchtung mit dem Arduino und WS2812b Strips zu realiesieren. Hat soweit auch ganz gut geklappt. Doch jetzt möchte ich natürlich auch nen paar Besonderheiten einbauen, nur weis nicht so richtig wie ich Anfangen soll! Habe nen bisschen mit dem Code des Moodlight 2.0 gespielt, nur jetzt das Problem:
Kann ich einen Farbverlauf quasi im Hintergrund laufen lassen und dann Stufe für Stufe Hell-werden lassen?

MfG
Danke Schonmal :)


sschultewolter

Moodlight 2.0 kannte ich nicht. Hab gerade ein Video dort gesehen https://www.youtube.com/watch?v=9IisUrFWD5c. Ist das sowas?

"Im Hintergrund laufen lassen" musst du genauer erklären. Bei einem AVR gibt es kein Multithreading o.ä. bei dem man bestimmte Sachen im Hintergrund laufen lässt. Die Einfachste Möglichkeit ist es mit dem HSV-Farbraum zu arbeiten und den V-Anteil langsam hochzuregeln,
Orginal Atmel AVRISP mkII zu verkaufen. Anfrage per PN ;)

Kramie

hy, danke für die schnelle Antwort. Sorry, hatte mich Verschrieben, hier mal das video: www.youtube.com/watch?v=6jfAZXOzzec
Das mit dem Multithreading hab ich schon rausgefunden, ich hatte mir das so gedacht, das ich im loop den Farbwechsel permanent laufen lasse und über nen Event (tastendruck) die Stufen nacheinander hochregel.

sschultewolter

Sollte kein Problem sein. Ein paar Effekte hatte ich auch hier mal im Forum hinterlegt. Werden von mir aber nicht weiter entwickelt und sind keinesfalls die HighEnd Lösung. Dort sind einige Sachen bereits stark überarbeitet (vereinfachteter Code, weniger Speicher und weniger Auslastung). Die sind aber noch nicht veröffentlicht, da ich gerade eine größere Sammlung anlege.
http://forum.arduino.cc/index.php?topic=198987.0
Wie gesagt, dort werden keine Optimierungen mehr wahrgenommen. Die Anwendungen dort sind lediglich für 1D Optik gedacht. Die Neuentwicklung beinhaltet erst einmal auch in erster Hinsicht alles Richtung 1D. Die Effekte, sofern noch nicht geschehen sind komplett skalierbar.
Orginal Atmel AVRISP mkII zu verkaufen. Anfrage per PN ;)

Kramie

Hy, ich schau mir das mal an und Probier nen bissel aus.
Ich füge mal meinen Aktuellen Code der Treppenbeleuchtung .
Code: [Select]
#include "FastLED.h"
#define NUM_LEDS 80
// Data pin
#define DATA_PIN 13

CRGB leds[NUM_LEDS];

int pirPin1 = 7;     //the digital pin Taster Unten
int pirPin2 = 8;     //the digital pin Taster Oben

int globaldelay = 5;
       
int mode;
int treppe = 70;      
int ledsstufe = 5;   // Anzahl der LED´s Pro Stufe
int laufzeit= 15000; // Maximal laufzeit
int helli = 200;     // hier die max helligkeit vorgeben
int fadezeit =5;     // Zeit zum hochlauf/ablauf der Helligkeit
int fadestufen = 10;
int an = false;      
int oben = false;
int unten = false;
int fa1 =0;

////////////////



void setup()
{
 FastLED.addLeds<WS2812B, DATA_PIN, GRB>(leds, NUM_LEDS);
 
 Serial.begin(9600); // connect to the serial port

}


////////////////
// ausschalten aller Stufen von unten nach oben

void untenAN (){



 for (int stufe=0; stufe<=treppe ; stufe+=ledsstufe){
     if (fa1 == 0){
           for (int i=0; i<=helli; i+=fadestufen){
             
              leds [stufe] =CRGB(0,i,0);        //
              leds [stufe+1] =CRGB(0,i,0);      //
              leds [stufe+2] =CRGB(0,i,0);      //  Hier müssen manuell die Leds
              leds [stufe+3] =CRGB(0,i,0);      //  pro Stufe geschaltet werden
              leds [stufe+4] =CRGB(0,i,0);      //  
              //leds [stufe+5] =CRGB(i,0,0);      //  
              //leds [stufe+6] =CRGB(i,0,0);      //
                FastLED.show();
            delay(fadezeit);
         
           }
     }
     
     if (fa1 ==1){
          for (int i=0; i<=helli; i+=fadestufen){
             
              leds [stufe] =CRGB(0,0,i);        //
              leds [stufe+1] =CRGB(0,0,i);      //
              leds [stufe+2] =CRGB(0,0,i);      //  Hier müssen manuell die Leds
              leds [stufe+3] =CRGB(0,0,i);      //  pro Stufe geschaltet werden
              leds [stufe+4] =CRGB(0,0,i);      //  
              //leds [stufe+5] =CRGB(i,0,0);      //  
              //leds [stufe+6] =CRGB(i,0,0);      //
                FastLED.show();
            delay(fadezeit);
         
           }      
     }
}

}


/////////////////
// anschalten aller Stufen von oben nach unten

void obenAN (){


 for (int stufe=treppe; stufe>=0 ; stufe-=ledsstufe){
   if (fa1 ==0){
   
           
           for (int i=0; i<=helli; i+=fadestufen){
              leds [stufe] =CRGB(0,i,0);        //
              leds [stufe+1] =CRGB(0,i,0);      //
              leds [stufe+2] =CRGB(0,i,0);      //  Hier müssen manuell die Leds
              leds [stufe+3] =CRGB(0,i,0);      //  pro Stufe geschaltet werden
              leds [stufe+4] =CRGB(0,i,0);      //  im Moment 1 LED´s pro Stufe
              //leds [stufe+5] =CRGB(i,0,0);      //  
              //leds [stufe+6] =CRGB(i,0,0);      //
           FastLED.show();
        delay(fadezeit);
  }
   }
 if (fa1==1){
    for (int i=0; i<=helli; i+=fadestufen){
             
              leds [stufe] =CRGB(0,0,i);        //
              leds [stufe+1] =CRGB(0,0,i);      //
              leds [stufe+2] =CRGB(0,0,i);      //  Hier müssen manuell die Leds
              leds [stufe+3] =CRGB(0,0,i);      //  pro Stufe geschaltet werden
              leds [stufe+4] =CRGB(0,0,i);      //  
              //leds [stufe+5] =CRGB(i,0,0);      //  
              //leds [stufe+6] =CRGB(i,0,0);      //
                FastLED.show();
            delay(fadezeit);
}
}

 }
}
///////////////
// ausschalten aller Stufen von unten nach oben

void untenAUS (){


 for (int stufe=0; stufe<=treppe ; stufe+=ledsstufe){
       if (fa1 ==0){
           for (int i=helli; i>=0; i-=fadestufen){
              leds [stufe] =CRGB(0,i,0);        //
              leds [stufe+1] =CRGB(0,i,0);      //
              leds [stufe+2] =CRGB(0,i,0);      //  Hier müssen manuell die Leds
              leds [stufe+3] =CRGB(0,i,0);      //  pro Stufe geschaltet werden
              leds [stufe+4] =CRGB(0,i,0);      //  im Moment 1 LED´s pro Stufe
              //leds [stufe+5] =CRGB(i,0,0);      //  
              //leds [stufe+6] =CRGB(i,0,0);      //
          FastLED.show();
        delay(fadezeit);
           }
}
      if (fa1 ==1){
        for (int i=helli; i>=0; i-=fadestufen){
             
              leds [stufe] =CRGB(0,0,i);        //
              leds [stufe+1] =CRGB(0,0,i);      //
              leds [stufe+2] =CRGB(0,0,i);      //  Hier müssen manuell die Leds
              leds [stufe+3] =CRGB(0,0,i);      //  pro Stufe geschaltet werden
              leds [stufe+4] =CRGB(0,0,i);      //  
              //leds [stufe+5] =CRGB(i,0,0);      //  
              //leds [stufe+6] =CRGB(i,0,0);      //
                FastLED.show();
            delay(fadezeit);
         
           }
      }
}

}



////////////////
// ausschalten aller Stufen von oben nach unten

void obenAUS (){


 for (int stufe=treppe; stufe>=0 ; stufe-=ledsstufe){
  if (fa1 ==0){
           for (int i=helli; i>=0; i-=fadestufen){
              leds [stufe] =CRGB(0,i,0);        //
              leds [stufe+1] =CRGB(0,i,0);      //
              leds [stufe+2] =CRGB(0,i,0);      //  Hier müssen manuell die Leds
              leds [stufe+3] =CRGB(0,i,0);      //  pro Stufe geschaltet werden
              leds [stufe+4] =CRGB(0,i,0);      //  im Moment 1 LED´s pro Stufe
              //leds [stufe+5] =CRGB(i,0,0);      //  
              //leds [stufe+6] =CRGB(i,0,0);      //
           FastLED.show();
        delay(fadezeit);
  }
 }

 if (fa1 ==1){
       
           for (int i=helli; i>=0; i-=fadestufen){
              leds [stufe] =CRGB(0,i,0);        //
              leds [stufe+1] =CRGB(0,i,0);      //
              leds [stufe+2] =CRGB(0,i,0);      //  Hier müssen manuell die Leds
              leds [stufe+3] =CRGB(0,i,0);      //  pro Stufe geschaltet werden
              leds [stufe+4] =CRGB(0,i,0);      //  im Moment 1 LED´s pro Stufe
              //leds [stufe+5] =CRGB(i,0,0);      //  
              //leds [stufe+6] =CRGB(i,0,0);      //
           FastLED.show();
        delay(fadezeit);
         
           }  
   
}
}

}

void rainbow2(int mode){

 //for (int t = 0; t<=200;){
   for(int i = 255; i >= 0; i--)
   {
     for (int col = 0; col < 14; col++) {
       for(int row = 0; row < 5; row++) {
         int v = ((10*row) + i) % 255;
         setHue2(v,(5*col + row));        
       }
     }
     //t +=1;
     Serial.print("  ");
     Serial.print(i);
     Serial.print("  ");
     FastLED.show();
     delay(100);
     
   }

   
 //}delay(100);

}




/**
* function to set a specific LED in the chain to a given value of the HVS color-circle
*
* this is simplified version of HVS to RGB comversion
* see: http://en.wikipedia.org/wiki/HSL_and_HSV#Converting_to_RGB
*
* in all cases saturation and value are "1" so we do not have to calculate all parts
*
* we also use a range of 0 to 255 instead of 0 to 360 for HUE
**/
void setHue2(int h, int pin) {
 //this is the algorithm to convert from RGB to HSV
 double r=0;
 double g=0;
 double b=0;

 double hf=h/42.5;

 //calculate with 255 instead of 360° for the whole color-circle so we have to divide by 42.5 instead of 60°
 int i=(int)floor(h/42.5);
 double f = h/42.5 - i;
 double qv = 1 - f;
 double tv = f;

 switch (i)
 {
 case 0:
   r = 1;
   g = tv;
   break;
 case 1:
   r = qv;
   g = 1;
   break;
 case 2:
   g = 1;
   b = tv;
   break;
 case 3:
   g = qv;
   b = 1;
   break;
 case 4:
   r = tv;
   b = 1;
   break;
 case 5:
   r = 1;
   b = qv;
   break;
 }

 //set each component to a integer value between 0 and 255
 leds[pin].r = constrain((int)255*r,0,255);
 leds[pin].g = constrain((int)255*g,0,255);
 leds[pin].b = constrain((int)255*b,0,255);

}

/**
* function to set a specific LED in the chain to concrete R, G and B values
*
**/
void setRGB(int r, int g, int b, int pin) {
 //set each component to a integer value between 0 and 255
 leds[pin].r = r;
 leds[pin].g = g;
 leds[pin].b = b;

}





Kramie

Code: [Select]

void pausenschleife1(){


    for(int i = 0; i<= 1500; i++){
      delay(10);
      if (digitalRead(pirPin2) == HIGH & i>=550){
      i =1500;
      }
      if (digitalRead(pirPin1) == HIGH){
      i =1500;
      oben = true;
      }
     
         
    }

}

void pausenschleife2(){


    for(int i = 0; i<= 1500; i++){
      delay(10);
      if (digitalRead(pirPin1) == HIGH & i>=550){
      i =1500;
      }
      if (digitalRead(pirPin2) == HIGH){
      i =1500;
      unten = true; 
    }
     
    }

}
///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
////////////////////////////////  LOOP   //////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
void loop(){


 
  if (digitalRead(pirPin1)== HIGH){ 
         an = true ;
         
         untenAN();   //the leds turned on from bottom to top
         if (digitalRead(pirPin1) == HIGH){
           rainbow2(mode);
         }
         pausenschleife1();
         if (oben == true){
         obenAUS();
         }
         else{
         untenAUS();  //the leds turned off from bottom to top
         }
         an = false;
         oben = false;
         
}





         
   if (digitalRead(pirPin2) == HIGH){     
         
         an = true;
         
         obenAN();   //the leds turned on from top to bottom
         if (digitalRead(pirPin2) == HIGH){
           rainbow2(mode);
         }
         pausenschleife2();
         if (unten == true){
         untenAUS();
         }
         else{ 
         obenAUS();  //the leds turned off from top to bottom
         }
        an = false;
        unten = false;
         
           
}

//Serial.print(fa1); 
}

Danke schonmal für die hilfe, ist wie gesagt nen Anfängercode! :)

Chris72622

Endlich liegt die 4m Rolle hier auf dem Tisch.

Habe jetz ein paar Stunden damit gespielt und folgendes herausgefunden: Für bunte Effekte geht die Länge klar, 4m in weiss kann man allerdings vergessen. Die ersten 2m sehen ok aus, dann driftet die Farbe wegen Spannungsabfall weg.
Ein alter Thread, ja. Trotzdem von mir folgende Frage:

Wie viele LEDs pro Meter hatten die hierbei von Dir verwendeten LED-Streifen?

Gruß Chris
Suche PoE Modul für Ethernet Shield

Helmuth

#221
Feb 01, 2016, 01:18 pm Last Edit: Feb 01, 2016, 03:09 pm by Helmuth
Falls das Zitat von mir ist, das waren 60 Leds/m.

Wenn Du FastLED verwendest, kannst Du den Strom begrenzen = dynamische Helligkeitsregelung.

4A Dauerstrom mit einer Einspeisungsstelle geht klar, 8A für kurze Impulse.

(Und ich sehe Uwe mit dem Kopf schütteln...)

Gruß,

Helmuth

Chris72622

#222
Feb 01, 2016, 01:54 pm Last Edit: Feb 01, 2016, 01:55 pm by Chris72622
Dank Dir. :)

Kann jmd. bestätigen, ob es mit 30 LEDs pro Meter auch zu den von Helmuth beschriebenen Problemen kommt?

Gruß Chris
Suche PoE Modul für Ethernet Shield

sschultewolter

Du solltest versuchen, etwa alle 30 Leds neu einzuspeisen. Die Probleme kommen daher, dass der Spannungsabfall zu hoch wird. Wie im anderen Thread bereits geschrieben, macht es Sinn, parallel zum Strip noch 2 Versorgungsleitungen zu ziehen.

Eine andere, in meinen Augen sogar bessere Lösung wäre es,  wenn du alle 30 - 40 Leds einen StepDown setzt, welches über 12 - 12V gespeisst wird. Die 5V dann an den Streifen.
Orginal Atmel AVRISP mkII zu verkaufen. Anfrage per PN ;)

agmue

Eine andere, in meinen Augen sogar bessere Lösung wäre es,  wenn du alle 30 - 40 Leds einen StepDown setzt, welches über 12 - 12V gespeisst wird. Die 5V dann an den Streifen.
Wenn Du die vierfache Spannung nimmst, fließt nur ein Viertel des Stroms durch die Versorgungsleitung, womit sie dünner ausgelegt werden kann.

Go Up
 


Please enter a valid email to subscribe

Confirm your email address

We need to confirm your email address.
To complete the subscription, please click the link in the email we just sent you.

Thank you for subscribing!

Arduino
via Egeo 16
Torino, 10131
Italy