C: LED-Fading; Licht flackert

[Johannes (menschenskind)]

Hallo,

Es geht um eine eher simple Funktion: LED soll ein- und wieder ausfaden.
Zugriff auf die PWM-Werte 0..255 über ein Array mit 100 Elementen.
Das Einfaden hat funktioniert. Dann habe ich das Ausfaden noch 
integriert und den Code noch etwas optimiert aber nun hab ich das 
Problem, dass für "count"-Werte größer 49 die LED komisch flackert. Beim 
Ausfaden reagiert sie wieder normal sobald "count" kleiner 50 ist(das 
konnte ich nur durch eingrenzen der Werte in der letzten "if"-Anweisung 
herausfinden...)
Ich sitze jetzt hier bestimmt schon 1,5h dran, aber kriege das nicht 
gelöst.
Bitte helft mir.

Hannes

(Dieser Code ist Teil einer separaten c-Datei und wird aus der main 
)aufgerufen.

#include "includes/light_ws2812.h"
#include "includes/config.h"
#include <util/delay.h>
#include <math.h>
#include <stdlib.h>

#define PWM_MAX 255
#define RESOLUTION 50  //number of steps to increment the brightness value


struct cRGB COLORS[14];
struct cRGB LED_COLOR[1];
struct cRGB LED_COLOR_old[1]; //stores old color
struct cRGB LED_COLOR_new[1]; //stores new color

int16_t count = 0;
int16_t step = 1 ;
int16_t brightnesstable_index_red  = 0;
int16_t brightnesstable_index_green = 0;
int16_t brightnesstable_index_blue  = 0;
int16_t brightness_step_red    = 0;
int16_t brightness_step_green  = 0;
int16_t brightness_step_blue  = 0;

int16_t pwm_difference_red    = 0;
int16_t pwm_difference_green  = 0;
int16_t pwm_difference_blue    = 0;

uint8_t brightnesstable [100]={
0,0,0,0,0,1,1,1,1,2,
2,2,3,3,4,5,5,6,7,7,
8,9,10,11,12,13,14,15,17,18,
19,21,22,24,25,27,29,30,32,34,
36,38,40,42,44,46,48,51,53,55,
58,60,63,66,68,71,74,77,80,83,
86,89,92,96,99,102,106,109,113,116,
120,124,128,131,135,139,143,148,152,156,
160,165,169,174,178,183,188,192,197,202,
207,212,217,223,228,233,238,244,249,255
};

void initColors(void){
  COLORS[0].r=0;      COLORS[0].g=0;      COLORS[0].b=0; // black/dark
  COLORS[1].r=PWM_MAX;  COLORS[1].g=0;      COLORS[1].b=0; // red
  COLORS[2].r=PWM_MAX;  COLORS[2].g=1+PWM_MAX/2;  COLORS[2].b=0; // orange
  COLORS[3].r=PWM_MAX;  COLORS[3].g=PWM_MAX;  COLORS[3].b=0; // yellow
  COLORS[4].r=1+PWM_MAX/2;  COLORS[4].g=PWM_MAX;  COLORS[4].b=0; // green-yellow
  COLORS[5].r=0;      COLORS[5].g=PWM_MAX;  COLORS[5].b=0; // green
  COLORS[6].r=0;      COLORS[6].g=PWM_MAX;  COLORS[6].b=1+PWM_MAX/2; // mint-green
  COLORS[7].r=0;      COLORS[7].g=PWM_MAX;  COLORS[7].b=PWM_MAX; // turquois
  COLORS[8].r=0;      COLORS[8].g=1+PWM_MAX/2;  COLORS[8].b=PWM_MAX; // light blue
  COLORS[9].r=0;      COLORS[9].g=0;      COLORS[9].b=PWM_MAX; // blue
  COLORS[10].r=1+PWM_MAX/2;COLORS[10].g=0;  COLORS[10].b=PWM_MAX; // violet
  COLORS[11].r=PWM_MAX;  COLORS[11].g=0;      COLORS[11].b=PWM_MAX; // pink
  COLORS[12].r=PWM_MAX;  COLORS[12].g=0;      COLORS[12].b=1+PWM_MAX/2; // magenta
  COLORS[13].r=PWM_MAX;  COLORS[13].g=PWM_MAX;  COLORS[13].b=PWM_MAX; // white
}

struct cRGB colorPulse(uint8_t index){
  if(count == 0){

    pwm_difference_red    = pwmDifference(LED_COLOR_new[0].r,0); // Either 0, 127.5 or 255
    pwm_difference_green  = pwmDifference(LED_COLOR_new[0].g,0); // Either 0, 127.5 or 255
    pwm_difference_blue    = pwmDifference(LED_COLOR_new[0].b,0); // Either 0, 127.5 or 255
    
    brightness_step_red    = brighnessStep(pwm_difference_red); // Speed is 0 for same, 1/2 for 127 and 1 for 255 as difference each in positive or negative direction.
    brightness_step_green  = brighnessStep(pwm_difference_green); // Speed is 0 for same, 1/2 for 127 and 1 for 255 as difference each in positive or negative direction.
    brightness_step_blue  = brighnessStep(pwm_difference_blue); // Speed is 0 for same, 1/2 for 127 and 1 for 255 as difference each in positive or negative direction.
    
    LED_COLOR_new[0] = COLORS[index];
    LED_COLOR[0] = COLORS[0]; // switch off Color
  }

  brightnesstable_index_red  += step * brightness_step_red;
  brightnesstable_index_green += step * brightness_step_green;
  brightnesstable_index_blue  += step * brightness_step_blue;
  
  LED_COLOR[0].r = brightnesstable[brightnesstable_index_red];
  LED_COLOR[0].g = brightnesstable[brightnesstable_index_green];
  LED_COLOR[0].b = brightnesstable[brightnesstable_index_blue];
  
  count += step;
  
  if( (count == 100) || (count == 0) ){
    step = -step;
  }  

  return LED_COLOR[0];
}

int16_t pwmDifference(uint8_t pwm_Value_New, uint8_t pwm_Value_Old){
  return pwm_Value_New - pwm_Value_Old;
}
uint8_t brighnessStep (uint8_t pwm_Difference){
  return  ( (100*pwm_Difference) / PWM_MAX )/RESOLUTION;
}

[B. S. (bestucki)]

Das sieht alles ein bisschen wirr aus. Du hast viele globale Variablen, 
was nicht gerade der Übersichtlichkeit zugute kommt, sogar solche, die 
von Funktionen zurückgegeben werden (z.B. LED_COLOR).

Johannes H. schrieb:
> struct cRGB LED_COLOR[1];

Es ist nicht nötig, diese Variable als Array anzulegen, die Grösse ist 
ja 1.

Johannes H. schrieb:
> LED_COLOR[0].r = brightnesstable[brightnesstable_index_red];
>   LED_COLOR[0].g = brightnesstable[brightnesstable_index_green];
>   LED_COLOR[0].b = brightnesstable[brightnesstable_index_blue];

Bist du sicher, dass die Indizes von brightnesstable alle kleiner als 
100 sind? Das wäre das erste, was ich in deinem Programm prüfen würde.

[Johannes (menschenskind)]

Hallo Stucki,
Die ws2812_setleds (Die Funktion, die die Daten an die LED sendet) 
erwartet aber einen Pointer auf ein Array. Ich hatte es schon mal so 
gemacht, wie Du sagtest, da hatte ich aber mangels C-Kenntnissen 
Probleme, dass ich das falsch übergeben habe, deswegen lasse
ich das jetzt so mit dem LED_COLOR[1].

Aber ich glaube Dein Hinweis ist die Lösung, da ich diesen 
"brightness_index" für eine LED um 1 erhöhe und bei der anderen um 2. Da 
leuchtet ein, dass der nach 50 counts schon bei 100 ist.
Warum ich das nicht selbst gesehen habe...?

Und die Werte müssen global sein, erstens, da sie auch von anderen 
Funktionen verwendet werden und 2. weil die Werte bei jedem 
Funktionsaufruf sonst neu berechnet werden müssten.

[Stefan F. (Gast)]

> 2. weil die Werte bei jedem
> Funktionsaufruf sonst neu berechnet werden müssten.

Schau Dir mal an, was "static" Variablen innerhalb von Funktionen 
machen. Könnte in deinem Fall hilfreich sein.

[Johannes (menschenskind)]

@Stefan:
Aber die Variablen werden ja auch noch in anderen Funktionen benutzt.

[B. S. (bestucki)]

Johannes H. schrieb:
> Die ws2812_setleds (Die Funktion, die die Daten an die LED sendet)
> erwartet aber einen Pointer auf ein Array. Ich hatte es schon mal so
> gemacht, wie Du sagtest, da hatte ich aber mangels C-Kenntnissen
> Probleme, dass ich das falsch übergeben habe, deswegen lasse
> ich das jetzt so mit dem LED_COLOR[1].

Dann wirst du wahrscheinlich auch die Arraygrösse übergeben müssen? Dann 
könntest du auch einfach einen Zeiger auf eine Variable übergeben und 
die Grösse auf 1 setzen, macht keinen Unterschied.

Johannes H. schrieb:
> Und die Werte müssen global sein, erstens, da sie auch von anderen
> Funktionen verwendet werden und 2. weil die Werte bei jedem
> Funktionsaufruf sonst neu berechnet werden müssten.

Könnte man bestimmt anders machen, ausser die Werte werden in einem 
Interrupt benötigt. Bei globalen Variablen läuft man immer in die 
Gefahr, dass viele verstreute Funktionen darauf zugreifen und man im 
Fehlerfall nicht nachvollziehen kann, welche Funktion nun den falschen 
Wert geschrieben hat.

[Peter D. (peda)]

Warum legst Du COLORS[14] nicht im Flash an, sondern umständlich zur 
Laufzeit?
Warum muß ein Index auf 100 Werte 16-bittig sein?
Wie wird gesichert, daß der Index innerhalb 0..99 liegt?

[TM (Gast)]

Johannes H. schrieb:
> @Stefan:
> Aber die Variablen werden ja auch noch in anderen Funktionen benutzt.

Ja dann werden sie oder pointer auf diese Variablen im Funktionsaufruf 
mit übergeben. So ist das nur ein Haufen unübersichtlicher Mist. Sorry.