Attualmente, la funzione di dissolvenza inizia da 0 e si interpola efficacemente fino al colore desiderato. Per sfumare tra i colori, avresti bisogno che lo schizzo ricordi il colore precedente che ha usato e inizi a sbiadire da quello invece che da 0.

L'approccio che userei è iniziare calcolando quanto ogni componente deve cambiare di volta in volta. Ad esempio, se si desidera sfumare da 100 a 200 su 50 passaggi, è necessario modificare di +2 a ogni passaggio. Se si desidera eseguire la stessa operazione al contrario (da 200 a 100), dovrebbe cambiare di -2.

Uno dei problemi è che ogni componente cambierà probabilmente di una quantità diversa (il rosso potrebbe va da 0 a 200, ma il blu può andare solo da 50 a 70). Se utilizzi sempre numeri interi, potrebbero verificarsi transizioni irregolari, quindi ti consiglio di utilizzare il punto mobile. È tecnicamente più lento (meno efficiente), ma probabilmente non abbastanza di cui preoccuparsi.

Probabilmente lo scriverei così:

  void fade (uint8_t oldR, uint8_t oldG, uint8_t oldB, uint8_t newR, uint8_t newG, uint8_t newB, uint32_t numSteps, uint32_t waitPerStep) {// Guardati dalla divisione per zero if (numSteps == 0) numSteps = 1; // Calcola quanto ogni colore deve cambiare in ogni passaggio const float stepR = (newR - oldR) / (float) numSteps, stepG = (newG - oldG) / (float) numSteps, stepB = (newB - oldB) / (float) numSteps; // Questi valori memorizzeranno i nostri colori lungo il percorso float r = oldR, g = oldG, b = oldB; uint8_t byteR = vecchioR, byteG = vecchioG, byteB = vecchioB; // Passa attraverso ogni passo di dissolvenza const uint16_t numPixels = strip.numPixels (); for (uint32_t step = 0; step < numSteps; ++ step) {// Sposta un passaggio verso il colore target r + = stepR; g + = stepG; b + = stepB; // Arrotonda i colori ai numeri interi qui così non dobbiamo farlo ripetutamente nel ciclo sotto byteR = (uint8_t) (r + 0.5f);
byteG = (uint8_t) (g + 0,5f); byteB = (uint8_t) (b + 0,5f); // Applica il colore a ogni pixel per (uint16_t pixel = 0; pixel < numPixels; ++ pixel) {strip.setPixelColor (pixel, byteR, byteG, byteB); } strip.show (); ritardo (waitPerStep); }}  

Come puoi vedere, gli passi il vecchio colore (che stai sbiadendo da ) e il nuovo colore (che stai sbiadendo a ). Come accennato in precedenza, questo significa che il tuo schizzo deve ricordare quale colore è stato utilizzato in precedenza, poiché non credo che la libreria fornisca un modo per leggere il colore corrente.

Ho incluso alcune ottimizzazioni in lì per farlo funzionare più velocemente. C'è di più che potresti fare per ottimizzarlo ulteriormente, se necessario.

Per usarlo, dovresti fare qualcosa del genere:

  // Dissolvenza dal nero al rosso e pausa brevemente dissolvenza (0, 0, 0, 255, 0, 0, 100, 10); ritardo (500); // dissolvenza dal rosso al viola e pausa breve dissolvenza (255, 0, 0, 255, 0, 255, 100 , 10); delay (500); // Dissolvenza dal viola al verde e pausa brevemente dissolvenza (255, 0, 255, 0, 255, 0, 100, 10); delay (500);  

Ho apportato un paio di altre modifiche rispetto alla tua funzione di dissolvenza. Prima di tutto, ho fatto in modo che tu possa impostare il numero di passaggi per la dissolvenza. Questo può essere molto utile perché cambi di colore più grandi richiederanno più passaggi per avere un aspetto uniforme.

Ho anche modificato il parametro wait . Nel tuo codice, inserisci il ritardo dopo che l'intera dissolvenza è stata completata, il che sembra un approccio strano. Ha più senso consentire un piccolo ritardo tra ogni fase della dissolvenza, in modo da poter controllare la velocità con cui va.

Nel mio esempio sopra, puoi vedere i parametri 100, 10 alla fine di ogni chiamata a fade () . Ciò significa che dividerà il cambio di colore in 100 passaggi, con un ritardo di 10 ms tra ogni passaggio. Il risultato è che ogni dissolvenza richiederà circa 1 secondo (senza contare il tempo impiegato per aggiornare effettivamente la striscia LED).