HL1606 LED Streifen Hintergrundbeleuchtung machbar?

ich habe noch HL1606 Streifen übrig. Wollte die gerne hinter dem Plasma Fernseher as Hintergrundbeleuchtung anbringen.

Hat jemand so etwas schon ma gemacht.

Welche Adruino Platine brauche ich dafür und hat jemand ein Programm dafür.

Vielen Dank.

Hatte die bisher in einer Wortuhr verbaut gehabt mit einer HUPO Platine. Bin aber nun auf einen anderen LED Streifen ausgewichen, da der mehr Möglichkeiten bietet.

Die HL1606 wird von der FastLED-Bibliothek angesteuert. Du brauchst einen x-beliebigen Arduino.

Grüße Uwe

OK danke schön. Dann muss ich nur noch schauen wie man ein Programm dafür schreibt, damit ich die gewünschte Beleuchtung habe.. Das ist noch Neuland für mich.

Hmm bekomme es leider nicht hin. Die LED Streifen sollen sich nur einschalten und etwas dimmen

Die HL1606 wird von der FastLED-Bibliothek angesteuert.

Dem muss ich widersprechen. Dieser Chipsatz wird bereits seit FastSPI_LED2 nicht mehr unterstuetzt.

Aus einer alten Ankuendigung fuer FastSPI_LED2:

New users should begin using FastSPI_LED2, as it is now ready/mature for use. The first version of the library will be left around for people who need to use hl1606/lpd6803.

Man braucht also die antike FastSPI_LED Library.

@reimunko: Zeig mal den Code, den Du bisher geschrieben hast. Falls Du es ueberhaupt nicht hinbekommst, mit den 1606 zu sprechen, dann frag in der FastLED Community nach.

Gruesse,

Helmuth

UPS, Entschuldigung für die Falschinformation. Grüße Uwe

Nachtrag: Alternativ gibt es auch eine Adafruit lib und ein Tutorial fuer diesen Chip.

Ich schreibe das, weil ich damals - bei meinen ersten Schritten - an diesem Chip fast verzweifelt bin.

Und FastSPI_LED ist fuer Anfaenger ziemlich schwer zu durchschauen.

Gruesse in die Runde,

H.

Danke für die Hilfe.

Die DEmos funktionieren. Aber ich selber bekomme es einfach nicht hin.

Möchte nur dass die Led Streifen in WEiss oder blau angehen. Diese soll hinter dem Fernseher als Hintergrund dienen.

Kann mir da einer einen Code basteln ?

Wie sieht dein Aufbau nun genau aus? Schaltplan!

Der Code kann nicht so schwer sein. Geht doch lediglich um 3 PWM Ausgänge die beschrieben werden müssen. Schau dir mal die Tutorials an.

Geht doch lediglich um 3 PWM Ausgänge die beschrieben werden müssen.

Sagt mal, wollt ihr mich trollen? Hier muss ich erneut widersprechen. Es handelt sich um via SPI einzeln ansteuerbare LEDs.

Alle in einer Farbe leuchten zu lassen, ist aber wirklich nicht das grosse Ding. Fuer welche Lib hast Du Dich entschieden? Zeig mal den Demosketch, der funktioniert. Von dem ausgehend sollte die Aenderung Deinem Wunsch entsprechend easy sein.

Gruss,

Helmuth

Ich habe den HL1606stripPWM genommen
das ist der einzige, der auf Anhieb lieb

Die Pulsepde sieht so aus.

Braucht ihr noch etwas ?
Die hl1606strippwm.h Datei.

// Example code for fast-PWM control of HL1606 LEDs
// public domain, enjoy!

#include “HL1606stripPWM.h”
// This library uses Timer 2 for PWM counting and 3 * numLEDs bytes of RAM
// and Arduino pins 11 & 13 (Mega, 51 & 52)

// First value passed is how many LEDs are in your HL1606 strand
// fewer LEDs means less work
// This library uses hardware SPI so pins 11 and 13 are used
// for Data and Clock output (for the Mega, pins 51 and 52)
// The latch pin (L) can be any pin but pin 10 (Arduino) or 53 (Mega)
// MUST BE AN OUTPUT!
int latchPin = 10;
HL1606stripPWM strip = HL1606stripPWM(32, latchPin);

void setup() {
Serial.begin(9600);
Serial.println(“hello!”);

// You can customize/control the pulse width modulation and color
// resolution by setting how many bits of PWM you want per LED
// For example, 3 bits is 8 different PWM values per LED and 9 bits, 512
// values for full color. 4 bits is 16 PWM per LED, 12 bit color with
// 4096 different colors available.
// Increasing the PWMbits by 1 means you need TWICE as much CPU !!!
// We suggest starting with 3 and tweaking the other variables to get
// the fastest SPI and maximum CPU. Then try upping this to 4. For short
// strips (like 1 meter) that are ok with SPIdiv of 16, you can try 5
strip.setPWMbits(3);

// We use the built-in hardware SPI module. We can change the speed
// of the module to push data out faster. In theory, HL1606’s should work with
// the SPI divider set to 16 but we found that this makes some strips
// spaz out. Start with 32 and once it works try reducing it to 16
// If you’re lucky, you can even try 8
// Valid divider values are: 2, 4, 8, 16, 32, 64, and 128, dont try others!
strip.setSPIdivider(32);

// all the hard work of running the strip is done in an interrupt
// we can configure the interrupt so that we spend more or less
// time running the strip, letting you do other stuff like sensors
// or an LED or whatever. Set it between 0 and 100, where 100 means
// higher quality colorstrip display but no time for anything else.
strip.setCPUmax(70); // 70% is what we start at

// For Arduinos, pin 10 MUST be an output before you begin!
// (if using a Mega, pin 53 must be an output (instead of 10) )
// We suggest using pin 10 for the latchPin
strip.begin();

// print out what the timing is (for debugging)
double time = strip.numLEDs(); // each LED
time *= 8; // 8 bits of data for each LED;
time *= strip.getSPIdivider(); // larger dividers = more time per bit
time *= 1000; // time in milliseconds
time /= F_CPU; // multiplied by how long it takes for one instruction (nverse of cpu)

Serial.print(“Time per LED strip write: “);
Serial.print(time); Serial.println(” millis”);

time *= 100;
time /= strip.getCPUmax();

Serial.print(“Time allowed per interrupt “);
Serial.print(time);
Serial.println(” millis”);

// get that in Hz
time = 1000 / time;
Serial.print(“Interrupt freq: “);
Serial.print(time);
Serial.println(” Hz”);

// Now find the final ‘color cycle’ frequency
Serial.print(“Color cycle freq: “);
Serial.print(time / (1 << strip.getPWMbits()));
Serial.println(” Hz”);
// Try to keep the color frequency above 60 Hz (flickery). 100 Hz or higher looks good to most people

}

// make an oval pulse where the center is bright and the
// edges are dimmer
void createPulse(int8_t n, uint8_t r, uint8_t g, uint8_t b) {
strip.setLEDcolorPWM(n, r, g, b);

if (n + 1 < strip.numLEDs())
strip.setLEDcolorPWM(n+1, r/8, g/8, b/8);
if (n - 1 >= 0)
strip.setLEDcolorPWM(n-1, r/8, g/8, b/8);

if (n + 2 < strip.numLEDs())
strip.setLEDcolorPWM(n+2, r/64, g/64, b/64);
if (n - 2 >= 0)
strip.setLEDcolorPWM(n-2, r/64, g/64, b/64);
}

// blank out every pixel by setting it to 0
void clearStrip() {
uint8_t i;

for (i=0; i<strip.numLEDs(); i++) {
strip.setLEDcolorPWM(i, 0, 0, 0);
}
}

uint8_t j=0;
void loop() {

// create a tealish pulse
clearStrip();
// Red, Green, Blue
createPulse(j, 0, 128, 255);

// move the pulse up one pixel
j++;
// and wrap around the strip
if (j > strip.numLEDs()) {
j = 0;
}
delay(40);
}

https://learn.adafruit.com/hl1606-led-strip/advanced-usage

So habe ich den Streifen angeschlossen

Ok, dann nimm den gleichen Sketch, aber aendere den Loop am Ende, wie folgt:

void loop() {
  for (byte i = 0; i < strip.numLEDs(); i++) {
    strip.setLEDcolorPWM(i, 0, 0, 128);
  } 
}

Ich wuerde erwarten, dass jetzt alle Leds mit halber Helligkeit blau leuchten. Ist das so?

Gruss,

Helmuth

Nein, die halbe Helligkeit ist OK , aber die Farbe ist hellgrün und es flackert, also eher ein Pulse, keine konstante Helligkeit.

Wie stelle ich denn die Helligkeit ein ?

Ist auch ein Ambilight machbar?

Hellguenes flackern?! Grrr.

Ok, einen Schritt zurueck. Du hast geschrieben:

Die DEmos funktionieren.

Gut. Beschreib´ mal bitte konkret, welcher Sketch zu welchem Ergebnis gefuehrt hat.

Zu dem von Dir geposteten Sketch: Probier mal aus, diesen Teil

for (byte i = 0; i < strip.numLEDs(); i++) {
    strip.setLEDcolorPWM(i, 0, 0, 128);
  }

an das Ende vom setup Teil zu schreiben und lass loop leer. Was passiert dann?

Habe den COde eingebunden und den Loop leergelassen. Es bleibt alles dunkel.

Habe auch ein Projekt Afterglow gefunden.Dort ist auch der HL1606 definiert.

Allerdings funktioniert dies leider nicht.

Das ist merkwuerdig.

Die DEmos funktionieren.

Gut. Beschreib´ mal bitte konkret, welcher Sketch zu welchem Ergebnis gefuehrt hat.