Go Down

Topic: (solved, but continued) Inhalt eines RGB Strips weich überblenden (Read 7246 times) previous topic - next topic

Doc_Arduino

Hallo,

hab das probiert. Das funktioniert aber nicht wie gedacht. Das ist nur ein mehr oder weniger unkoordiniertes blitzen der LEDs. Ich glaube auch zu wissen warum. Die "Hardware PWM" und die Software PWM arbeiten gegeneinander. Ich versuche es später an reinen digitalen Ausgängen, dann sollte es klappen, denke ich.

Code: [Select]

// Arduino Mega 2560

int EIN = 1;

int GruppeA = 2;  // Pin 2   LED Nr. 4 (mittelste) (Würfelzahl)
int GruppeB = 3;  // Pin 3   LED Nr. 1 + 7
int GruppeC = 4;  // Pin 4   LED Nr. 3 + 5
int GruppeD = 5;  // Pin 5   LED Nr. 2 + 6

void setup()
{     
   Serial.begin(9600);
pinMode(GruppeA, OUTPUT);
pinMode(GruppeB, OUTPUT);
pinMode(GruppeC, OUTPUT);
pinMode(GruppeD, OUTPUT);
   
}

void loop()
{

       analogWrite(GruppeA, EIN);
       analogWrite(GruppeB, EIN);                                 // PWM Ausgabe an LED
       analogWrite(GruppeC, EIN);
       analogWrite(GruppeD, EIN);
       delay(1);
       //delayMicroseconds()
       
       analogWrite(GruppeA, 0);
       analogWrite(GruppeB, 0); 
       analogWrite(GruppeC, 0);
       analogWrite(GruppeD, 0); 
       delay(2);
       //delayMicroseconds()
}
Tschau
Doc Arduino '\0'

Messschieber auslesen: http://forum.arduino.cc/index.php?topic=273445
EA-DOGM Display - Demos: http://forum.arduino.cc/index.php?topic=378279

Doc_Arduino

Hallo,

mit digitalWrite klappt das jetzt. In µs im Verhältnis 30/1970 leuchtet es stabil dunkel. Unter 30 High-Pegel flackert es. Diese Zündeffekte sehe ich aber nicht mehr. Ich vermute das die PWM Funktion nicht astrein 100% funktioniert. Hätte es mit Software PWM nicht funktioniert, hätte ich den Zündeffekt auf ein Halbleitereffekt geführt.

Das Software-PWM hat aber einen großen Nachteil. Je nach Sketchlänge muß man die Werte immer wieder anpassen. Nehme ich zum Bsp. analogWrite (ganz unten) als Vergleich dazu, muß ich mehr wie 35 vorgeben. Sonst flackert es wieder.

Wobei ich mit paralleln analogWrite mit anderer LED Gruppe vorhin einen seltsamen Effekt hatte. Mit dem leuchtete gar keine LED mehr. Nach langen Rätselraten und vielleicht 4x neu flashen ging es dann plötzlich. Weis nicht warum.


Code: [Select]


int PWM_WERT = 1;
int HIGHPULSDAUER = 25;   // Verhältnis 30 / 1970 entspricht ca. PWM 1 bei ca. 500 Hz
int LOWPULSDAUER = 1975;

byte LEDAUS = 0;

int GruppeA = 22;  // Pin 22   LED Nr. 4 (mittelste) (Würfelzahl)
int GruppeB =  5;  // Pin  5   LED Nr. 1 + 7
int GruppeC = 24;  // Pin 24   LED Nr. 3 + 5
int GruppeD = 25;  // Pin 25   LED Nr. 2 + 6

unsigned long TIME_NEW;
unsigned long TIME_OLD = 0;

unsigned long ZEIT_NEW;
unsigned long ZEIT_OLD = 0;

void setup()
{     
   Serial.begin(9600);
pinMode(GruppeA, OUTPUT);
pinMode(GruppeB, OUTPUT);
pinMode(GruppeC, OUTPUT);
pinMode(GruppeD, OUTPUT);
   
}

void loop()
{
   
       TIME_NEW = micros();
       ZEIT_NEW = millis();
       
       if (TIME_NEW - TIME_OLD <= HIGHPULSDAUER)
         {
          //digitalWrite(GruppeA, EIN);
          //digitalWrite(GruppeB, EIN);                                 // Software PWM
          //digitalWrite(GruppeC, EIN);
          digitalWrite(GruppeD, HIGH);
         
         }
       
       
        if ((TIME_NEW - TIME_OLD > HIGHPULSDAUER) && (LEDAUS == 0))     // LEDAUS Check zum überspringen der if Schleife wenn schon 1x durchlaufen
         {
          //digitalWrite(GruppeA, 0);
          //digitalWrite(GruppeB, 0); 
          //digitalWrite(GruppeC, 0);
          digitalWrite(GruppeD, LOW); 
          LEDAUS = 1;       
         }
 
 
       if (TIME_NEW - TIME_OLD > LOWPULSDAUER)
         {
           TIME_OLD = TIME_NEW;
           LEDAUS = 0;
         }
       

       if (ZEIT_NEW - ZEIT_OLD > 5000)
         {
           delay(1000);
           ZEIT_OLD = ZEIT_NEW;
         }


 
       //analogWrite(GruppeA, PWM_WERT);
//       analogWrite(GruppeB, PWM_WERT);                                 // PWM Ausgabe an LED
       //analogWrite(GruppeC, PWM_WERT);
       //analogWrite(GruppeD, PWM_WERT);

}


Tschau
Doc Arduino '\0'

Messschieber auslesen: http://forum.arduino.cc/index.php?topic=273445
EA-DOGM Display - Demos: http://forum.arduino.cc/index.php?topic=378279

Chris72622

Hallo,

ist es so, dass es nun im Jahr 2016 sinnvoller ist, die in diesem Thread geforderte Funktionalität mit den Modulen der FastLED-Library zu lösen und falls ja, mit welchen? Finden sich hier die besten Erklärungen zur Library?

Gruß Chris

PS: Da stand "but continued".. konnte daher nicht widerstehen. Ich bitte um Nachsicht. :P
Suche PoE Modul für Ethernet Shield

Helmuth

Wenn man es mit FastLED Bordmitteln machen will, dann mal diesen Bereich in colorutils.h anschauen:
Code: [Select]

// Pixel blending
//
// blend - computes a new color blended some fraction of the way
//         between two other colors.
CRGB  blend( const CRGB& p1, const CRGB& p2, fract8 amountOfP2 );

CHSV  blend( const CHSV& p1, const CHSV& p2, fract8 amountOfP2,
            TGradientDirectionCode directionCode = SHORTEST_HUES );

// blend - computes a new color blended array of colors, each
//         a given fraction of the way between corresponding
//         elements of two source arrays of colors.
//         Useful for blending palettes.
CRGB* blend( const CRGB* src1, const CRGB* src2, CRGB* dest,
             uint16_t count, fract8 amountOfsrc2 );

CHSV* blend( const CHSV* src1, const CHSV* src2, CHSV* dest,
            uint16_t count, fract8 amountOfsrc2,
            TGradientDirectionCode directionCode = SHORTEST_HUES );

// nblend - destructively modifies one color, blending
//          in a given fraction of an overlay color
CRGB& nblend( CRGB& existing, const CRGB& overlay, fract8 amountOfOverlay );

CHSV& nblend( CHSV& existing, const CHSV& overlay, fract8 amountOfOverlay,
             TGradientDirectionCode directionCode = SHORTEST_HUES );

// nblend - destructively blends a given fraction of
//          a new color array into an existing color array
void  nblend( CRGB* existing, CRGB* overlay, uint16_t count, fract8 amountOfOverlay);

void  nblend( CHSV* existing, CHSV* overlay, uint16_t count, fract8 amountOfOverlay,
             TGradientDirectionCode directionCode = SHORTEST_HUES);


Wenn man es "von Hand" machen will, dann hiermit:
Code: [Select]

// Reduce color to 75% (192/256ths) of its previous value
// eventually fading to full black
  leds[i].nscale8( 192);


Also 2 CRGBs: animation1 und animation2

animation1 berechnen
animation2 berechnen

runterskalieren:
Code: [Select]
animation1[i].nscale8(ratio);
animation2[i].nscale8(255-ratio);

leds[i] = animation1[i] + animation2[i];



Wenn man jetzt ratio auf 0 setzt, sieht man nur animation2
Bei 255 nur animation 1
Bei 127 ist es eine 50%+50% Mischung.

P.S.: Die beiden Skalierungsfaktoren (ratio und 255-ratio) MÜSSEN in der Summe <=255 sein, sonst Chaos. Man kann auch 3 oder mehr Animationen zusammenrechnen, Hauptsache am Ende bleiben die RGB Werte <=255. Nichts überlaufen lassen.

Voila - ein Videocrossfade.

Verständlich?

Gruß,

Helmuth

Chris72622

Lass es sich etwas bei mir setzen.. hab grad extrem viel um die Ohren.

Ich meld mich an dieser Stelle, sobald ich mit meinen bestellten Streifen das von Dir Beschriebene endlich ausprobieren kann! :)

Bis dahin zunächst (wieder) mal vielen Dank!

Gruß Chris
Suche PoE Modul für Ethernet Shield

Chris72622

Besteht der Unterschied zwischen blend und nblend darin, dass bei nblend in ein bestehendes Array geschrieben wird, während blend das Ergebnis in ein eigenständiges Array schreibt?

Wenn man mehrere Pixel überblenden will, legt man die folgende Zeile z.B. dann in eine for-Schleife, oder löst man das anders?

Code: [Select]
CRGB  blend( const CRGB& p1, const CRGB& p2, fract8 amountOfP2 );

Leider kann ich nirgends im Netz verständliche Beispiele hierzu finden.  :smiley-confuse:

Gruß Chris
Suche PoE Modul für Ethernet Shield

Helmuth

Quote
Besteht der Unterschied zwischen blend und nblend darin, dass bei nblend in ein bestehendes Array geschrieben wird, während blend das Ergebnis in ein eigenständiges Array schreibt?
Genau. nblend arbeitet mit 2 arrays, wobei die Ursprungsdaten zerstört werden.

Bei blend bleiben die beiden Quellen unberührt und das Ergebnis wird extern gespeichert.
Quote
Wenn man mehrere Pixel überblenden will, legt man die folgende Zeile z.B. dann in eine for-Schleife, oder löst man das anders?
Ja, eine Schleife, welche alle LEDs abdeckt. Ich bevorzuge nicht-destruktive Varianten, wie z.B.

Code: [Select]
leds[i] =  blend( animation1[i], animation2[i], byte amountOFanimation2 );

Gruß,

Helmuth

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