Adding IR Remote Control to a Sketch

Greetings everyone
I have an Arduino sketch "WS2812B_Analogue_Digital_Clock_2Strip" made for Led strips and, I would like to add an IR Remote Control as in the attached drawing https://aws1.discourse-cdn.com/arduino/original/3X/e/c/ecbf0033bd2945c03f90ba59102fcacfcf9c7673.jpg, simply to turn the Led strip ON and OFF but, I don't have enough knowledge to do it, so I would like the help of noble friends. here's the sketch:
WS2812B_Analogue_Digital_Clock_2Strip.ino (8.3 KB)
My thanks in advance

PS.: If it is necessary to place the sketch between Tags I will place it!

Yes, please post code here as well as drawing, no Fritzing.
Helpers don't like spending time digging for documentation, watching videos etc.
If You want helpers to get interested, make their work as easy as ever can be.

1 Like

Hello
and good morning
For your approach you have check the usage of the Arduino timers for the selected libries first. Under bad circumstances their might be some conflicts.

I am unable to see the code. Post it here.

If the code uses the FastLED library, the show() function disables all interrupts. That can mess with IR code reception. Not sure how to get around that.

Open source here:

/***********************************************************************************
  Wol Clock ESP8266-12E + 60 LED WS2812B Analogue Digital Clock by Jon Fuge
  https://www.instructables.com/Wol-Clock-ESP8266-12E-60-LED-WS2812B-Analogue-Digi/
  referĂȘncia de cores rgb: https://rgb.to/255,128,0
  forum.arduino: https://forum.arduino.cc/t/ajuda-com-projeto-de-relogio-com-tira-de-led-ws2812-e-esp8266/859445
***********************************************************************************/

// *************** Declare included libraries *****************
#include <NTPClient.h>
#include <Time.h>
#include <TimeLib.h>
#include <Adafruit_NeoPixel.h>
#include <ESP8266WiFi.h>
#include <WiFiUdp.h>

// ************* Declara estruturas *****************
//Cria uma estrutura para informaçÔes de LED RGB
struct RGB {
  byte r, g, b;
};

//Cria uma estrutura para informaçÔes de tempo
struct TIME {
  byte Hour, Minute;
};

// ************* OpçÔes editåveis ***************************
//A cor do ponteiro "12H" para dar referĂȘncia visual ao topo
const RGB Twelve = { 128, 0, 128 };  //roxo forte
//A cor dos ponteiros 3H, 6H e 9H para dar referĂȘncia visual
const RGB Quarters = { 64, 0, 40 };  //roxo fraco
//A cor das "divisĂ”es" 1min,2min,4min,5min,7min,8min,10min e 11min para dar referĂȘncia visual
const RGB Divisions = { 32, 0, 20 }; //azul fraco
//Todos os outros pixels sem informação
const RGB Background = { 1, 3, 10 };  //azul fraco

//O ponteiro das horas
const RGB Hour = { 255, 0, 0 };  //vermelho
//O ponteiro dos minutos
const RGB Minute = { 0, 128, 0 };  //verde
//O ponteiro dos segundos
const RGB Second = { 0, 0, 255 };  //azul intenso

// Faz o relógio avançar ou retroceder (dependendo do tipo de tira de Led)
const char ClockGoBackwards = 0;

//Define o brilho por tempo para o modo noturno e diurno
const TIME WeekNight = {21, 30}; //escurecimento na semana Ă  noite
const TIME WeekMorning = {6, 15}; //clarear pela manhĂŁ na semana
const TIME WeekendNight = {21, 30}; //escurecimento Ă  noite nos fins de semana
const TIME WeekendMorning = {9, 30}; //clarear pela manhĂŁ nos fins de semana

const int day_brightness = 255;
const int night_brightness = 16;

//Define o seu fuso horårio em horas de diferença do GMT
const int hours_Offset_From_GMT = -4;

//Define os detalhes do seu Wi-Fi para que a placa possa se conectar e obter o tempo da internet
const char *ssid      = "Dancopy";      // seu SSID de rede (nome)
const char *password  = "dsjjg015085";  // sua senha de rede

byte SetClock;

// Por padrĂŁo 'time.nist.gov' Ă© usado.
WiFiUDP ntpUDP;
NTPClient timeClient(ntpUDP);

// Pino do ESP8266 que estĂĄ conectado aos NeoPixels
// #define PIN   14  // Este Ă© o pino D5
// #define PIN2  12  // Este Ă© o pino D6

// ************* Declara funçÔes do usuårio ******************************
void Draw_Clock(time_t t, byte Phase);
int ClockCorrect(int Pixel);
void SetBrightness(time_t t);
void SetClockFromNTP ();
bool IsDst();

// ************************** Declara NeoPixel ***************************
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(60, 14, NEO_GRB + NEO_KHZ800);
Adafruit_NeoPixel pixels2 = Adafruit_NeoPixel(60, 12, NEO_GRB + NEO_KHZ800);

//************* Função Setup para Wol_Clock ******************************
void setup() {
  pixels.begin(); // Inicializa a 1ÂȘ tira NeoPixel
  pixels2.begin(); // Inicializa a 2ÂȘ tira NeoPixel
  pixels.show();   // Atualiza todos os pixels da 1ÂȘ tira de Led
  pixels2.show();  // Atualiza todos os pixels da 2ÂȘ tira de Led
  Draw_Clock(0, 1); // Desenha simplesmente um relĂłgio em branco

  WiFi.begin(ssid, password); // Tenta conectar-se ao Wi-Fi
  Draw_Clock(0, 2); // Desenha o fundo do relĂłgio

  while (WiFi.status() != WL_CONNECTED)
    delay (500); // continua esperando até que possamos conectar com sucesso ao WiFi

  Draw_Clock(0, 3); // Adiciona os indicadores de um quarto de hora

  SetClockFromNTP(); // obtém a hora do servidor NTP com correção de fuso horårio
}

void SetClockFromNTP ()
{
  timeClient.update(); // obtém a hora do servidor NTP
  setTime(timeClient.getEpochTime()); // Define a hora do sistema a partir do relĂłgio
  if (IsDst())
    adjustTime((hours_Offset_From_GMT + 1) * 3600); // desloca a hora do sistema com o fuso horĂĄrio definido pelo usuĂĄrio (3600 segundos em uma hora)
  else
    adjustTime(hours_Offset_From_GMT * 3600); // desloca a hora do sistema com o fuso horĂĄrio definido pelo usuĂĄrio (3600 segundos em uma hora)
}

bool IsDst()
{
  if (month() < 3 || month() > 10)  return false;
  if (month() > 3 && month() < 10)  return true;

  int previousSunday = day() - weekday();

  if (month() == 3) return previousSunday >= 24;
  if (month() == 10) return previousSunday < 24;

  return false; // esta linha nunca vai acontecer
}

// ************* Loop do programa principal para Wol_Clock ******************************
void loop() {
  time_t t = now(); // Obtém a hora atual

  Draw_Clock(t, 4); // Desenha todo o mostrador do relĂłgio com horas, minutos e segundos
  if (minute(t) == 0) // no inĂ­cio de cada hora, atualiza a hora no servidor de tempo
  {
    if (SetClock == 1)
    {
      SetClockFromNTP(); // obtém a hora do servidor NTP com correção de fuso horårio
      SetClock = 0;
    }
  }
  else
  {
    delay(200); // Espera somente 0,1 segundos
    SetClock = 1;
  }
}

// ************* FunçÔes para desenhar o relógio ******************************
void Draw_Clock(time_t t, byte Phase)
{
  if (Phase <= 0)
    for (int i = 0; i < 60; i++)
      pixels.setPixelColor(i, pixels.Color(0, 0, 0)); // para Phase = 0 ou menos, todos os pixels sĂŁo pretos

  if (Phase >= 1)
    for (int i = 0; i < 60; i++)
      pixels2.setPixelColor(i, pixels.Color(Background.r, Background.g, Background.b)); // para Phase = 1 ou mais, desenhe os minutos com a cor de fundo

  if (Phase >= 2)
    for (int i = 0; i < 60; i = i + 5)
      pixels2.setPixelColor(i, pixels.Color(Divisions.r, Divisions.g, Divisions.b)); // para Phase = 2 ou mais, desenhe divisÔes de 5 minutos

  if (Phase >= 3) {
    for (int i = 0; i < 60; i = i + 15)
      pixels.setPixelColor(ClockCorrect(i), pixels.Color(Quarters.r, Quarters.g, Quarters.b)); // para Phase = 3 ou mais, desenhe divisÔes de 15 minutos
    pixels.setPixelColor(ClockCorrect(0), pixels.Color(Twelve.r, Twelve.g, Twelve.b)); // para Phase = 3 e acima, desenhe o indicador de 12 horas
  }

  if (Phase >= 4) {
    pixels2.setPixelColor(ClockCorrect(second(t)), pixels2.Color(Second.r, Second.g, Second.b)); // desenhe o ponteiro dos segundos primeiro
    if (second() % 2)
      pixels2.setPixelColor(ClockCorrect(minute(t)), pixels2.Color(Minute.r, Minute.g, Minute.b)); // para ajudar na identificação, o ponteiro dos minutos pisca entre a intensidade normal e meia intensidade
    else
      pixels2.setPixelColor(ClockCorrect(minute(t)), pixels2.Color(Minute.r, Minute.g, Minute.b)); // ponteiro dos minutos de menor intensidade

    pixels.setPixelColor(ClockCorrect(((hour(t) % 12) * 5)), pixels.Color(Hour.r, Hour.g, Hour.b)); // desenhe o ponteiro das horas por Ășltimo
    pixels.show();
    pixels2.show();
    pixels.clear();
    pixels2.clear();
  }

  SetBrightness(t); // Define o brilho do relĂłgio de acordo com a hora
}

// ************* Função para definir o brilho do relógio ******************************
void SetBrightness(time_t t)
{
  int NowHour = hour(t);
  int NowMinute = minute(t);

  if ((weekday() >= 2) && (weekday() <= 6))
    if ((NowHour > WeekNight.Hour) || ((NowHour == WeekNight.Hour) && (NowMinute >= WeekNight.Minute)) || ((NowHour == WeekMorning.Hour) && (NowMinute <= WeekMorning.Minute)) || (NowHour < WeekMorning.Hour))
      pixels.setBrightness(night_brightness);
    else
      pixels.setBrightness(day_brightness);
  else if ((NowHour > WeekendNight.Hour) || ((NowHour == WeekendNight.Hour) && (NowMinute >= WeekendNight.Minute)) || ((NowHour == WeekendMorning.Hour) && (NowMinute <= WeekendMorning.Minute)) || (NowHour < WeekendMorning.Hour))
    pixels.setBrightness(night_brightness);
  else
    pixels.setBrightness(day_brightness);
}

//************* Testa a função de inversão da ordem dos pixels ***************
int ClockCorrect(int Pixel)
{
  if (ClockGoBackwards == 1)
    return ((60 - Pixel + 30) % 60);
  else
    return (Pixel);
}

If this change is to compromise the program because it actually uses the show () function, I will keep the original code (without IR control).