Problema en cambios de fase, pantalla iluminación acuario.

Buenas tardes, llevaba un tiempo rondándome la cabeza el comprarme una placa y empezar a hacer proyectos sencillos para comenzar en arduino cuando un conocido me incito a comprarle una pantalla de led ya preparada para funcionar que otro tipo le había dado totalmente desconectada y de lo cual no tenia ni remota idea de como comenzar, como no es el mismo espectro para agua dulce y marino cambie los leds de 6500k por 10000k y los de 4000k por azul royal y cian.

El problema:

Tras ajustar tiempos y poco mas vi que la programación funcionaba, hasta que la monté en el acuario y ayer me di cuenta que cuando está "amaneciendo" no pasa de la fase 1, que es la que conecta los rojos y no llega a conectar los otros colores.

Ademas si recargo el programa en el tiempo que debería estar en fase 2, 3 o cualquier otra se pone bien el color y cuando llega al anochecer lo hace perfectamente... pongo el código para ver si alguien me podria decir donde tengo el problema entre la fase 1 y 2.

El nombre de las salidas y entradas de reg no las he cambiado porque el programa no sabe de que color son los leds que enciende/apaga...

///////////////////////// PROGRAMA //////////////////////////////
/////////////////////////////////////////////////////////////////

void loop(){
  
  //Leer Entrada//////////////////////////////////////////////////////////////////////////////
  IN_MTO_ON = digitalRead(IN_MTO);
  
  ////CONFIRMA ENTRADA MTO////////////
  if (IN_MTO_ON == HIGH)
  {
    delay (5000);
    IN_MTO_ON = digitalRead(IN_MTO);
  }
  
  if (IN_MTO_ON == HIGH) {
    analogWrite(OUT_PWM_Diurna_6500_1, PWM_MTO);
    analogWrite(OUT_PWM_Diurna_6500_2, PWM_MTO);
    analogWrite(OUT_PWM_Diurna_4000_1, PWM_MTO);
    analogWrite(OUT_PWM_Diurna_4000_2, PWM_MTO);
    analogWrite(OUT_PWM_Rojos, 0);
    analogWrite(OUT_PWM_Nocturna, 0);
    M_1 = 1;
  }
    if ((IN_MTO_ON == LOW)&& (M_1 = 1)) {
    analogWrite(OUT_PWM_Diurna_6500_1, Reg_PWM_Dia_6500);
    analogWrite(OUT_PWM_Diurna_6500_2, Reg_PWM_Dia_6500);
    analogWrite(OUT_PWM_Diurna_4000_1, Reg_PWM_Dia_4000);
    analogWrite(OUT_PWM_Diurna_4000_2, Reg_PWM_Dia_4000);
    analogWrite(OUT_PWM_Rojos, Reg_PWM_Rojos);
    analogWrite(OUT_PWM_Nocturna, Reg_PWM_Noche);
    M_1 = 0;
  }
  
    
  //Leer Reloj//////////////////////////////////////////////////////////////////////////////////////////////////
   getDateDs1307(&second, &minute, &hour, &dayOfWeek, &dayOfMonth, &month, &year);  
  
   //Ver reloj en puerto serie//////////////////////////////////////////////////////////////////////////////////
          if (dayOfMonth < 10) Serial.print("0");
          Serial.print(dayOfMonth, DEC); 
          Serial.print("/"); 
        if (month < 10) Serial.print("0");
          Serial.print(month, DEC); 
          Serial.print("/");
          Serial.print("20");
          Serial.print(year, DEC);
    
          Serial.print("     ");
        if (hour < 10) Serial.print("0");
          Serial.print(hour, DEC);
          Serial.print(":");  
        if (minute < 10) Serial.print("0");
          Serial.print(minute, DEC);
          Serial.print(":");  
           if (second < 10) Serial.print("0");
          Serial.print(second, DEC);
          
          Serial.print("     ");
          Serial.print("Rojos");
          Serial.print("-");
          Serial.print(Reg_PWM_Rojos);
          Serial.print("  Blacos 6500");
          Serial.print("-");
          Serial.print(Reg_PWM_Dia_6500);
          Serial.print("  Blacos 4000");
          Serial.print("-");
          Serial.print(Reg_PWM_Dia_4000);
          Serial.print("  Azules");
          Serial.print("-");
          Serial.print(Reg_PWM_Noche);
          Serial.print(" MTO - ");
          Serial.print(IN_MTO_ON);  
          Serial.print(" Fase - ");
          Serial.println(Fase);        
       
       delay (100); 
       if (((Fase == 4) || (Fase == 0)|| (Fase == 8))&& Ciclo == 1) {delay (10000);}
  
    ////////////////////////////////
    //Fase 1,Fase2,Fase3 AMANECER //
    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    
   if ((Fase == 0) &&  (hour >= H_Amanecer)) Fase = 1; 
  while ((hour >= H_Amanecer)&&(hour < H_Dia) && (Fase < 4)) //Funcion mientras
  { 
    //Salir Bucle Por Tiempo
     if ((VESC_Delay_Fase1 >= ESC_Delay_Fase1) || (VESC_Delay_Fase2 >= ESC_Delay_Fase2) || (VESC_Delay_Fase3 >= ESC_Delay_Fase3)) {
                VESC_Delay_Fase1 = 0;
                VESC_Delay_Fase2 = 0;
                VESC_Delay_Fase3 = 0;
                 break;
     }
     
  //Luz Dia Rojos ON (FASE 1)/////////////////////////////////////
  if ((Reg_PWM_Rojos < PWM_Rojos)&& (Fase == 1)) 
  { 
  Reg_PWM_Rojos++;                                         //Incremento del registro
  if (IN_MTO_ON == LOW) analogWrite(OUT_PWM_Rojos, Reg_PWM_Rojos);   // Escribe el registro PWM en Salida Rojos
  delay(Delay_Fase1);
  VESC_Delay_Fase1++;
  Men_Escribir();
  }
  if (Reg_PWM_Rojos == PWM_Rojos_Blancos_ON) {Fase = 2; VESC_Delay_Fase1 = 0;}
  
  //AQUI EMPIEZA EL PROBLEMA, EL PROGRAMA NO AVANZA POR SI SOLO//
    //Luz Dia Dia ON (FASE 2)////////////////////////////////////////    
  if ((Reg_PWM_Dia_6500 < PWM_Blancos_6500) && (Fase == 2)) 
  { 
  Reg_PWM_Dia_6500++;  //Incremento del registro 6500K
  
  if (Reg_PWM_Dia_4000 < PWM_Blancos_4000) //4000K
        {
          Reg_PWM_Dia_4000++;  //Incremento del registro 4000K
        }
    
  if (IN_MTO_ON == LOW) {
    analogWrite(OUT_PWM_Diurna_6500_1, Reg_PWM_Dia_6500);    // Escribe el registro PWM en Salida Diurna 6500K
    analogWrite(OUT_PWM_Diurna_6500_2, Reg_PWM_Dia_6500);    // Escribe el registro PWM en Salida Diurna 6500K
    analogWrite(OUT_PWM_Diurna_4000_1, Reg_PWM_Dia_4000);    // Escribe el registro PWM en Salida Diurna  
    analogWrite(OUT_PWM_Diurna_4000_2, Reg_PWM_Dia_4000);    // Escribe el registro PWM en Salida Diurna    
    }
  if (Reg_PWM_Rojos < PWM_Rojos) 
          { 
            Reg_PWM_Rojos++;                                         //Incremento del registro
  if (IN_MTO_ON == LOW) analogWrite(OUT_PWM_Rojos, Reg_PWM_Rojos);   // Escribe el registro PWM en Salida Rojos
            }
   delay (Delay_Fase2);    //Temporizador espera ms
   VESC_Delay_Fase2++;
    Men_Escribir();
  }
  if (Reg_PWM_Dia_6500 == PWM_Blancos_6500) {Fase = 3; VESC_Delay_Fase2 = 0;}
   
    
    //Luz Rojos Dia OFF (FASE 3)////////////////////////////////////////////
    if ((Reg_PWM_Rojos > 0) && (Fase == 3)){
    Reg_PWM_Rojos--; 
    if (IN_MTO_ON == LOW) analogWrite(OUT_PWM_Rojos, Reg_PWM_Rojos); 
    delay (Delay_Fase3);
    VESC_Delay_Fase3++;
     Men_Escribir();
    }
    if ((Reg_PWM_Rojos == 0) && (Fase == 3)) {Fase = 4; break;}
  }

Supongo que sera una chorrada en los contadores o algo, pero como he empezado galopando ya saltándome el gateo, andar y aprender a montar a caballo… poco a poco voy identificando código e instrucciones pero identificar el problema me viene grande.

Un saludo y gracias.

EDIT: He recortado el código porque no me dejaba postearlo sinó

Y el setup, las librerías y los globales?
Si pides ayuda, no parcialeces el código, hay que ver todo!!

ok pero como me dice que 9000 caracteres… lo pongo completo pero en varios mensajes

/////////////////  Pantalla NANO-REEF ///////////////////////////////

////////////////Libreria EEPROM /////////////////////////////
#include <EEPROM.h>

  //////////
  // RELOJ//
  //////////
  
  #include <Wire.h>   
  #define DS1307_I2C_ADDRESS 0x68
  byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;
  byte decToBcd(byte val)
  {
   return ( (val/10*16) + (val%10) );
  }
  byte bcdToDec(byte val)// Convierte BCD (binario decimal codificado) a números normales decimales 
  {
  return ( (val/16*10) + (val%16) );
  }
  void setDateDs1307(byte second,        // 0-59
                     byte minute,        // 0-59
                     byte hour,          // 1-23
                     byte dayOfWeek,     // 1-7
                     byte dayOfMonth,    // 1-28/29/30/31
                     byte month,         // 1-12
                     byte year)          // 0-99
  {
     Wire.beginTransmission(DS1307_I2C_ADDRESS);
     Wire.write(0);
     Wire.write(decToBcd(second));    // 0 a bit 7 inicia el reloj
     Wire.write(decToBcd(minute));
     Wire.write(decToBcd(hour));      // Si usted quiere 12 hora am/pm usted tiene que poner el 
                                   //  bit 6 (tambien tiene que cambiar readDateDs1307)

     Wire.write(decToBcd(dayOfWeek));
     Wire.write(decToBcd(dayOfMonth));
     Wire.write(decToBcd(month));
     Wire.write(decToBcd(year));
     Wire.endTransmission();
  }

  // Establece la fecha y el tiempo del ds1307
  void getDateDs1307(byte *second,
            byte *minute,
            byte *hour,
            byte *dayOfWeek,
            byte *dayOfMonth,
            byte *month,
            byte *year)
  {
  
    // Resetea el registro puntero
    Wire.beginTransmission(DS1307_I2C_ADDRESS);
    Wire.write(0);
    Wire.endTransmission();
    Wire.requestFrom(DS1307_I2C_ADDRESS, 7);

    // Alguno de estos necesitan enmascarar porque ciertos bits son bits de control 

    *second     = bcdToDec(Wire.read() & 0x7f);    
    *minute     = bcdToDec(Wire.read());
    *hour       = bcdToDec(Wire.read() & 0x3f);  // Need to change this if 12 hour am/pm
    *dayOfWeek  = bcdToDec(Wire.read());
    *dayOfMonth = bcdToDec(Wire.read());
    *month      = bcdToDec(Wire.read());
    *year       = bcdToDec(Wire.read());
  }


  ///////////////
  //ILUMINACION//
  ///////////////
  
  //Potencias
  int P_Blancos_6500 =  70; // Potencia Led Blanco 0-100%
  int P_Blancos_4000 =  70; // Potencia AZUL ROYAL DIA 0-100%
  int P_Rojos=   20; // Potencia Led Rojos 0-100%
  int P_Azules=    70; // Potencia Led Azul 0-100%
  int P_MTO =      10; // Potencia Led Blanco MTO 0-100%
  
 
  int P_Ro_ON_Blancos = 15; //Potencia Led Rojos, enciende Blancos Amanecer
  int P_Bla_ON_Rojos = 20;  //Potencia Led Blancos, enciende Rojos Atardecer

  //Horas
  int H_Amanecer =  13; // Hora Fase Amanecer
  int H_Dia =    14; // Hora Fase Dia
  int H_Atardecer = 21; // Hora Fase Atardecer
  int H_Luna =     22; // Hora Fase Luna
  int H_Apagado =    1; // Hora Fase Apagado

///MINUTOS
  int T_Fase1=    14; // Tiempo del efecto en Fase 1 (Rojos ON) 
  int T_Fase2=      45; // Tiempo del efecto en Fase 2 (Blancos ON) 
  int T_Fase3=      1; // Tiempo del efecto en Fase 3 (Rojos OFF)
  int T_Fase5=      35; // Tiempo del efecto en Fase 5 (Blancos OFF) 
  int T_Fase6=      24; // Tiempo del efecto en Fase 5 (Rojos OFF) 
  int T_Fase7=      65; // Tiempo del efecto en Fase 5 (Azules ON)
  int T_Fase8=      1; // Tiempo del efecto en Fase 5 (Azules OFF) 

  //Calculos PWM Potencias
  int PWM_Blancos_6500  =(P_Blancos_6500 * 2.55); 
  int PWM_Blancos_4000  =(P_Blancos_4000 * 2.55); 
  int PWM_Rojos    =(P_Rojos * 1.55);
  int PWM_Azules   =(P_Azules * 2.55);
  int PWM_Rojos_Blancos_ON = (P_Ro_ON_Blancos * 2.55);
  int PWM_MTO = (P_MTO * 2.55);
  
  int Fase = 0;
  
  //Calulos Delay
  long Delay_Fase1 =(T_Fase1 * 60000)/(PWM_Rojos_Blancos_ON);  
  long Delay_Fase2 =(T_Fase2 * 60000)/(PWM_Blancos_6500);
  long Delay_Fase3 =(T_Fase3 * 60000)/(PWM_Rojos);
  long Delay_Fase5 =(T_Fase5 * 60000)/(PWM_Blancos_6500);
  long Delay_Fase6 =(T_Fase6 * 60000)/(PWM_Rojos);
  long Delay_Fase7 =(T_Fase7 * 60000)/(PWM_Azules); 
  long Delay_Fase8 =(T_Fase8 * 60000)/(PWM_Azules);  

  //Calculos Salir Bucles
  int ESC_Delay_Fase1 = (60000 / Delay_Fase1); //60000
    int VESC_Delay_Fase1 = 0;  
  int ESC_Delay_Fase2 = (60000 / Delay_Fase2);
    int VESC_Delay_Fase2 = 0; 
  int ESC_Delay_Fase3 = (60000 / Delay_Fase3);
    int VESC_Delay_Fase3 = 0; 
  int ESC_Delay_Fase5 = (60000 / Delay_Fase5);
    int VESC_Delay_Fase5 = 0;
  int ESC_Delay_Fase6 = (60000 / Delay_Fase6);
    int VESC_Delay_Fase6 = 0;
  int ESC_Delay_Fase7 = (60000 / Delay_Fase7);
    int VESC_Delay_Fase7 = 0;
  int ESC_Delay_Fase8 = (60000 / Delay_Fase8);
    int VESC_Delay_Fase8 = 0;
    
// Se definen las Salidas
const int OUT_PWM_Diurna_6500_1 = 10;        // salida PWM 10, Diurna 6500K
const int OUT_PWM_Diurna_6500_2 = 6;        // salida PWM 6, Diurna 6500K
const int OUT_PWM_Diurna_4000_1 = 5;        // salida PWM 5, Diurna 4000K
const int OUT_PWM_Diurna_4000_2 = 3;        // salida PWM 5, Diurna 4000K
const int OUT_PWM_Nocturna = 9;     //salida PWM 9, Nocturna
const int OUT_PWM_Rojos = 11;     //salida PWM 11, Rojos


// Se definen la Entrada
const int IN_MTO = 2;        // Entrada Mantenimiento
boolean IN_MTO_ON;


//Se definen las marcas registro PWM
int Reg_PWM_Dia_6500;
int Reg_PWM_Dia_4000;
int Reg_PWM_Noche;
int Reg_PWM_Rojos;

//Primer Ciclo
int Ciclo = 0;
int M_1 = 0;
///////////////////////// SETUP //////////////////////////////////
//////////////////////////////////////////////////////////////////
void setup() {
  
     //LCD//
     Serial.begin(9600); 
  
    //RELOJ//
    Wire.begin();
    
  /*    
  //Poner en hora
    second = 00;
    minute = 36;
    hour = 16;
    dayOfWeek = 4;
    dayOfMonth = 14;
    month = 8;
    year = 14;
  
  setDateDs1307(second, minute, hour, dayOfWeek, dayOfMonth, month, year); 
*/
    
  // Se Definen Salidas
  pinMode(OUT_PWM_Diurna_6500_1, OUTPUT);
  pinMode(OUT_PWM_Diurna_6500_2, OUTPUT);
  pinMode(OUT_PWM_Diurna_4000_1, OUTPUT);
  pinMode(OUT_PWM_Diurna_4000_2, OUTPUT);
  pinMode(OUT_PWM_Nocturna, OUTPUT);
  pinMode(OUT_PWM_Rojos, OUTPUT);
  pinMode(IN_MTO, INPUT);
  
  //Define el registro pwm a 0
  Reg_PWM_Dia_6500 = 0;
  Reg_PWM_Dia_4000 = 0;
  Reg_PWM_Noche = 0;
  Reg_PWM_Rojos = 0;
  
  //Leer Memoria
  Mem_Leer();
}

///////////////////////// PROGRAMA //////////////////////////////
/////////////////////////////////////////////////////////////////

void loop(){
  
  //Leer Entrada//////////////////////////////////////////////////////////////////////////////
  IN_MTO_ON = digitalRead(IN_MTO);
  
  ////CONFIRMA ENTRADA MTO////////////
  if (IN_MTO_ON == HIGH)
  {
    delay (5000);
    IN_MTO_ON = digitalRead(IN_MTO);
  }
  
  if (IN_MTO_ON == HIGH) {
    analogWrite(OUT_PWM_Diurna_6500_1, PWM_MTO);
    analogWrite(OUT_PWM_Diurna_6500_2, PWM_MTO);
    analogWrite(OUT_PWM_Diurna_4000_1, PWM_MTO);
    analogWrite(OUT_PWM_Diurna_4000_2, PWM_MTO);
    analogWrite(OUT_PWM_Rojos, 0);
    analogWrite(OUT_PWM_Nocturna, 0);
    M_1 = 1;
  }
    if ((IN_MTO_ON == LOW)&& (M_1 = 1)) {
    analogWrite(OUT_PWM_Diurna_6500_1, Reg_PWM_Dia_6500);
    analogWrite(OUT_PWM_Diurna_6500_2, Reg_PWM_Dia_6500);
    analogWrite(OUT_PWM_Diurna_4000_1, Reg_PWM_Dia_4000);
    analogWrite(OUT_PWM_Diurna_4000_2, Reg_PWM_Dia_4000);
    analogWrite(OUT_PWM_Rojos, Reg_PWM_Rojos);
    analogWrite(OUT_PWM_Nocturna, Reg_PWM_Noche);
    M_1 = 0;
  }
  
    
  //Leer Reloj//////////////////////////////////////////////////////////////////////////////////////////////////
   getDateDs1307(&second, &minute, &hour, &dayOfWeek, &dayOfMonth, &month, &year);  
  
   //Ver reloj en puerto serie//////////////////////////////////////////////////////////////////////////////////
          if (dayOfMonth < 10) Serial.print("0");
          Serial.print(dayOfMonth, DEC); 
          Serial.print("/"); 
        if (month < 10) Serial.print("0");
          Serial.print(month, DEC); 
          Serial.print("/");
          Serial.print("20");
          Serial.print(year, DEC);
    
          Serial.print("     ");
        if (hour < 10) Serial.print("0");
          Serial.print(hour, DEC);
          Serial.print(":");  
        if (minute < 10) Serial.print("0");
          Serial.print(minute, DEC);
          Serial.print(":");  
           if (second < 10) Serial.print("0");
          Serial.print(second, DEC);
          
          Serial.print("     ");
          Serial.print("Rojos");
          Serial.print("-");
          Serial.print(Reg_PWM_Rojos);
          Serial.print("  Blacos 6500");
          Serial.print("-");
          Serial.print(Reg_PWM_Dia_6500);
          Serial.print("  Blacos 4000");
          Serial.print("-");
          Serial.print(Reg_PWM_Dia_4000);
          Serial.print("  Azules");
          Serial.print("-");
          Serial.print(Reg_PWM_Noche);
          Serial.print(" MTO - ");
          Serial.print(IN_MTO_ON);  
          Serial.print(" Fase - ");
          Serial.println(Fase);        
       
       delay (100); 
       if (((Fase == 4) || (Fase == 0)|| (Fase == 8))&& Ciclo == 1) {delay (10000);}
  
    ////////////////////////////////
    //Fase 1,Fase2,Fase3 AMANECER //
    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    
   if ((Fase == 0) &&  (hour >= H_Amanecer)) Fase = 1; 
  while ((hour >= H_Amanecer)&&(hour < H_Dia) && (Fase < 4)) //Funcion mientras
  { 
    //Salir Bucle Por Tiempo
     if ((VESC_Delay_Fase1 >= ESC_Delay_Fase1) || (VESC_Delay_Fase2 >= ESC_Delay_Fase2) || (VESC_Delay_Fase3 >= ESC_Delay_Fase3)) {
                VESC_Delay_Fase1 = 0;
                VESC_Delay_Fase2 = 0;
                VESC_Delay_Fase3 = 0;
                 break;
     }
     
  //Luz Dia Rojos ON (FASE 1)/////////////////////////////////////
  if ((Reg_PWM_Rojos < PWM_Rojos)&& (Fase == 1)) 
  { 
  Reg_PWM_Rojos++;                                         //Incremento del registro
  if (IN_MTO_ON == LOW) analogWrite(OUT_PWM_Rojos, Reg_PWM_Rojos);   // Escribe el registro PWM en Salida Rojos
  delay(Delay_Fase1);
  VESC_Delay_Fase1++;
  Men_Escribir();
  }
  if (Reg_PWM_Rojos == PWM_Rojos_Blancos_ON) {Fase = 2; VESC_Delay_Fase1 = 0;}
  
  
    //Luz Dia Dia ON (FASE 2)////////////////////////////////////////    
  if ((Reg_PWM_Dia_6500 < PWM_Blancos_6500) && (Fase == 2)) 
  { 
  Reg_PWM_Dia_6500++;  //Incremento del registro 6500K
  
  if (Reg_PWM_Dia_4000 < PWM_Blancos_4000) //4000K
        {
          Reg_PWM_Dia_4000++;  //Incremento del registro 4000K
        }
    
  if (IN_MTO_ON == LOW) {
    analogWrite(OUT_PWM_Diurna_6500_1, Reg_PWM_Dia_6500);    // Escribe el registro PWM en Salida Diurna 6500K
    analogWrite(OUT_PWM_Diurna_6500_2, Reg_PWM_Dia_6500);    // Escribe el registro PWM en Salida Diurna 6500K
    analogWrite(OUT_PWM_Diurna_4000_1, Reg_PWM_Dia_4000);    // Escribe el registro PWM en Salida Diurna  
    analogWrite(OUT_PWM_Diurna_4000_2, Reg_PWM_Dia_4000);    // Escribe el registro PWM en Salida Diurna    
    }
  if (Reg_PWM_Rojos < PWM_Rojos) 
          { 
            Reg_PWM_Rojos++;                                         //Incremento del registro
  if (IN_MTO_ON == LOW) analogWrite(OUT_PWM_Rojos, Reg_PWM_Rojos);   // Escribe el registro PWM en Salida Rojos
            }
   delay (Delay_Fase2);    //Temporizador espera ms
   VESC_Delay_Fase2++;
    Men_Escribir();
  }
  if (Reg_PWM_Dia_6500 == PWM_Blancos_6500) {Fase = 3; VESC_Delay_Fase2 = 0;}
    //Luz Rojos Dia OFF (FASE 3)////////////////////////////////////////////
    if ((Reg_PWM_Rojos > 0) && (Fase == 3)){
    Reg_PWM_Rojos--; 
    if (IN_MTO_ON == LOW) analogWrite(OUT_PWM_Rojos, Reg_PWM_Rojos); 
    delay (Delay_Fase3);
    VESC_Delay_Fase3++;
     Men_Escribir();
    }
    if ((Reg_PWM_Rojos == 0) && (Fase == 3)) {Fase = 4; break;}
  }


    ////////////////////////////////
    //        Fase 4 DIA          //
    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    
    if ((hour >= H_Dia) && (hour < H_Atardecer))
    {
      Reg_PWM_Noche = 0;
      Reg_PWM_Rojos = 0;
      Reg_PWM_Dia_6500 = PWM_Blancos_6500;
      Reg_PWM_Dia_4000 = PWM_Blancos_4000;  
      
        if (IN_MTO_ON == LOW) {
          analogWrite(OUT_PWM_Diurna_6500_1, Reg_PWM_Dia_6500); 
          analogWrite(OUT_PWM_Diurna_6500_2, Reg_PWM_Dia_6500); 
          analogWrite(OUT_PWM_Diurna_4000_1, Reg_PWM_Dia_4000);
          analogWrite(OUT_PWM_Diurna_4000_2, Reg_PWM_Dia_4000);
          analogWrite(OUT_PWM_Rojos, Reg_PWM_Rojos);
          analogWrite(OUT_PWM_Nocturna, Reg_PWM_Noche);
          
        }
        Fase = 4;
        Men_Escribir();
    }
    
   ///////////////////////////////////////////
  //     Fase 5, Fase 6, Fase 7 (ATARDECER) //
  ////////////////////////////////////////////////////////////////////////////////////  

  while ((hour >= H_Atardecer) && (Fase > 3 && Fase < 8)) { 
    if (Fase == 4) Fase = 5;
    
        //Salir Bucle Por Tiempo
     if ((VESC_Delay_Fase5 >= ESC_Delay_Fase5) || (VESC_Delay_Fase6 >= ESC_Delay_Fase6) || (VESC_Delay_Fase7 >= ESC_Delay_Fase7)) {
                VESC_Delay_Fase5 = 0;
                VESC_Delay_Fase6 = 0;
                VESC_Delay_Fase7 = 0;
                 break;
     }
     
    //Atardecer Blancos FASE 5//////////////////////////////////////////////////////////////////
   if  ((Reg_PWM_Dia_6500 > 0) && (Fase == 5)){
  Reg_PWM_Dia_6500--;                                         //Decremento del registro 6500K
    if (Reg_PWM_Dia_4000 > 0) Reg_PWM_Dia_4000--;
  Reg_PWM_Rojos = PWM_Rojos;
  if (IN_MTO_ON == LOW) {
    analogWrite(OUT_PWM_Diurna_6500_1, Reg_PWM_Dia_6500);   // Escribe el registro PWM en Salida Blancos 6500
    analogWrite(OUT_PWM_Diurna_6500_2, Reg_PWM_Dia_6500);   // Escribe el registro PWM en Salida Blancos 6500
    analogWrite(OUT_PWM_Diurna_4000_1, Reg_PWM_Dia_4000);   // Escribe el registro PWM en Salida Blancos 4000 
    analogWrite(OUT_PWM_Diurna_4000_2, Reg_PWM_Dia_4000);   // Escribe el registro PWM en Salida Blancos 4000
    analogWrite(OUT_PWM_Rojos, Reg_PWM_Rojos);
      }
      
  delay(Delay_Fase5);
  VESC_Delay_Fase5++;
   Men_Escribir();
  }
  if ((Reg_PWM_Dia_6500 == 0) && (Fase == 5)) {Fase = 6; VESC_Delay_Fase5 = 0; break;} 
    
    
     //Atardecer Rojos y Azules ON FASE 6
   if  ((Reg_PWM_Rojos > 0) && (Fase == 6)){                                       
  Reg_PWM_Rojos--;
  Reg_PWM_Noche++;
 if (IN_MTO_ON == LOW)  analogWrite(OUT_PWM_Nocturna, Reg_PWM_Noche);   // Escribe el registro PWM en Salida Azules
 if (IN_MTO_ON == LOW)  analogWrite(OUT_PWM_Rojos, Reg_PWM_Rojos);
  delay(Delay_Fase6);
  VESC_Delay_Fase6++;
   Men_Escribir();
  }
  if ((Reg_PWM_Rojos == 0) && (Fase == 6)) {Fase = 7; VESC_Delay_Fase6 = 0; break;} 
  
  //Luna Subir FASE 7
  if ((Reg_PWM_Noche < PWM_Azules)&&(Fase == 7))
  {
  Reg_PWM_Noche++;
  if (IN_MTO_ON == LOW) analogWrite(OUT_PWM_Nocturna, Reg_PWM_Noche);   // Escribe el registro PWM en Salida Azules
  delay(Delay_Fase7);
  VESC_Delay_Fase7++; 
   Men_Escribir();
  }
   if ((Reg_PWM_Noche == PWM_Azules) && (Fase == 7)) {Fase = 8; VESC_Delay_Fase7 = 0; break;} 
  } 
  
  
   ///////////////////////////////////////////
  //     Fase 8,  (ATARDECER LUNA) ///////////
  ////////////////////////////////////////////  

  while ((hour == H_Luna )&& (Fase == 8)) {
    
         //Salir Bucle Por Tiempo
     if (VESC_Delay_Fase8 >= ESC_Delay_Fase8) {
                VESC_Delay_Fase8 = 0;
                 break;
     }
    if (Reg_PWM_Noche > 0)
    {
   Reg_PWM_Noche--;
  if (IN_MTO_ON == LOW) analogWrite(OUT_PWM_Nocturna, Reg_PWM_Noche);   // Escribe el registro PWM en Salida Azules
  delay(Delay_Fase8);
  VESC_Delay_Fase8++;
  Men_Escribir(); 
  }
   if (Reg_PWM_Noche == 0) {Fase = 0; VESC_Delay_Fase8 = 0; break;} 
  } 
  
 /////APAGADO TOTAL///
if ((Fase == 0) || ((hour >= H_Apagado) && (hour < H_Amanecer)))
{
  Reg_PWM_Noche = 0;
  Reg_PWM_Rojos = 0;
  Reg_PWM_Dia_6500 = 0;
  Reg_PWM_Dia_4000 = 0;
  
  if (IN_MTO_ON == LOW) {
    analogWrite(OUT_PWM_Nocturna, Reg_PWM_Noche);
    analogWrite(OUT_PWM_Rojos, Reg_PWM_Rojos);
    analogWrite(OUT_PWM_Diurna_6500_1, Reg_PWM_Dia_6500);
    analogWrite(OUT_PWM_Diurna_6500_2, Reg_PWM_Dia_6500);
    analogWrite(OUT_PWM_Diurna_4000_1, Reg_PWM_Dia_4000);
    analogWrite(OUT_PWM_Diurna_4000_2, Reg_PWM_Dia_4000);
  }
  Men_Escribir();
}

  if (Ciclo == 0) Ciclo = 1;
  } 
  
  //EEPROM

//Escribir
void Men_Escribir() 
{
   EEPROM.write(0, Fase);
   EEPROM.write(1, Reg_PWM_Dia_6500);
   EEPROM.write(2, Reg_PWM_Noche);
   EEPROM.write(3, Reg_PWM_Rojos);
   EEPROM.write(4, Reg_PWM_Dia_4000);
}

//Leer

void Mem_Leer()
{ 
  
  Fase = EEPROM.read(0); 
  Reg_PWM_Dia_6500 = EEPROM.read(1);
  Reg_PWM_Noche = EEPROM.read(2);
  Reg_PWM_Rojos = EEPROM.read(3);
  Reg_PWM_Dia_4000 = EEPROM.read(4);
 
}

Fallaria en el cambio de fase 2 se queda clavada en la luz roja, ni conecta la luz dia 6500 ni la luz dia 4000 ni va desvaneciendo el rojo en si. Ademas el color rojo aunque le he bajado la potencia al 15% ni se mueve, esta a tope diria yo… Si por ejemplo desconecto la fuente y la conecto cuando le toca fase 2 funciona correctamente, no se que puede ser

Si el código es grande solo lo subes como adjunto y nadie te va a reclamar!!!

Bueno a ver de que se trata el resto.

Primer comentario : Has visto si esta condición se cumple?
Agrega un Serial.println("Fase 2"); dentro de esto

if (Reg_PWM_Rojos == PWM_Rojos_Blancos_ON) {
      Fase = 2; 
      Serial.println("Fase 2");
      VESC_Delay_Fase1 = 0;
  }

eso quiere decir que si estan los rojos encendidos conecta los blancos? pues deberia porque cuando llego a comer estan los rojos a tope y si no lo toco se pegan todo el dia encendidos hasta el horario de apagar todo

Yo no te pregunté eso. Te pregunte si esa función modificada se ve en el Serial.
COmo para indicar que llegaste a Fase = 2.
Tu dices que justo despues empieza el problema por eso te consulté pro esto.

seria cuerstion de sustituir

if (Reg_PWM_Rojos == PWM_Rojos_Blancos_ON) {Fase = 2; VESC_Delay_Fase1 = 0;}

por lo que me comentas?

meter un serialprinln en esa parte? Porque funciona en el resto de fases si al final de la anterior no hay un serial.println?

Calcenika perdona pero no lees lo que te sugerí en el post#7 y le das y le das vuelta a lo mismo.
Lee y te lo pego acá para que quede claro.

surbyte:
Primer comentario : Has visto si esta condición se cumple?
Agrega un Serial.println("Fase 2"); dentro de esto

if (Reg_PWM_Rojos == PWM_Rojos_Blancos_ON) {

Fase = 2;
      Serial.println("Fase 2");
      VESC_Delay_Fase1 = 0;
  }