Time controlled LEDs

Hi,
i’m running a RTC controlled LED lighting with fadeIns and Fadeouts.
Since this arduino board is installed where the lightin is, I bought a second Arduino board to continue other projects or work on the current one.
Unfortunately I do not have a second RTC board.

What did I do? Instead of saying run any void at e.g. 8:30 am, I use millis(). That way I do not need RTC for testing.
Unfortunately it aint working.

Here is a part of my code:

for (int loop=0; loop<MAX_STRIPES; loop++) {
            if (millis() == hourfadein[loop]) {
                      currmillis[loop]=millis();
                      i[loop]=0;
                      a[loop]=1;
                      check[loop]=1;
                      intervall[loop]=intervallfadein[loop];
            }

Usually I have a time set up for hourfadein[loop]. This time I used a value like 3000 (ms). Meaning after exactly 3000 ms the loop should start.
My question: is this at all possible or is this the problem for my project not working without RTC?
Could it be, that the arduino is not fast enough to be at this part of the code at exactly 3000? Like running through the entire code takes a few ms I guess. So could it be the arduino gets there at e.g. 3013ms and then the == is wrong?

Any help appreciated.

Here is the entire code. Please have a look. It might also be an issue with my random() code => cause this one is also new and not tested on my lighting.
Sorry, some things are in German that explain the code. But its not a hard one for you to understand I guess!

//////////WICHTIGE SETUP-DATEN FÜR LEDs//////////////////
#define MAX_STRIPES 5
byte stripePin[] = {8, 9, 10, 11, 12}; //8=weiss 9=blau 10=blau+UV 11=weiss+rot, 12=moon
int i[] = {0, 0, 0, 0, 0};
int a[] = {0, 0, 0, 0, 0}; 
int check[] = {0, 0, 0, 0, 0};
long currmillis[5];
long timemillis = 0;
float intervall[5];
float intervallfadein[] = {1*60000/256, 1*60000/256, 1*60000/256, 1*60000/256, 1*60000/256};
float intervallnoon[] = {1*60000/256, 1*60000/256, 1*60000/256, 1*60000/256, 1*60000/256};
float intervallfadeout[] = {1*60000/256, 1*60000/256, 1*60000/256, 1*60000/256, 1*60000/256}; //jeweils erste Zahl = Fadingdauer im Minuten
byte hourfadein[] = {2000, 2500, 3000, 4000, 5000};
byte noonhourfadeout[] = {15000, 15000, 15000, 15000, 15000};
byte noonhourfadein[] = {25000, 25000, 25000, 25000, 25000};
byte hourfadeout[] = {40000, 42000, 44000, 46000, 48000};   
int zufall[5];
int store[5];
//////////ENDE WICHTIGE SETUP-DATEN FÜR LEDs//////////////////

void setup()
{
 

   /////////////LEDs//////////////////
   pinMode(stripePin[0], OUTPUT);
   digitalWrite(stripePin[0], LOW);
   pinMode(stripePin[1], OUTPUT);
   digitalWrite(stripePin[1], LOW);
   pinMode(stripePin[2], OUTPUT);
   digitalWrite(stripePin[2], LOW);
   pinMode(stripePin[3], OUTPUT);
   digitalWrite(stripePin[3], LOW);
   pinMode(stripePin[4], OUTPUT);
   digitalWrite(stripePin[4], LOW);

   /////////////ENDE LEDs//////////////////
}

void loop()
{



  for (int loop=0; loop<MAX_STRIPES; loop++) {
            if (millis() == hourfadein[loop]) {
                      currmillis[loop]=millis();
                      i[loop]=0;
                      a[loop]=1;
                      check[loop]=1;
                      intervall[loop]=intervallfadein[loop];
            }
             else if (millis() == noonhourfadeout[loop]) {
                      currmillis[loop]=millis();
                      i[loop]=255;
                      a[loop]=-1;
                      check[loop]=2;
                      zufall[loop]=random(256);
                      intervall[loop]=intervallnoon[loop];
            }
             else if (millis() == noonhourfadein[loop]) {
                      currmillis[loop]=millis();
                      i[loop]=store[loop];
                      a[loop]=1;
                      check[loop]=1;
                      intervall[loop]=intervallnoon[loop];
            }    
            else if (millis() == hourfadeout[loop]) {
                      currmillis[loop]=millis();
                      i[loop]=255;
                      a[loop]=-1;
                      check[loop]=1;
                      intervall[loop]=intervallfadeout[loop];
            }
             if (a[loop]!=0 && (millis() - currmillis[loop]) > intervall[loop] && check[loop] == 1) {
                      currmillis[loop] = millis();
                      i[loop]+=a[loop];
                      switch(i[loop]) {
                          case 0:
                              digitalWrite(stripePin[loop], LOW);
                              a[loop]=0;
                              check[loop] == 0;
                              break;
                          case 255:
                              digitalWrite(stripePin[loop], HIGH);
                              a[loop]=0;
                              check[loop] == 0;
                              break;
                          default:
                              analogWrite(stripePin[loop], i[loop]);
                      }
            }
             else if (a[loop]!=0 && (millis() - currmillis[loop]) > intervall[loop] && check[loop] == 2) {
                      currmillis[loop] = millis();
                      i[loop]+=a[loop];
                      if (i[loop]>zufall[loop]) {
                          analogWrite(stripePin[loop], i[loop]);
                      }
                      else {
                        store[loop]=i[loop];
                        a[loop]=0;
                        
                      }
             }
  }



 }

And here we go with the code including RTC and the new random part!
The random part:

else if (minute == noonminutefadein[loop] && hour == noonhourfadein[loop] && second == 0) {
                      currmillis[loop]=millis();
                      i[loop]=store[loop];
                      a[loop]=1;
                      check[loop]=1;
                      intervall[loop]=intervallnoon[loop];
            }    
            else if (minute == minutefadeout[loop] && hour == hourfadeout[loop] && second == 0) {
                      currmillis[loop]=millis();
                      i[loop]=255;
                      a[loop]=-1;
                      check[loop]=1;
                      intervall[loop]=intervallfadeout[loop];
            }

.
.
.
else if (a[loop]!=0 && (millis() - currmillis[loop]) > intervall[loop] && check[loop] == 2) {
                      currmillis[loop] = millis();
                      i[loop]+=a[loop];
                      if (i[loop]>zufall[loop]) {
                          analogWrite(stripePin[loop], i[loop]);
                      }
                      else {
                        store[loop]=i[loop];
                        a[loop]=0;
                        
                      }
            }

Entire code:

//////////WICHTIGE SETUP-DATEN FÜR REALTIME UHRZEIT//////////////////
#include "Wire.h"
#define DS1307_I2C_ADDRESS 0x68
byte decToBcd(byte val)
{
  return ( (val/10*16) + (val%10) );
}
byte bcdToDec(byte val)
{
  return ( (val/16*10) + (val%16) );
}
//////////ENDE WICHTIGE DATEN FÜR REALTIME UHRZEIT////////////////


//////////WICHTIGE SETUP-DATEN FÜR LEDs//////////////////
#define MAX_STRIPES 5
byte stripePin[] = {8, 9, 10, 11, 12}; //8=weiss 9=blau 10=blau+UV 11=weiss+rot, 12=moon
int i[] = {0, 0, 0, 0, 0};
int a[] = {0, 0, 0, 0, 0}; 
int check[] = {0, 0, 0, 0, 0};
long currmillis[5];
long timemillis = 0;
float intervall[5];
float intervallfadein[] = {90*60000/256, 60*60000/256, 120*60000/256, 90*60000/256, 30*60000/256};
float intervallnoon[] = {10*60000/256, 10*60000/256, 10*60000/256, 10*60000/256, 10*60000/256};
float intervallfadeout[] = {60*60000/256, 90*60000/256, 90*60000/256, 90*60000/256, 30*60000/256}; //jeweils erste Zahl = Fadingdauer im Minuten
byte hourfadein[] = {8, 8, 10, 10, 20};
byte noonhourfadeout[] = {13, 13, 13, 13, 13};
byte noonhourfadein[] = {14, 14, 14, 14, 14};
byte hourfadeout[] = {19, 19, 17, 17, 8};   
byte minutefadein[] = {0, 0, 30, 30, 30};
byte noonminutefadeout[] = {0, 0, 0, 0, 0};
byte noonminutefadein[] = {15, 15, 15, 15, 15};
byte minutefadeout[] = {0, 30, 0, 0, 0};
int zufall[5];
int store[5];
//////////ENDE WICHTIGE SETUP-DATEN FÜR LEDs//////////////////



//////////FUNKTION FÜR UHRZEIT//////////////////
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.send(0);
   Wire.send(decToBcd(second));    // 0 to bit 7 starts the clock
   Wire.send(decToBcd(minute));
   Wire.send(decToBcd(hour));     
   Wire.send(decToBcd(dayOfWeek));
   Wire.send(decToBcd(dayOfMonth));
   Wire.send(decToBcd(month));
   Wire.send(decToBcd(year));
   Wire.endTransmission();
}
void getDateDs1307(byte *second,
          byte *minute,
          byte *hour,
          byte *dayOfWeek,
          byte *dayOfMonth,
          byte *month,
          byte *year)
{
  Wire.beginTransmission(DS1307_I2C_ADDRESS);
  Wire.send(0);
  Wire.endTransmission();

  Wire.requestFrom(DS1307_I2C_ADDRESS, 7);

  *second     = bcdToDec(Wire.receive() & 0x7f);
  *minute     = bcdToDec(Wire.receive());
  *hour       = bcdToDec(Wire.receive() & 0x3f);  // Need to change this if 12 hour am/pm
  *dayOfWeek  = bcdToDec(Wire.receive());
  *dayOfMonth = bcdToDec(Wire.receive());
  *month      = bcdToDec(Wire.receive());
  *year       = bcdToDec(Wire.receive());
}
//////////ENDE FUNKTION FÜR UHRZEIT//////////////////


void setup()
{
  /////////////UHRZEIT////////////////// ZUM UHRZEIT STELLEN EINTRAGEN UND SETDATE FÜR UPLOAD AKTIVIEREN//////
  byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;
  Wire.begin();
 Serial.begin(9600);
//    minute = 46;
//    hour = 23;
//    dayOfWeek = 6;
//    dayOfMonth = 5;
//    month = 2;
//    year = 10;
//    setDateDs1307(second, minute, hour, dayOfWeek, dayOfMonth, month, year);
  //////////////UHRZEIT ENDE//////////////

   /////////////LEDs//////////////////
   pinMode(stripePin[0], OUTPUT);
   digitalWrite(stripePin[0], LOW);
   pinMode(stripePin[1], OUTPUT);
   digitalWrite(stripePin[1], LOW);
   pinMode(stripePin[2], OUTPUT);
   digitalWrite(stripePin[2], LOW);
   pinMode(stripePin[3], OUTPUT);
   digitalWrite(stripePin[3], LOW);
   pinMode(stripePin[4], OUTPUT);
   digitalWrite(stripePin[4], LOW);

   /////////////ENDE LEDs//////////////////
}

void loop()
{
  byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;


  for (int loop=0; loop<MAX_STRIPES; loop++) {
            if (minute == minutefadein[loop] && hour == hourfadein[loop] && second == 0) {
                      currmillis[loop]=millis();
                      i[loop]=0;
                      a[loop]=1;
                      check[loop]=1;
                      intervall[loop]=intervallfadein[loop];
            }
             else if (minute == noonminutefadeout[loop] && hour == noonhourfadeout[loop] && second == 0) {
                      currmillis[loop]=millis();
                      i[loop]=255;
                      a[loop]=-1;
                      check[loop]=2;
                      zufall[loop]=random(256);
                      intervall[loop]=intervallnoon[loop];
            }
             else if (minute == noonminutefadein[loop] && hour == noonhourfadein[loop] && second == 0) {
                      currmillis[loop]=millis();
                      i[loop]=store[loop];
                      a[loop]=1;
                      check[loop]=1;
                      intervall[loop]=intervallnoon[loop];
            }    
            else if (minute == minutefadeout[loop] && hour == hourfadeout[loop] && second == 0) {
                      currmillis[loop]=millis();
                      i[loop]=255;
                      a[loop]=-1;
                      check[loop]=1;
                      intervall[loop]=intervallfadeout[loop];
            }
             if (a[loop]!=0 && (millis() - currmillis[loop]) > intervall[loop] && check[loop] == 1) {
                      currmillis[loop] = millis();
                      i[loop]+=a[loop];
                      switch(i[loop]) {
                          case 0:
                              digitalWrite(stripePin[loop], LOW);
                              a[loop]=0;
                              check[loop] == 0;
                              break;
                          case 255:
                              digitalWrite(stripePin[loop], HIGH);
                              a[loop]=0;
                              check[loop] == 0;
                              break;
                          default:
                              analogWrite(stripePin[loop], i[loop]);
                      }
            }
            else if (a[loop]!=0 && (millis() - currmillis[loop]) > intervall[loop] && check[loop] == 2) {
                      currmillis[loop] = millis();
                      i[loop]+=a[loop];
                      if (i[loop]>zufall[loop]) {
                          analogWrite(stripePin[loop], i[loop]);
                      }
                      else {
                        store[loop]=i[loop];
                        a[loop]=0;
                        
                      }
            }
  }


//Ausgabe Uhrzeit//
if (millis() - timemillis > 1000) {
  timemillis = millis();
  getDateDs1307(&second, &minute, &hour, &dayOfWeek, &dayOfMonth, &month, &year);
  Serial.print(hour, DEC);
  Serial.print(":");
  Serial.print(minute, DEC);
  Serial.print(":");
  Serial.print(second, DEC);
  Serial.print("  ");
  Serial.print(dayOfMonth, DEC);
  Serial.print(".");  
  Serial.print(month, DEC);
  Serial.print(".");
  Serial.print(year, DEC);
  Serial.print("  Tag:");
  Serial.println(dayOfWeek, DEC);
  }
 }