Ajuda com Projeto de Relógio com Tira de LED WS2812 e ESP8266 (Resolvido)

Cumprimentos a todos os forenses

Tenho um projeto, obtido da internet que, como especifiquei no título, originalmente foi feito para uma tira de LED 60 NeoPixel WS2812 com ESP8266, mas, como eu precisava para duas tiras (60 NeoPixel), eu adaptei o código, acrescentando alguma coisa. O projeto original (uma tira) funciona corretamente, mas, como tive que fazer adaptações e, tendo pouca experiência com Arduino, o código está tendo alguma disfunção (penso eu), que explicarei a seguir:

Estou fazendo o relógio com duas tiras, uma para, praticamente, mostrar as Horas e a outra para mostrar Minutos / Segundos então, eis o erro:

Quando eu ligo o relógio, ele inicia corretamente, por exemplo, digamos 8:00h e, a medida que as horas avançam, quando são 9:00h, o Led de 8:00h que ficou pra trás, permanece aceso com o Led de 9:00h que acendeu e, assim por diante, quando são 10:00h, ficam acesos os Leds de 8:00h, 9:00h e 10:00h que acendeu por último. Portanto, necessito da vossa preciosa ajuda.

Abaixo o sketch que modifiquei/acrescentei:

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

Obs.: Desconfio que o suposto problema pode estar na seguinte linha:

pixels.setPixelColor(ClockCorrect(((hour(t) % 12) * 5)), pixels.Color(Hour.r, Hour.g, Hour.b)); // desenhe o ponteiro das horas por último

Meus sinceros e antecipados agradecimentos a todos

Boa noite

Dancopy

or favor coloque seu sketch entre tags. </>

RV mineirin

@ruilviana
Desculpe, sou meio atrapalhado nessa questão mas, agora acho que fiz correto?

A questão foi parcialmente resolvida da seguinte forma:
No final de Funções para desenhar o relógio, em "void Draw_Clock(time_t t, byte Phase)", após pixels.show(); e pixels2.show(); eu acrescentei as duas funções: pixels.clear(); e pixels2.clear(); então, percebi que isso resolveu o problema pois, os LEDs da hora agora estão acendendo e apagando corretamente.

Que tal fechar este tópico sobre este assunto e abrir um novo focado no CR IR?

RV mineirin