Ok let me try and explain the problem here. I am using a millis() and % modulo method of creating Ledstrip patterns, but somehow 1 of my patterns started to 'malfunction' after a few weeks of running (the patterns are triggered via a random generator and i noticed it but it took me a few days to actually try and find out what is happening, but i think i got it ! )

Since it is the only pattern, It's not such a big deal, but every time i reset the unit the problem was gone. Anyway i've come to the conclusion that casting a millis() value into a 'float' makes it lose it final few bytes of accuracy , in fact i drop it down from 32 bit to 23 bit (right ? hmm that would mean it would already happen after a few hours, though i may not visibly be able to notice for much later. ) and as long as millis() is smaller than the maximum 23-bit (float value) there is no issue.

Ok, the sketch example, i think i'll simplify as much as possible, in the end i need a uint32_t value again.

```
uint32_t manixmoment; // the final value
float manixvalue = ManixValue(val,j); // the function returns a value between 1.0 & 3.0 approx
// val is a uint8_t , and j is a counter between 0 - 9
manixmoment=(uint32_t) ((float) moment * manixvalue); // here is my cast
//.....
```

and ManixValue()

```
float ManixValue (uint8_t val, uint8_t depth) { // depth here can be between 0 - 9
return 1.0 + ((float) depth * ((float) val / 127.0)) / 10.0;
}
```

I hope i have demonstrated the issue, how can i multiply my 32-bit variable with a value between 1.0 & 3.0 ? Just to confirm that the cast is in fact the problem, the issue is also there if ManixValue() returns 1.0

Of course as i am writing this possible solutions are coming to mind, the simplest probably being i could start my calculation with a maximum elapsed time value of 45 minutes... but i am still wondering if there is a better solution.