Hallo zusammen,
Also ich blicke das ganze mit den Neopixel einfach nicht.
Ich versuche in einem Streifen von 4 Pixeln die erste weiss aufleuchten und leicht flackern zu lassen. Dann sollen ein bischen verzögert die anderen drei in blau aufleuchten und flackern. Gefolgt von einem aufleuchten über rot nach gelbweis wieder zurück nach blau. Die erste soll in der ganzen zeit so bleiben
Lg Holger
Wollst du den fertigen Sketch? 
Poste deinen Ansatz und man kann dir sagen, woran es liegt.
Wenn jemand nen fertigen Sketch hätte wäre das super ich bekomme nicht mal den Ansatz hin... =(
Dann liegt das Problem darin, dass du bislang auch nicht wirklich die Arduino Basics verstanden hast. Das Forum dient in erste Linie Leuten zu helfen. Jedoch sollte auch hier immer eine Eigeninitiative erfolgen. Arbeite dich durch die Tutorial. Auch Adafruit hat ordentliche Tutorials für die Nutzung der Neopixel.
alles klar bei folgenden Sketch geht zwar der erste Pixel an, der rest bleibt dunkel. Außerdem hat der 1 Pixel die falsche farbe....
#include <Adafruit_NeoPixel.h>
#include <avr/pgmspace.h>
#define PIN 2
#define LED_QUANTITY 4
Adafruit_NeoPixel strip = Adafruit_NeoPixel(LED_QUANTITY, PIN, NEO_GRB + NEO_KHZ800);
//store the led values for fading
struct led{
byte hue;
byte sat;
byte light;
};
//load the sequence into PROGMEM because otherwise it overloads RAM
const byte ledSeq [16][LED_QUANTITY][3] PROGMEM = {
{{0x41, 0x81, 0x80},{0x00, 0x00, 0x00},{0x00, 0x00, 0x00},{0x00, 0x00, 0x00}},
{{0x2C, 0xE6, 0xEC},{0x00, 0x00, 0x00},{0x00, 0x00, 0x00},{0x00, 0x00, 0x00}},
{{0x01, 0xE6, 0xEC},{0x00, 0x12, 0x0E},{0x01, 0xE6, 0xEC},{0x01, 0xE6, 0xEC}},
{{0x00, 0x00, 0xFA},{0x06, 0xF5, 0xF2},{0x06, 0xF5, 0xF2},{0x06, 0xF5, 0xF2}},
{{0x00, 0x00, 0xFA},{0x10, 0xF5, 0xF2},{0x10, 0xF5, 0xF2},{0x10, 0xF5, 0xF2}},
{{0x18, 0x0A, 0xAC},{0x1F, 0xF5, 0xF2},{0x1F, 0xF5, 0xF2},{0x1F, 0xF5, 0xF2}},
{{0x00, 0x00, 0xFA},{0x27, 0xF5, 0xF2},{0x27, 0xF5, 0xF2},{0x27, 0xF5, 0xF2}},
{{0x18, 0x0A, 0xAC},{0x27, 0x7C, 0xEE},{0x27, 0x7C, 0xEE},{0x27, 0x7C, 0xEE}},
{{0x00, 0x00, 0xFA},{0x83, 0x7C, 0xEE},{0x83, 0x7C, 0xEE},{0x83, 0x7C, 0xEE}},
{{0x18, 0x0A, 0xAC},{0x9D, 0xF9, 0xD7},{0x9D, 0xF9, 0xD7},{0x9D, 0xF9, 0xD7}},
{{0x00, 0x00, 0xFA},{0x2C, 0xF9, 0xD7},{0x2C, 0xF9, 0xD7},{0x2C, 0xF9, 0xD7}},
{{0x18, 0x0A, 0xAC},{0x1B, 0xF9, 0xD7},{0x1B, 0xF9, 0xD7},{0x1B, 0xF9, 0xD7}},
{{0x00, 0x00, 0xFA},{0x03, 0xF9, 0xD7},{0x03, 0xF9, 0xD7},{0x03, 0xF9, 0xD7}},
{{0x18, 0x0A, 0xAC},{0x8B, 0xF9, 0xD7},{0x8B, 0xF9, 0xD7},{0x8B, 0xF9, 0xD7}},
{{0x00, 0x00, 0xFA},{0xA2, 0xF9, 0xD7},{0xA2, 0xF9, 0xD7},{0xA2, 0xF9, 0xD7}},
{{0x18, 0x0A, 0xAC},{0xA2, 0xF9, 0xD7},{0xA2, 0xF9, 0xD7},{0xA2, 0xF9, 0xD7}}
};
float fadefraction = .95; //adjust the fade out speed. typically .9-.99
int interval = 650; //the speed of the animation, lower is faster
//store colors for conversion from HSB
byte col[3] = {0,0,0};
//count loops
int counter = 0;
//current frame of the sequence
int frame = 0;
led myLeds[LED_QUANTITY];
void setup() {
pinMode( 3 , OUTPUT);
pinMode( 4 , OUTPUT);
pinMode( 0 , OUTPUT);
pinMode( 1 , OUTPUT);
strip.begin();
strip.show(); // Initialize all pixels to 'off'
}
void loop() {
analogWrite( 0 , HIGH );
delay( 500 );
analogWrite( 0 , LOW );
analogWrite( 1 , HIGH );
delay( 500 );
analogWrite( 1 , LOW );
analogWrite(3 , 255);
analogWrite(4 , 255);
delay( 1000 );
//step thru the sequence
if(frame < 16) {
if(counter%interval==0) {
for(int x = 0; x<LED_QUANTITY;x++) {
byte light = pgm_read_byte(&(ledSeq[frame][x][2])); //check the lightness value
if(light != 0x00) { //do not override with any black so that the fading can work
setPixelFade(x, pgm_read_byte(&(ledSeq[frame][x][0])), pgm_read_byte(&(ledSeq[frame][x][1])), light);
}
}
frame++;
}
}else{
frame=0;
}
//update the fading - you can increase the "5" for slower fading
if(counter%5==0)updateLeds();
strip.show();
counter++;
delay(1);
}
void updateLeds() {
for(int i = 0; i < LED_QUANTITY; i++) {
updateFade(i);
HSV_to_RGB(myLeds[i].hue, myLeds[i].sat, myLeds[i].light);
strip.setPixelColor(i, col[0], col[1], col[2]);
}
}
void setPixelFade(int m, byte hues, byte saturation, byte lightness) {
myLeds[m].light = lightness;
myLeds[m].hue = hues;
myLeds[m].sat = saturation;
}
void updateFade(int g) {
if(myLeds[g].light < 2) { //if the lightness is really low, set it to 0 to shut it all the way off
myLeds[g].light = 0;
}
else {
myLeds[g].light *= fadefraction;
}
}
//code to convert HSB to RGB
void HSV_to_RGB(float h, float s, float v)
{
int i;
byte r, g, b;
float f,p,q,t;
s /= 255;
v /= 255;
if(s == 0) {
// Achromatic (grey)
r = g = b = v*255;
col[0] = r;
col[1] = g;
col[2] = b;
return;
}
h /= 60; // sector 0 to 5
i = h;
f = h - i; // factorial part of h
p = v * (1 - s);
q = v * (1 - s * f);
t = v * (1 - s * (1 - f));
switch(i) {
case 0:
r = 255*v;
g = 255*t;
b = 255*p;
break;
case 1:
r = 255*q;
g = 255*v;
b = 255*p;
break;
case 2:
r = 255*p;
g = 255*v;
b = 255*t;
break;
case 3:
r = 255*p;
g = 255*q;
b = 255*v;
break;
case 4:
r = 255*t;
g = 255*p;
b = 255*v;
break;
default:
r = 255*v;
g = 255*p;
b = 255*q;
}
col[0] = r;
col[1] = g;
col[2] = b;
return;
}
Welche Arduino hast Du?
analogWrite( 0 , HIGH );
delay( 500 );
analogWrite( 0 , LOW );
analogWrite( 1 , HIGH );
delay( 500 );
analogWrite( 1 , LOW );
analogWrite(3 , 255);
analogWrite(4 , 255);
Das hat alles keinen Sinn.
Außerdem bewirkt es, daß die Farbe der Neo-Pixel sich nur alle 2 Sekinden ändern.
Ich verstehe auch nicht wieso Du die Farben im HSV-Format angeben willst und nicht im RGB.
Grüße Uwe
Ich habe ein adafruit trinket vom speicher passt das...
Ja die farben sollen sich ja auch im 2 Sekunden abstand...
Kann ich das ganze denn ohne Probleme auf rgb ändern?
Sollten dann nicht trotzdem alle pixel angehen?
Keiner eine idee?
oOThrawnOo:
Keiner eine idee?
Ich habe eine Idee aber die wird dir nicht gefallen:
Gib uns mehr Informationen und Schaltplan.
Da ist eien Funktion die HSv in RGB wandelt; Du braucht sie nur nicht aufrufen.
Grüße Uwe
Hallo,
ich habe keine Ahnung, ob Dein MöchteGerneArduino Arduino kann…
Wenn ich Dir einen Rat geben darf, dann nutze die FastLED.
In den BeispielSketchen ist eigentlich sofort ersichtlich wie es geht.
Nur ein Vorschlag.
Gruß und Spaß dabei
Andreas
Na ja möchtegern arduino... reicht ja um 6 leds und 4 rgbs zu steuern... mehr will ich ja nicht
Hallo,
"na ja", mags ja recht haben. Man (und auch Frau) sieht ja was dabei raus kommt.
Anhand Deines Sketch kannst DU nicht einmal den falsch leuchtenden Pixel
ändern.
Das mag daran liegen, das Du- und auch ich, die "Adafruit_NeoPixel.h" nicht
richtig verstehen, wer weiß das schon?
Bei der FastLED kann man das aber in den Beispielen sofort erkennen und
durch probieren sofort andere Farben setzen.
Das was Du suchst, ist ja ein fast fertiger Sketch den hier wohl keiner liefern
wird.
Bei der FastLED könnte man es so probieren:
leds[0] = CRGB::White;
leds[1] = CRGB::Blue;
leds[2] = CRGB::Blue;
leds[3] = CRGB::Blue;
Hier leuchtet die erste LED in weiß und die anderen in Blau. Ich finde, das läßt
sich schon "leichter" kapieren.
Welche Lib Du auch nimmst, Du wirst nicht ohne Dokumentation auskommen.
Wenn Du nicht weißt wie die Stripes angesteuert werden, dann kannst Du das
schon vergessen.
Nimm doch erst einmal eine 0815-LED und lasse diese alle 2 Sekunden leuchten.
Wenn Du das kannst, dann lasse sie flackern.
Wenn beides funktioniert, dann überträgst Du das auf Deine NeoPixel. Ist doch
egal, was da 2 Sekunden leuchtet und flackert.
Ja, das liest sich alles als "DummSchwätzer" und bringt Dich nicht weiter.
Es gehören hier auch immer zwei dazu, Wir sind schon Einer…
Gruß und Spaß
Andreas
Habe noch mal einen neuen Sketch geschrieben...
Allerdings passiert wieder nicht das was passieren soll....
Der erste Pixel geht direkt mit an und leuchtet weiß die anderen reagieren gar nicht
Der Sketch sieht wie folgt aus:
#include <Adafruit_NeoPixel.h>
Adafruit_NeoPixel strip_pin2 = Adafruit_NeoPixel(4,2, NEO_RGB + NEO_KHZ800);
int rotgruen = 0 ;
void Unterprogramm();
void setup()
{
pinMode( 0 , OUTPUT);
pinMode( 1 , OUTPUT);
pinMode( 3 , OUTPUT);
pinMode( 4 , OUTPUT);
strip_pin2.begin();
strip_pin2.show();
}
void loop()
{
for (rotgruen= 1; rotgruen<= ( 5 ); rotgruen++ )
{
analogWrite(1 , 255);
analogWrite(0 , 255);
delay( 200 );
analogWrite(1 , 0);
analogWrite(0 , 0);
}
delay( 1000 );
analogWrite(3 , 255);
analogWrite(4 , 255);
delay( 1000 );
strip_pin2.setPixelColor(0,255 ,0 ,0 );
strip_pin2.show();
delay( 500 );
strip_pin2.setPixelColor(0,0 ,255 ,0 );
strip_pin2.show();
delay( 500 );
strip_pin2.setPixelColor(0,255 ,255 ,255 );
strip_pin2.show();
delay( 1000 );
strip_pin2.setPixelColor(1,255 ,0 ,0 );
strip_pin2.show();
delay( 100 );
strip_pin2.setPixelColor(2,255 ,0 ,0 );
strip_pin2.setPixelColor(3,255 ,0 ,0 );
delay( 500 );
strip_pin2.show();
strip_pin2.setPixelColor(1,230 ,119 ,23 );
strip_pin2.setPixelColor(2,230 ,119 ,23 );
strip_pin2.setPixelColor(3,230 ,119 ,23 );
strip_pin2.show();
delay( 500 );
strip_pin2.setPixelColor(1,230 ,213 ,23 );
strip_pin2.setPixelColor(2,230 ,213 ,23 );
strip_pin2.setPixelColor(3,230 ,213 ,23 );
strip_pin2.show();
delay( 500 );
Unterprogramm();
}
void Unterprogramm()
{
strip_pin2.setPixelColor(1,142 ,99 ,235 );
strip_pin2.setPixelColor(2,142 ,99 ,235 );
strip_pin2.setPixelColor(3,142 ,99 ,235 );
strip_pin2.show();
delay( 500 );
strip_pin2.setPixelColor(1,33 ,26 ,217 );
strip_pin2.setPixelColor(2,33 ,26 ,217 );
strip_pin2.setPixelColor(3,33 ,26 ,217 );
strip_pin2.show();
delay( 500 );
strip_pin2.setPixelColor(1,247 ,15 ,15 );
strip_pin2.setPixelColor(2,247 ,15 ,15 );
strip_pin2.setPixelColor(3,247 ,15 ,15 );
strip_pin2.show();
delay( 500 );
strip_pin2.setPixelColor(1,247 ,115 ,15 );
strip_pin2.setPixelColor(2,247 ,115 ,15 );
strip_pin2.setPixelColor(3,247 ,115 ,15 );
strip_pin2.show();
delay( 500 );
strip_pin2.setPixelColor(1,247 ,228 ,15 );
strip_pin2.setPixelColor(2,247 ,228 ,15 );
strip_pin2.setPixelColor(3,247 ,228 ,15 );
strip_pin2.show();
delay( 500 );
}
oOThrawnOo:
Ich habe ein adafruit trinket vom speicher passt das...
Da stimme ich zu, ich teste aber mit einen UNO.
oOThrawnOo:
... bei folgenden Sketch geht zwar der erste Pixel an, der rest bleibt dunkel. Außerdem hat der 1 Pixel die falsche farbe....
Ich habe
{{0x00, 0x00, 0xFF},{0x00, 0x00, 0x00},{0x00, 0x00, 0x00},{0x00, 0x00, 0x00}},
in allen Zeilen geändert, dann sieht es doch irgendwie Weiß aus und die restlichen NEOPIXEL-LEDs faden farbig. Woher die anderen Tabellenwerte stammen, erschließt sich mir nicht, allerdings nutze ich sonst FastLED.
Bei einem ATtiny könnte man noch Speicher sparen, da NEOPIXEL-LED0 immer die selbe Farbe haben soll und die restlichen die selbe Framefarbe. Was die restlichen "normalen" LEDs machen sollen, erschließt sich mir nicht, daher habe ich eine einfach mal blinken lassen. Mein Testcode:
#include <Adafruit_NeoPixel.h>
#include <avr/pgmspace.h>
#define PIN 2
#define LED_QUANTITY 4
Adafruit_NeoPixel strip = Adafruit_NeoPixel(LED_QUANTITY, PIN, NEO_GRB + NEO_KHZ800);
//store the led values for fading
struct led {
byte hue;
byte sat;
byte light;
};
//load the sequence into PROGMEM because otherwise it overloads RAM
const byte ledSeq [16][3] PROGMEM = {
{0x00, 0x00, 0x00},
{0x00, 0x00, 0x00},
{0x10, 0xFF, 0xFF},
{0x20, 0xFF, 0xFF},
{0x30, 0xFF, 0xFF},
{0x40, 0xFF, 0xFF},
{0x50, 0xFF, 0xFF},
{0x60, 0xFF, 0xFF},
{0x70, 0xFF, 0xFF},
{0x80, 0xFF, 0xFF},
{0x90, 0xFF, 0xFF},
{0xA0, 0xFF, 0xFF},
{0xB0, 0xFF, 0xFF},
{0xC0, 0xFF, 0xFF},
{0xD0, 0xFF, 0xFF},
{0xE0, 0xFF, 0xFF}
};
float fadefraction = .95; //adjust the fade out speed. typically .9-.99
const unsigned int interval = 130; //the speed of the animation, lower is faster
//store colors for conversion from HSB
byte col[3] = {0, 0, 0};
//count loops
int counter = 0;
//current frame of the sequence
int frame = 0;
led myLeds[LED_QUANTITY];
const byte blinkLedPin1 = 4;
const unsigned long fadeIntervall = 5, blinkIntervall = 100;
unsigned long aktMillis, fadeMillis, blinkMillis;
void setup() {
strip.begin();
strip.show(); // Initialize all pixels to 'off'
pinMode( blinkLedPin1 , OUTPUT);
}
void loop() {
aktMillis = millis();
if (aktMillis - fadeMillis >= fadeIntervall) {
fadeMillis = aktMillis;
//step thru the sequence
if (frame < 16) {
if (counter > interval) {
counter = 0;
setPixelFade(0, 0, 0, 0xFF);
for (int x = 1; x < LED_QUANTITY; x++) {
byte light = pgm_read_byte(&(ledSeq[frame][2])); //check the lightness value
if (light != 0x00) { //do not override with any black so that the fading can work
setPixelFade(x, pgm_read_byte(&(ledSeq[frame][0])), pgm_read_byte(&(ledSeq[frame][1])), light);
}
}
frame++;
}
} else {
frame = 0;
}
//update the fading - you can increase the "5" for slower fading
updateLeds();
strip.show();
counter++;
}
if (aktMillis - blinkMillis >= blinkIntervall) {
blinkMillis = aktMillis;
digitalWrite(blinkLedPin1, !digitalRead(blinkLedPin1));
}
}
void updateLeds() {
for (int i = 0; i < LED_QUANTITY; i++) {
updateFade(i);
HSV_to_RGB(myLeds[i].hue, myLeds[i].sat, myLeds[i].light);
strip.setPixelColor(i, col[0], col[1], col[2]);
}
}
void setPixelFade(int m, byte hues, byte saturation, byte lightness) {
myLeds[m].light = lightness;
myLeds[m].hue = hues;
myLeds[m].sat = saturation;
}
void updateFade(int g) {
if (myLeds[g].light < 2) { //if the lightness is really low, set it to 0 to shut it all the way off
myLeds[g].light = 0;
}
else {
myLeds[g].light *= fadefraction;
}
}
//code to convert HSB to RGB
void HSV_to_RGB(float h, float s, float v)
{
int i;
byte r, g, b;
float f, p, q, t;
s /= 255;
v /= 255;
if (s == 0) {
// Achromatic (grey)
r = g = b = v * 255;
col[0] = r;
col[1] = g;
col[2] = b;
return;
}
h /= 60; // sector 0 to 5
i = h;
f = h - i; // factorial part of h
p = v * (1 - s);
q = v * (1 - s * f);
t = v * (1 - s * (1 - f));
switch (i) {
case 0:
r = 255 * v;
g = 255 * t;
b = 255 * p;
break;
case 1:
r = 255 * q;
g = 255 * v;
b = 255 * p;
break;
case 2:
r = 255 * p;
g = 255 * v;
b = 255 * t;
break;
case 3:
r = 255 * p;
g = 255 * q;
b = 255 * v;
break;
case 4:
r = 255 * t;
g = 255 * p;
b = 255 * v;
break;
default:
r = 255 * v;
g = 255 * p;
b = 255 * q;
}
col[0] = r;
col[1] = g;
col[2] = b;
return;
}
Noch ein Tipp: Vergiß, daß es delay() gibt, nutze millis()! (Als ich diesen Satz schrieb, konnte ich nicht ahnen, wie aktuell er ist!)
Super vielen dank ich teste das gleich mal,
allerdings bräuchte ich eventuell noch ne info was das für ne 2 libary ist?
vom speicher passt auch meine ursprüngliche Version, die braucht nur 41 Bytes aber egal ich nehme jeden tipp gerne an =)
oOThrawnOo:
Super vielen dank ich teste das gleich mal,
Das sollte erstmal wie bei mir funktionieren, dann kann man optimieren.
oOThrawnOo:
allerdings bräuchte ich eventuell noch ne info was das für ne 2 libary ist?
Was meinst Du damit? Wenn Du FastLED meinst, dann GitHub - FastLED/FastLED: The FastLED library for colored LED animation on Arduino. Please direct questions/requests for help to the FastLED Reddit community: http://fastled.io/r We'd like to use github "issues" just for tracking library bugs / enhancements..
Ich meinte folgenden eintrag #include <avr/pgmspace.h>
Ich hoffe es, sobald die viper trocken spiele ich den sketch direkt mal auf
oOThrawnOo:
Ich meinte folgenden eintrag #include <avr/pgmspace.h>
Die wird wegen PROGMEM benötigt. Damit speicherst Du eine Konstante ab, als wäre es ein Stück Programm in der Annahme, Programmspeicher steht genügend zur Verfügung. Du schonst damit den dynamischen Speicher für die Verwendung von Variablen. Als Nachteil mußt Du dann pgm_read_byte() verwenden.
alles klar danke.
Habs jetzt mal probiert, erst lief es nicht. Daraufhin hab ich mir die Pixel noch mal angesehen und siehe da habe den 2. Pixel auf der Ausgangsseite angeschlossen.
Also Neu gelötet und jetzt leuchten alle.
Doch bei beiden Sketches leuchten alle 4 Pixel nur dauerhaft in Weiß....