Logarithmische Berechnung der LED Helligkeit

[Stefan (Gast)]

Habe ein kleines Problem mit dem Fading 3er LEDs auf einem WS2812 Strip. 
Die 3 Leds sollen einen Sekundenzeiger anzeigen. Jedoch hackeln die LEDs 
noch ein bisschen.
Grund ist die lineare Berechnung der Helligkeit (-> Berechnung Fading).

Wie sieht die logarithmische Berechung genau aus? Mit einem Array möchte 
ich ungern arbeiten, da die Zeit vom loop abhängig ist. Soll heißen, der 
loop braucht z.B. einmal 20ms und das nächste mal 30ms. Das würde 
bedeuten das innerhalb einer Sekunde mir die letzen Werte eines Arrays 
nicht zur Verfügung stehen.

Zum Einsatz kommt ein Arduino Pro Mini 328P. Der Arduino ist nur für die 
Anzeige einer Uhr zuständig. (Stunden, Minuten und Sekundenzeiger).

static byte sAlt;
unsigned long aZeit = millis();
static unsigned long vZeit;
static unsigned long dZeit;

if(s != sAlt) {
  vZeit = aZeit;
  sAlt = s;
}

// Vergangene Zeit seit der letzen Sekundenänderung
dZeit = aZeit - vZeit;
// Berechnung des Fadings
float x = 255-(255*dZeit/1000);
float y = 255;
float z = 255*dZeit/1000;
    
leds[s].b = x;
leds[s+1].b = y;
leds[s+2].b = z;

[Jörg E. (jackfritt)]

http://www.mikrocontroller.net/articles/LED-Fading
?? Da steht ne formel

[Ralf (Gast)]

Neben dem bereits genannten Artikel hab ich es folgendermaßen berechnet 
und war recht zufrieden:
k = n^(1/m), wobei n die maximale (PWM-)Stufe ist und m die Anzahl der 
Schritte. k ergibt einen Faktor, mit dem multipliziert wird.

Beispiel mit n = 255 und m = 10:
Schritt 0: 0
Schritt 1: k -> 1,7404198105
Schritt 2: (Schritt 1) * k -> 3,0290611167
...
Schritt 10: (Schritt 9) * k -> 255

Ob das nun der Formel aus dem Artikel entspricht bezweifle ich, mir hat 
es jedenfalls für meine Anwendung gereicht...

Ralf

[Stefan (Gast)]

Den Artikel hatte ich schon gesehen(wird man ja tausendfach von Google 
drauf weitergeleitet ;)). Hab davon heute mittag mit der Tabelle 
gearbeitet. Da trat aber dann das Problem auf, das wenn die loopTime mal 
um ein paar ms verspringt, nicht mehr alle Werte des daraus erzeugten 
Wertes angesprochen wurden.

@Ralf, ich werde mal schaun ob ich das entsprechend anpassen kann für 
meine Aufgabe. Danke schon mal.

[holger (Gast)]

>Hab davon heute mittag mit der Tabelle
>gearbeitet. Da trat aber dann das Problem auf, das wenn die loopTime mal
>um ein paar ms verspringt, nicht mehr alle Werte des daraus erzeugten
>Wertes angesprochen wurden.

Dann zeig mal deinen Code dazu.

Mit deinem float Geraffel gewinnst du jedenfalls keinen
Blumentopf oder einen Zeitvorteil gegenüber einer Tabelle;)

[Konrad S. (maybee)]

Immer wieder gerne von mir empfohlen:
http://www.zabex.de/site/sofabeleuchtung.html

[Stefan (Gast)]

Das hier ist vorerst mein derzeitiger Sketch. Im Endeffekt soll hier ein 
sauberer Überlauf der Sekunden geschehen. Das heißt, man soll den 
"Ausschlag" des Sekundenzeigers nicht sehen.
leds[s] fadet runter
leds[s+1] fadet hoch und wieder runter // oder aber konstant 255 wenn es 
flüssig aussieht mit s und s+2
leds[s+2] fadet hoch

Habe derzeit nur einen WS2812 Strip mit insgesamt 15 RGB Leds im 
Einsatz. Der Fade sieht für mich noch nicht so prickelnd aus. Derzeit 
handelt es sich um die RGB Stips mit 60Leds/m. Im richtigen Prototypen 
kommen 60 zum ein Einsatz mit 144Leds/m. Somit werden vermutlich die 
Übergänge automatisch weicher. Ich lasse mich aber eines besseren 
belehren.

// RTC
#include <DS3232RTC.h>
#include <Time.h>
#include <Wire.h>

// F-Makro
#include <Streaming.h>

// LED Strip
#include <FastSPI_LED2.h>
#define NUM_LEDS 60
#define DATA_PIN 4
CRGB leds[NUM_LEDS];

// Ausgabe Debug Serial Monitor
byte debug = 3;
unsigned long lZeit = 0;


void setup() {
  Serial.begin(115200);

  // RTC Zeit setzen - zum testen!
  time_t t;
  tmElements_t tm;
  tm.Year = 2000;
  tm.Month = 1;
  tm.Day = 1;
  tm.Hour = 0;
  tm.Minute = 3;
  tm.Second = 0;
  t = makeTime(tm);
  RTC.write(tm);
  setTime(t);

  // LED Strip
  FastLED.addLeds<WS2812, DATA_PIN, RGB>(leds, NUM_LEDS);
}


void loop() {
  // Erfassung der loopZeit
  unsigned long aZeit = millis();

  // Aktivieren des Debuggers über den Serial Monitor
  if(Serial.available()) debug = Serial.parseInt();

  // Alle LEDs löschen
  for(int x = 0; x < 60; x++) leds[x] = CRGB(0,0,0);

  // RTC
  tmElements_t tm;
  RTC.read(tm);
  byte h = tm.Hour * 5;
  byte m = tm.Minute;
  byte s = tm.Second;

  rtcSekunden(s);
  FastLED.show();

  // Erfassung der loopZeit
  lZeit = millis() - aZeit;
  if(debug == 0) {
    Serial << F("lZeit : ") << dig2(lZeit) << endl;
  }
}

void rtcSekunden(byte s) {
  byte ledArray[] = {
    59, 0,1,2,3,4,5,6,7,8,9,10,
    11,12,13,14,15,16,17,18,19,20,
    21,22,23,24,25,26,27,28,29,30,
    31,32,33,34,35,36,37,38,39,40,
    41,42,43,44,45,46,47,48,49,50,
    51,52,53,54,55,56,57,58,59, 0
  };

  byte pwmFadeX[] = {
    69,66,64,61,59,57,54,52,50,48,
    46,44,43,41,39,38,36,35,34,32,
    31,30,29,28,26,25,24,23,23,22,
    21,20
  };
  
  byte pwmFadeY[] = {
    74,81,88,95,103,112,122,132,144,156,
    169,184,199,216,235,255,255,235,216,199,
    184,169,156,144,132,122,112,103,95,
    88,81,74
  };

  byte pwmFadeZ[] = {
    20,21,22,23,23,24,25,26,28,29,
    30,31,32,34,35,36,38,39,41,43,
    44,46,48,50,52,54,57,59,61,64,
    66,69  
  };

  // Vergangene Zeit seit der letzen Sekundenänderung
  static byte sAlt;
  unsigned long aZeit = millis();
  static unsigned long vZeit;
  static unsigned long dZeit;
  if(s != sAlt) {
    vZeit = aZeit;
    sAlt = s;
  }
  dZeit = aZeit - vZeit;

  // Berechnung des Fadings
  byte i = dZeit/31.25;
  if(i >= 32 ) i = 31;

  // 10 Schritte/Sekunde
  byte x = pwmFadeX[i];
  byte y = pwmFadeY[i];
  byte z = pwmFadeZ[i];

  // Zuweisung
  leds[ledArray[s]].b = x;
  leds[ledArray[s+1]].b = y;
  leds[ledArray[s+2]].b = z;

  // Debuginfo
  if(debug == 3) {
    Serial << F("s : ") << dig2(s);
    Serial << F("   i : ") << dig3(i);
    Serial << F("   leds[0] : ") << dig3(x);
    Serial << F("   leds[1] : ") << dig3(y);
    Serial << F("   leds[2] : ") << dig3(z);
    Serial << F("   lZeit : ") << dig2(lZeit);
    Serial << endl;
  }
}

// 2 stellige Ausgabe von Zahlen
byte dig2(byte i) {
  if(i < 10) Serial << " ";
  return i;
}

// 3 stellige Ausgabe von Zahlen
byte dig3(byte i) {
  if(i < 10) Serial << " ";
  if(i < 100) Serial << " ";
  return i;
}