LEDs flackern beim Umschalten (PCA9685)

Hallo zusammen,

ich bin derzeit am Basteln mit einem RGB-LED-Stripe (12V) und habe mir eine Schaltung mit dem >Adafruit 16-Channel 12-bit PWM/Servo Driver - I2C interface - PCA9685< und drei BUZ11-MOSFETs zur Steuerung der Farben aufgebaut.
Das funktioniert auch ganz gut. Leider kommt es beim Umschalten der PWM-Stufen immer wieder zum Flackern der LEDs was sehr störend ist. Schließlich sollten 12bit-Auflösung ja einen schönen, “stufenfreien” Dimmprozess ermöglichen. :wink:

Hat mit jemand einen Tipp wie ich das Flackern los werden kann??

Schon mal Danke im Voraus!

Viele Grüße
calim

PS: Ich verwende das Adafruit Library.

Sketch? Versuchsaufbau? Verwendetes Netzteil etc. nachreichen.

Hallo,

so, jetzt komme ich endlich wieder zu was. Und hatte die Gelegenheit mich in ein Layout-Programm einzuarbeiten. Daher hier der Schaltplan meines Aufbaus (s. Anhang). Bei den Anschlüssen K1-K4 handelt es sich um die PWM-Ausgänge 0-3.

Bei dem verwendeten Treiber handelt es sich um: Overview | Adafruit PCA9685 16-Channel Servo Driver | Adafruit Learning System

Das verwendete Library gibt es unter: Using the Adafruit Library | Adafruit PCA9685 16-Channel Servo Driver | Adafruit Learning System

Das verwendete Netzteil ist ein 12V Schaltnetzteil (aus der Bucht) mit der Typenbezeichnung HR-091210A; 100-240V 50/60 Hz Ausgang: 12V= 10A.

Als Leuchtmittel habe ich Sripes mit SMD5536 (Kalt- und Warmweiß), insgesamt 4 Streifen á 42 LEDs und einen RGB-Stripe mit SMD5050 mit 19 LEDs. Alles Wasserdicht.

Der angeschlossene Arduino (Nano), und damit auch der I2C-Bus, wird über ein separates 1500mA Netzteil versorgt. Am Treiber (V+) ist keine separate Versorgungsspannung angelegt.

Hier noch der Sketch:

#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>//LED-PWM
#include <avr/pgmspace.h>

PROGMEM uint16_t const exptable12[24]  = {2107,2168,2232,2297,2365,2434,2505,2579,2654,2732,2812,2895,2980,3067,3157,3249,3345,3443,3544,3648,3755,3865,3978,4095};//LED-PWM
//uint16_t const exptable4[16] PROGMEM = {133, 139, 145, 151, 158, 165, 172, 180, 188, 196, 205, 214, 224, 234, 244, 255}; //von http://www.mikrocontroller.net/articles/Diskussion:LED-Fading

uint16_t Red=0;
uint16_t Green=0;
uint16_t Blue=0;
uint16_t White=0;
uint16_t Red2=0;
uint16_t Green2=0;
uint16_t Blue2=0;
uint16_t White2=0;
int runde=1;
int counter=0;

// called this way, it uses the default address 0x40
Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver();
// you can also call it with a different address you want
//Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver(0x41);

void setup() {
  Serial.begin(9600);
    // Initialisiere I2C  
  Wire.begin();  
  //LED-PWM
  pwm.begin();
  pwm.setPWMFreq(1600);  // PWM-Frequenz; max 1600
                         //ob das sein muss??
  // save I2C bitrate
  uint8_t twbrbackup = TWBR;
  // must be changed after calling Wire.begin() (inside pwm.begin())
  TWBR = 12; // upgrade to 400KHz!
  
  //LEDs ausschalten (Ausgangszustand)
  for(int i=0;i<3;i++){ 
  pwm.setPWM(i, 0, 4096 );
  }
}

void loop() {
  
  Red2=expvalue12(Red/3)-1;
  pwm.setPWM(0, 0, Red2 );
  Green2=expvalue12(Green/3)-1;
  pwm.setPWM(1, 0, Green2 );
  Blue2=expvalue12(Blue/3)-1;
  pwm.setPWM(2, 0, Blue2 );
  White2=expvalue12(White/3)-1;
  pwm.setPWM(3, 0, White2 );
  
  //Kontrollausgabe
  Serial.print("R=");Serial.print(runde);Serial.print(";");Serial.print("C=");Serial.print(counter);Serial.print(";");Serial.print("R=");Serial.print(Red2);Serial.print(";");
  Serial.print("G=");Serial.print(Green2);Serial.print(";");Serial.print("B=");Serial.print(Blue2);Serial.print(";");Serial.print("W=");Serial.print(White2);Serial.println(";");

  delay(100);
  
  //Sonnenaufgang
  if (counter>286) {counter=0; runde++;}
  if (runde>8) {runde--;}
  
  if (runde==1){Blue=Blue+3;};//Mondschein
  if (runde==2){Red=Red+3;Blue=Blue-2;};//->Rot
  if (runde==3){Blue=Blue-1;};//->Rot
  if (runde==4){Green=Green+2;};//->Gelb
  if (runde==5){Blue=Blue+3;Green++;};//->Weiß
  if (runde==6){White=White+3;};//->Hauptlicht
  if (runde==7){Blue=Blue-3;Red=Red-3;Green=Green-3;};//->RGB-Stripe aus
  if (runde==8){int i=1;while(i==1){delay(1000);}};
 
  counter++;
}

//Licht-PWM-Steuerung//

uint16_t expvalue12( const uint16_t linear ) {/* Returns the exponential value (approx. 1.0443^x). *
 * argument: 11 bit unsigned (0..2048)  return: 12 bit unsigned (1..4096)       */
 // look up exponential
 //uint16_t timp = pgm_read_word(&exptable12[ 1 ]);
 uint16_t exp = pgm_read_word(&exptable12[ linear % 24 ]); //Serial.print(Blue2); Serial.print(";");Serial.print(exp); Serial.print(";");Serial.println(exp >> (11 - linear / 24));
 // scale magnitude
 return exp >> (11 - linear / 24);//289Stufen

}

//uint8_t expvalue7( const uint8_t linear ) {/* Returns the exponential value (approx. 1.0443^x). * //von http://www.mikrocontroller.net/articles/Diskussion:LED-Fading
//
// * argument: 7 bit unsigned (0..127)  return: 8 bit unsigned (1..255)       */
// // look up exponential
// uint8_t exp = pgm_read_byte(&exptable4[ linear % 16 ]); Serial.print(Blue); Serial.print(";");Serial.print(exp); Serial.print(";");Serial.println(exp >> (7 - linear / 16));
// // scale magnitude
// return exp >> (7 - linear / 16);
//
//}

Ich habe alles vor dem Posten noch einmal überprüft (Lötstellen, Steckverbinder usw.) und getestet (100ms und 1s Intervalle beim Schalten der PWM-Stufen). Leider flackert es auch jetzt noch immer wieder (für Sekundenbruchteile), gleich welche Farbe/Weiß angesteuert wird. Es scheinen auch alle Farben gleichzeitig zu flackern. Ein Muster bezüglich bestimmter PWM-Schritte o.ä. habe ich nicht entdecken können.

Danke für jedwede Hinweise zu meinem Problem!

Viele Grüße
calim

Die N-Kanal-MOSFETs (bei korrektem Typ) müssen am PWM-Ausgang nicht mehr nach Masse gezogen werden (bei Dir ist ein Pull-up nach 12V eingetragen, das dürfte den PCA9865 braten, ist evtl. schon geschehen, wenn Du wirklich so verbunden hast). Welche FETs setzt Du denn ein? Am PCA9865 müssten es schon Logic-Level-FETs sein, sonst kriegst Du keinen korrekten Schaltpunkt.

Hallo pylon,

ich habe meine Schaltung nochmals überprüft. Der der gepostete Plan ist korrekt. Dir MOSFETs werden von den Pull-Ups am Gate nach +12V gezogen. Es sind wie geschrieben MOSFETs vom Typ BUZ11. Die Schaltung funktioniert ja auch, nur flackert es immer wieder. (Hatte jetzt aber mal einen Durchgang ohne Flackern gesehen.

Ich werde mir auf jeden Fall mal Logic-Level-MOSFETs zulegen und die Schaltung nochmals neu aufbauen. Vielleicht erledigt sich das Problem dadurch. Meine Vermutung, nach einigem Suchen im Netz war, dass eventuell der PCA9865 sobald er neue Werte über I2C bekommt die Ausgänge kurzzeitig abschaltet.

Danke für die Tipps!

Viele Grüße calim

PS: Ich habe die BUZ11 auch, in einer anderen Schaltung, auf die selbe Weise mit den Pull-Ups direkt am Arduino laufen und dort flackert nichts.

Ich bin auch der Meinung das der Widerstand gegen 12V keine besonders gute Idee ist.

Der Ausgang des PCA9865 kann 5V oder 0V Level haben, bei 0V schaltet sperrt dein MOSFET. Bei 5V MOSFET schaltet zwar durch und das ganze funktioniert

In beiden Fällen fließt ein Strom von der 12V Leitung über den Widerstand in den Pin des PCA9865 das kann nicht gut sein.

Ich würde N-Kanal Logic-Level-MOSFET nehmen und dann kannst den Widerstand weglassen.

Hallo,

ich hab mir jetzt ein paar IRLZ 34N bestellt. Laut mikrocontroller.net ist das ein logic-level MOSFET, sollte also gehen. Danke für die Tipps, man lernt nie aus.

Das mit dem Widerstand auf 12V war der Tipp eines befreundeten Elektronikers. Der hatte bedenken, dass der BUZ11 bei 5V nicht voll auf macht und meinte durch den Widerstand wäre der Strom durch den Treiber auch klein genug damit nichts passiert.

Sollte ich eigentlich zwischen Treiber und MOSFET noch einen Widerstand klemmen? Auf dem Datenblatt der IRLZ ist im Testaufbau einer eingezeichnet.

Danke und viele Grüße calim

~~~Freu' mich auf die Weihnachtsbastellieferung! :-D ~~~