Effekte nur auf Bestimmte LEDs

Hi Leute,

hab zwar schon alles rauf und runter gesucht, komme nicht dahinter wie ich es Bewerkstelligen könnte.

Es geht um diesen Demo Sketch:

#include <FastLED.h>

#define LED_PIN     3
#define NUM_LEDS    36
#define BRIGHTNESS  180
#define LED_TYPE    UCS1903B
#define COLOR_ORDER RGB
CRGB leds[NUM_LEDS];

#define UPDATES_PER_SECOND 100

// This example shows several ways to set up and use 'palettes' of colors
// with FastLED.
//
// These compact palettes provide an easy way to re-colorize your
// animation on the fly, quickly, easily, and with low overhead.
//
// USING palettes is MUCH simpler in practice than in theory, so first just
// run this sketch, and watch the pretty lights as you then read through
// the code.  Although this sketch has eight (or more) different color schemes,
// the entire sketch compiles down to about 6.5K on AVR.
//
// FastLED provides a few pre-configured color palettes, and makes it
// extremely easy to make up your own color schemes with palettes.
//
// Some notes on the more abstract 'theory and practice' of
// FastLED compact palettes are at the bottom of this file.



CRGBPalette16 currentPalette;
TBlendType    currentBlending;

extern CRGBPalette16 myRedWhiteBluePalette;
extern const TProgmemPalette16 myRedWhiteBluePalette_p PROGMEM;


void setup() {
    delay( 3000 ); // power-up safety delay
    FastLED.addLeds<LED_TYPE, LED_PIN, COLOR_ORDER>(leds, NUM_LEDS).setCorrection( TypicalLEDStrip );
    FastLED.setBrightness(  BRIGHTNESS );
    
    currentPalette = RainbowColors_p;
    currentBlending = LINEARBLEND;
}


void loop()
{
    ChangePalettePeriodically();
    
    static uint8_t startIndex = 0;
    startIndex = startIndex + 1; /* motion speed */
    
    FillLEDsFromPaletteColors( startIndex);
    
    FastLED.show();
    FastLED.delay(1000 / UPDATES_PER_SECOND);
}

void FillLEDsFromPaletteColors( uint8_t colorIndex)
{
    uint8_t brightness = 255;
    
    for( int i = 0; i < NUM_LEDS; i++) {
        leds[i] = ColorFromPalette( currentPalette, colorIndex, brightness, currentBlending);
        colorIndex += 3;
    }
}


// There are several different palettes of colors demonstrated here.
//
// FastLED provides several 'preset' palettes: RainbowColors_p, RainbowStripeColors_p,
// OceanColors_p, CloudColors_p, LavaColors_p, ForestColors_p, and PartyColors_p.
//
// Additionally, you can manually define your own color palettes, or you can write
// code that creates color palettes on the fly.  All are shown here.

void ChangePalettePeriodically()
{
    uint8_t secondHand = (millis() / 3000) % 60;
    static uint8_t lastSecond = 99;
    
    if( lastSecond != secondHand) {
        lastSecond = secondHand;
        if( secondHand ==  0)  { currentPalette = RainbowColors_p;         currentBlending = LINEARBLEND; }
        if( secondHand == 10)  { currentPalette = RainbowStripeColors_p;   currentBlending = NOBLEND;  }
        if( secondHand == 15)  { currentPalette = RainbowStripeColors_p;   currentBlending = LINEARBLEND; }
        if( secondHand == 20)  { SetupPurpleAndGreenPalette();             currentBlending = LINEARBLEND; }
        if( secondHand == 30)  { SetupTotallyRandomPalette();              currentBlending = LINEARBLEND; }
        if( secondHand == 35)  { SetupBlackAndWhiteStripedPalette();       currentBlending = NOBLEND; }
        if( secondHand == 40)  { currentPalette = CloudColors_p;           currentBlending = LINEARBLEND; }
        if( secondHand == 45)  { currentPalette = PartyColors_p;           currentBlending = LINEARBLEND; }
        if( secondHand == 50)  { currentPalette = myRedWhiteBluePalette_p; currentBlending = NOBLEND;  }
        if( secondHand == 55)  { currentPalette = myRedWhiteBluePalette_p; currentBlending = LINEARBLEND; }
        if( secondHand == 60)  { currentPalette = OceanColors_p;           currentBlending = LINEARBLEND; }
        if( secondHand == 65)  { SetupBlackAndWhiteStripedPalette();       currentBlending = LINEARBLEND; }
        if( secondHand == 70)  { currentPalette = LavaColors_p;            currentBlending = LINEARBLEND; }
        if( secondHand == 75)  { currentPalette = ForestColors_p;          currentBlending = LINEARBLEND; }
        
    }
}

// This function fills the palette with totally random colors.
void SetupTotallyRandomPalette()
{
    for( int i = 0; i < 16; i++) {
        currentPalette[i] = CHSV( random8(), 255, random8());
    }
}

// This function sets up a palette of black and white stripes,
// using code.  Since the palette is effectively an array of
// sixteen CRGB colors, the various fill_* functions can be used
// to set them up.
void SetupBlackAndWhiteStripedPalette()
{
    // 'black out' all 16 palette entries...
    fill_solid( currentPalette, 16, CRGB::Black);
    // and set every fourth one to white.
    currentPalette[0] = CRGB::White;
    currentPalette[4] = CRGB::White;
    currentPalette[8] = CRGB::White;
    currentPalette[12] = CRGB::White;
    
}

// This function sets up a palette of purple and green stripes.
void SetupPurpleAndGreenPalette()
{
    CRGB purple = CHSV( HUE_PURPLE, 255, 255);
    CRGB green  = CHSV( HUE_GREEN, 255, 255);
    CRGB black  = CRGB::Black;
    
    currentPalette = CRGBPalette16(
                                   green,  green,  black,  black,
                                   purple, purple, black,  black,
                                   green,  green,  black,  black,
                                   purple, purple, black,  black );
}



// This example shows how to set up a static color palette
// which is stored in PROGMEM (flash), which is almost always more
// plentiful than RAM.  A static PROGMEM palette like this
// takes up 64 bytes of flash.
const TProgmemPalette16 myRedWhiteBluePalette_p PROGMEM =
{
    CRGB::Red,
    CRGB::Gray, // 'white' is too bright compared to red and blue
    CRGB::Blue,
    CRGB::Black,
    
    CRGB::Red,
    CRGB::Gray,
    CRGB::Blue,
    CRGB::Black,
    
    CRGB::Red,
    CRGB::Red,
    CRGB::Gray,
    CRGB::Gray,
    CRGB::Blue,
    CRGB::Blue,
    CRGB::Black,
    CRGB::Black
};

So weit geht es ja, aber ist es möglich die Effekte nur auf Bestimmten LEDs auszugeben. Besser gesagt auf zwei Synchron laufenden Strengen.

Beispiel: 1. Strang LED 1,4,6,8,12,15…
2. Strang LED 2,3,7…

Ein Umbau ist leider nicht mehr möglich, da diese LEDs in einer Kindereisenbahn mit drei Hängern verbaut sind. Da hatte ich beim Bau leider nicht darüber nachgedacht, für links und rechts einen Eigenen Strang zu verlegen. So das es nun eine komplette Kette ist.

Wäre über jede Hilfreiche Antwort dankbar.

gruß
Ronny

Hi

Das kannst Du mit einem Work-Arround erledigen.
Schreibe Dir eigene Funktionen, Die die Pixel-Farben annehmen und darin interpretierst Du, wo das eigentliche Ziel auf dem Hardware-String sitzt.
Schön wäre Es, wenn die LED-Nummern ‘einen Sinn’ ergäben :slight_smile: … sich also berechnen ließen.
Sonst könnte man auch die LED-Nummern in einem Array (oder Deren Zwei - Du hast ja zwei ‘alternative Stripes’) speichern und bei jedem Setzen würde man diese Arrays durchsuchen, wo meine LED letzlich hin gesetzt werden muß.

MfG

Danke für deine Antwort schon mal.

Zum Thema sinn ergeben, die Leds sind so auf geteilt. Jetzt mal bloß die Lok.

3 2

4 - - 1 5 - - 6 - - - - 7 - - 8 - -

9 - - 12

10 11

So müssten die Stränge da so nummeriert sein:

1.Strang: 7,8,9,10,11,12 2.Strang: 6,5,4,3,2,1

Das mit Array hatte ich schon mal getestet aber ich hatte es nicht geschafft, die die Effekte darauf zu bekommen.

Könntest du mir das mit dem Work-Arround genauer erläutern, bin leider noch nicht so lang drin.

Hi

'Sinn ergeben' soll hier nur heißen - wenn man den Kram berechnen kann, kann man sich einiges erleichtern. Wenn nicht, dann klappt's auch mit einer 'Übersetzung' - eben z.B. mit einem Array, Welches mir die Zuordnung der virtuellen LEDs meiner beiden Stripes zu dem wirklich vorhandenen 1-fach-String darlegt.

MEINE Funktion würde die LED-Nummer der virtuellen Stripes und Deren Farbe bekommen. Sie würde den Kram auf 'das Gesamte' um'interpretieren'. Das anschließende .show() füllt alle Pixel dann mit neuen Farben.

Du brauchst quasi nur eine Art 'Soll->Ist'-Liste.

Gegeben: 1 Stripe mit x LED Gefordert: 2 Stripe mit verteilten LED Lösung: Funktion, Die Stripe x LED y auf den gegebenen Stripe 'umstrickt'.

Darin sehe ich eigentlich kein größeres Problem (wobei sich Diese erst beim 'Machen' wirklich zeigen).

Entweder erstelle ich ein Array, Welches mit pro LED 'sagt', ob Diese in Stripe 0 oder in Stripe 1 zuliegen kommt (könnte man sogar bitweise machen --- Speichersparen gg). Oder ich erstelle zwei Array, Die die LED dieses Array beinhalten. Hier könnte ich auch LED mehrfach zuteilen - kA, wofür Das gut sein könnte.

Welchen Weg wollen wir einschlagen? Oder: Hat Wer Anders eine bessere Idee?

MfG