[kaczakat]

Wczytałem bibliotekę, wybrałem przykład ColorPalette, efekty zamieniłem na case'y przypisane do kodów 0-9, w loop wywołuję sprawdzanie kodów, jak jest inny niż 0 , a często jest przy wywołaniu efektu co 100ms, to ignoruję, jak jest któryś z tych 0-9 to zmieniam efekt.
Faktycznie czasami odczytuje 0 przy ustawieniu na 10FPS, a przy 50ms (20FPS) to już same 0, coś zaczyna działać od 60ms.
Ledów mam 24 w ringu, jak miałbym to zrobić tylko na AVR to dodałbym Attiny13 by czytał mi kody IR NEC i przez soft serial wysyłał na UART sprzętowy Atmega, ma bufor, odczyta w przerwaniach, to 1 bajt, zadziała na 100%.
Jak masz więcej led to i 100ms może czkać. 
Za to ESP8266, w sumie ten sam kod tylko zmienione dwa piny dla IR i LED, bez problemu śmiga w ustawieniu na 10ms, i na 1ms, bez zająknięcia, sterować można tym wtedy również przez WIFI, z drugiego końca świata (jak masz zewnętrzne IP i umiesz przekierować porty na routerze).
Tak że możesz trochę powalczyć, albo zrobić to na tańszej płytce jak Wemos MINI.
Ewentualnie są takie ledy z SPI, jest sprzętowy w Atmega328p, to wtedy może działać 10x szybciej, a na pewno jest tu opcja użycia przerwań zamiast blokować na kilkaset us /ms uC by nadawać banglując pinem.

Kod:

/// @file    ColorPalette.ino
/// @brief   Demonstrates how to use @ref ColorPalettes
/// @example ColorPalette.ino

#include <FastLED.h>



#define LED_PIN     11 //12
#define NUM_LEDS    24
#define BRIGHTNESS  64
#define LED_TYPE    WS2811
#define COLOR_ORDER GRB
CRGB leds[NUM_LEDS];

#define UPDATES_PER_SECOND 50
#include <IRremote.h>

#define RECV_PIN 2 //143

// 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;

//******************************************CZAS

uint32_t czasTeraz,czasPoprzedni,tik=10, minutyDoby;
uint8_t nTik,sekundy,minuty,godziny,dni;
bool fnTik,fsekundy,fminuty,fgodziny,fdni,czasInternetowyOK;


/*
0  0X16
1  0XC
2  0X18
3  0X5E
4  0X8
5  0X1C
6  0X5A
7  0X42
8  0X52
9  0X4A
*/
// const int pilot[]={0x16,0xC,0x18,0x5E,0x8,0x1C,0x5A,0x42,0x52,0x4A};

char  napis[20] ;
uint8_t kod;
void setup() {
 
    delay( 300 ); // power-up safety delay
      IrReceiver.begin(RECV_PIN);
    FastLED.addLeds<LED_TYPE, LED_PIN, COLOR_ORDER>(leds, NUM_LEDS).setCorrection( TypicalLEDStrip );
    FastLED.setBrightness(  BRIGHTNESS );
    Serial.begin(115200);
    currentPalette = RainbowColors_p;
    currentBlending = LINEARBLEND;
}


void loop()
{
czas();

if (IrReceiver.decode()) {
  IrReceiver.resume();
  uint8_t last;
if(last=IrReceiver.decodedIRData.command) kod=last;
 
    Serial.println(kod);
   
}
//if(fnTik)  //co 10ms
if(fnTik and nTik%10==0)  //co 100ms

  {
    ChangePalettePeriodically();
   
    static uint8_t startIndex = 0;
    startIndex = startIndex + 1; /* motion speed */
   
    FillLEDsFromPaletteColors( startIndex);
   
    FastLED.show();
//    FastLED.delay(1000 / UPDATES_PER_SECOND);
  }
if(fsekundy)
{
sprintf(napis,"%03d:%02d:%02d",godziny,minuty,sekundy);
Serial.println(napis);
}
   
}

void czas()
{
static uint32_t  czasPoprzedniS=0;
  czasTeraz=millis();
fnTik=fsekundy=fminuty=fgodziny=fdni=0;
if((uint32_t)(czasTeraz-czasPoprzedni)>=tik)
{
  czasPoprzedni=czasTeraz;
  fnTik=1;
  nTik++;
if(nTik>=(1000/tik))    nTik=0;


  if((uint32_t)(czasTeraz-czasPoprzedniS)>=1000)
  {
    czasPoprzedniS=czasTeraz;
    sekundy++;
    fsekundy=1;
     if (sekundy>=60)
    {
      sekundy=0;
      minuty++;
      fminuty=1;
      if (minuty>=60)
      {
        minuty=0;
        godziny++;
        fgodziny=1;
        if (godziny>=24)
        {
          godziny=0;
          fdni=1;
          dni++;
   
        }
      }
    }
  }
}
}




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() / 1000) % 60;
//    static uint8_t lastSecond = 99;
    switch (kod)
{     case 0x16:
       { currentPalette = RainbowColors_p;         currentBlending = LINEARBLEND; }
      break;
      case 0xC:
      { currentPalette = RainbowStripeColors_p;   currentBlending = NOBLEND;  }
      break;
      case 0x18:
      { currentPalette = RainbowStripeColors_p;   currentBlending = LINEARBLEND; }
      break;
      case 0x5E:
       { SetupPurpleAndGreenPalette();             currentBlending = LINEARBLEND; }
      break;
      case 0x8:
       { SetupTotallyRandomPalette();              currentBlending = LINEARBLEND; }
      break;
      case 0x1C:
       { SetupBlackAndWhiteStripedPalette();       currentBlending = NOBLEND; }
      break;
      case 0x5A:
      { SetupBlackAndWhiteStripedPalette();       currentBlending = LINEARBLEND; }
      break;
      case 0x42:
      { currentPalette = CloudColors_p;           currentBlending = LINEARBLEND; }
      break;
      case 0x52:
      { currentPalette = PartyColors_p;           currentBlending = LINEARBLEND; }
      break;
      case 0x4A:
      { currentPalette = myRedWhiteBluePalette_p; currentBlending = NOBLEND;  }
      break;
default:
//leds[whiteLed] = CRGB::White;
break;
}

   
//    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 == 25)  { SetupTotallyRandomPalette();              currentBlending = LINEARBLEND; }
//        if( secondHand == 30)  { SetupBlackAndWhiteStripedPalette();       currentBlending = NOBLEND; }
//        if( secondHand == 35)  { SetupBlackAndWhiteStripedPalette();       currentBlending = LINEARBLEND; }
//        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; }
//    }
}

// 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
};



// Additional notes on FastLED compact palettes:
//
// Normally, in computer graphics, the palette (or "color lookup table")
// has 256 entries, each containing a specific 24-bit RGB color.  You can then
// index into the color palette using a simple 8-bit (one byte) value.
// A 256-entry color palette takes up 768 bytes of RAM, which on Arduino
// is quite possibly "too many" bytes.
//
// FastLED does offer traditional 256-element palettes, for setups that
// can afford the 768-byte cost in RAM.
//
// However, FastLED also offers a compact alternative.  FastLED offers
// palettes that store 16 distinct entries, but can be accessed AS IF
// they actually have 256 entries; this is accomplished by interpolating
// between the 16 explicit entries to create fifteen intermediate palette
// entries between each pair.
//
// So for example, if you set the first two explicit entries of a compact
// palette to Green (0,255,0) and Blue (0,0,255), and then retrieved
// the first sixteen entries from the virtual palette (of 256), you'd get
// Green, followed by a smooth gradient from green-to-blue, and then Blue.