Wyświetlacz widma audio – ESP32 i 399 WS2812B

[_LM_]

No elegancja Francja trochę nerwowe te słupki, można zmieniać czas narastania i opadania? 

[Gieneq]

@_LM_ Dzięki!  Tak próbowałem coś takiego zrobić, ale w takim kodzie na taśmę klejącą, gdzie próbkowanie sygnału jest na delayach to nie ma sensu. Dlatego jak rozłożę zadania na rdzenie to będzie do zrobienia.

Nie mam jeszcze pomysłu jak rozdysponować zadania. Na pewno próbkowanie trzeba wydzielić do timera, który będzie zasilać bufor 512 próbek. Myślę że na tym samym rdzeniu można by puścić wyznaczanie FFT. Wtedy drugi rdzeń zająłby się obliczaniem animacji przejścia (czyli te opóźnienia) i sterowaniem diodami.

Samo FFT da się wykonywać z częstotliwością 40 Hz więc to ono jest tu wąskim gardłem który trzeba oddzielić od innych zadań.

[Gieneq]

Kolejna drobna aktualizacja. Usiadłęm do tematu timerów i użycia dwóch rdzeni ESP32 i okazało się, że nie jest to zbyt trudne (chyba że nie jestem czegoś świadom...).

Uznałem że zrobię tak:

• Core 0 - przeliczanie FFT na wysokość słupków i próbkowanie sygnału w przerwaniu od timera
• Core 1 - obliczenia na tablicy 19 doublów, które otrzymujemy z działań FFT, animacje, sterowanie matrycą.

Mam więc 2 taski i jedno przerwanie. Wymyśliłem więc że próbki wrzucam do bufora o 2x większej długości i inkrementuję indeks. W momęcie potrzeby wczytania próbek do algorytmu FFT cofam sięod indeksu z ewentualnym przeskokiem na koniec tablicy:

void load_samples(int read_index, volatile int* read_buffer, const int buffersize) {
    for (int i = 0; i < SAMPLES_COUNT; i++) {
        vReal[i] = read_buffer[read_index--];
        vImag[i] = 0;
        if(read_index < 0)
            read_index = buffersize-1;
    }
}

Samo próbkowanie nie jest jakieś wybitnie skomplikowane:

void IRAM_ATTR on_timer_sample() {
  portENTER_CRITICAL_ISR(&sampling_timerMux);
  adc_readings_counter++;
  readings_buffer[reading_buffer_index++] = analogRead(A6);
  if(reading_buffer_index >= READING_BUFFER_SIZE)
    reading_buffer_index = 0;
  portEXIT_CRITICAL_ISR(&sampling_timerMux);
}

W pętli głównej taska dla Core 0 wykonuję przepisanie próbek > obliczenie FFT > przepisanie pasków:

        load_samples(reading_buffer_index, readings_buffer, READING_BUFFER_SIZE);
        calculate_bars();
        double* fft_bars = get_heights();
        for(int i = 0; i < BARS_COUNT; i++)
            bars[i] = fft_bars[i];

Oczywiście pamiętam o volatile:

constexpr int READING_BUFFER_SIZE = 512 * 2;	
volatile int adc_readings_counter;
volatile int readings_buffer[READING_BUFFER_SIZE];
volatile int reading_buffer_index = 0;
hw_timer_t * sampling_timer = NULL;
portMUX_TYPE sampling_timerMux = portMUX_INITIALIZER_UNLOCKED;

Przyspieszenie jest naprawdę spore. Core 0 odświeża się z częstotliwością 30 Hz, głównym winowajcą jest algorytm FFT ale mam pomysł jak go trochę odchudzić, żeby Core 1 miał więcej do roboty. Core 1 za to nie ma na razie nic do roboty i dostał delay, bo bez miałem piękną częstotliwość odświeżania 0,5 MHz.

Na podglądzie widać wypisany bufor próbek, minimalna wartość trafiła się około 600, max około 3000. Widać też częstotliwości odświeżania i obliczoną częstotliwość próbkowania, która jest zaskakująco precyzyjna  

Patrząc na wygnał w ciszy od razu wpadłem na to, że można uprościć algorytm FFT, a dokładnie tę funkcję:

void arduinoFFT::DCRemoval()
{
	// calculate the mean of vData
	double mean = 0;
	for (uint16_t i = 0; i < this->_samples; i++)
	{
		mean += this->_vReal[i];
	}
	mean /= this->_samples;
	// Subtract the mean from vData
	for (uint16_t i = 0; i < this->_samples; i++)
	{
		this->_vReal[i] -= mean;
	}
}

Na wejściu ADC mam dzielnik 1:1 więc mam zawsze tę samą wartość średnią około 1800:

Więc wystarczy zmodyfikować tę funkcję:

void load_samples(int read_index, volatile int* read_buffer, const int buffersize) {
    for (int i = 0; i < SAMPLES_COUNT; i++) {
        vReal[i] = read_buffer[read_index--] - 1800; //DC removal
        vImag[i] = 0;
        if(read_index < 0)
            read_index = buffersize-1;
    }
}

Niestety nie dało to wzrostu nawet o 1 FPS, ale jedno dzielenie zawsze mniej  

Zastanawiam mnie tylko jak uspokoić watchdoga na Core 0, poczytałem że trzeba używać co jakiś czas funkcję vTaskDelay(pdMS_TO_TICKS(1)); ale ta 1ms opóźnienia jest znaczna. Próbowałem wyłączyć rtc_wdt.h ale coś nie szło. Ktoś ma doświadczenie? Może @ethanak coś wiesz? Pamiętam, że w syntezatorze robiłeś coś na 2 rdzeniach.

Kod całego maina:

#include <Arduino.h>
#include "display.h"
#include "analyser.h"
#include "cmath"
#include "soc/rtc_wdt.h"


#define BAR_HEIGHT 21
#define BARS_COUNT 19

volatile double bars[BARS_COUNT];

void print_bars() {
    Serial.print("B: |");
    for(int i=0; i<BARS_COUNT; i++) {
        Serial.print(bars[i]);
        Serial.print(" | ");
    }
    Serial.println();
}

long last_time_1;
int loops_counter_1;

constexpr int READING_BUFFER_SIZE = 512 * 2;	
volatile int adc_readings_counter;
volatile int readings_buffer[READING_BUFFER_SIZE];
volatile int reading_buffer_index = 0;
hw_timer_t * sampling_timer = NULL;
portMUX_TYPE sampling_timerMux = portMUX_INITIALIZER_UNLOCKED;

void print_buffer() {
    Serial.print("R: |");
    for(int i=0; i<READING_BUFFER_SIZE; i++) {
        Serial.print(readings_buffer[i]);
        Serial.print(" | ");
    }
    Serial.println();
}

void IRAM_ATTR on_timer_sample() {
  portENTER_CRITICAL_ISR(&sampling_timerMux);
  adc_readings_counter++;
  readings_buffer[reading_buffer_index++] = analogRead(A6);
  if(reading_buffer_index >= READING_BUFFER_SIZE)
    reading_buffer_index = 0;
  portEXIT_CRITICAL_ISR(&sampling_timerMux);
}


void core0_task( void * parameter) {
    Serial.print("FFT sampler/processor running on core ");
    Serial.println(xPortGetCoreID());
    // analyser_begin();
    static long last_time = millis();
    static int loops_counter = 0;
    static double delta_time;
    
    // #interrupt
    sampling_timer = timerBegin(0, 80, true);
    timerAttachInterrupt(sampling_timer, &on_timer_sample, true);
    timerAlarmWrite(sampling_timer, 25, true); //40 kHz
    timerAlarmEnable(sampling_timer);
    // #interrupt

    for(;;) {
        load_samples(reading_buffer_index, readings_buffer, READING_BUFFER_SIZE);
        calculate_bars();
        double* fft_bars = get_heights();
        for(int i = 0; i < BARS_COUNT; i++)
            bars[i] = fft_bars[i];


        delta_time = millis() - last_time;
        if(delta_time > 4000) {
            delta_time /= max(loops_counter, 1);
            Serial.print("Core ");
            Serial.print(xPortGetCoreID());
            Serial.print(" FPS=");
            Serial.print(int(1000.0/delta_time));
            Serial.print("Hz, buffidx=");
            Serial.print(reading_buffer_index);
            Serial.print(", sr=");
            Serial.print(int(adc_readings_counter/4.0));
            Serial.println("Hz");
            print_buffer();
            Serial.println();
            last_time = millis();
            adc_readings_counter = 0;
            loops_counter = 0;
        }

        vTaskDelay(pdMS_TO_TICKS(1));
        loops_counter++;
    }
}

long last_time_core1;
int loops_counter_core1;
double delta_time_core1;

void setup() {
    Serial.begin(115200);
    Serial.println(F("FFT Spectrum Display"));
    display_begin();

    Serial.println(xPortGetCoreID());

    xTaskCreatePinnedToCore(core0_task, "FFT_processor", 64000, NULL, 1, NULL,  0);
    last_time_core1 = millis();
}



void loop() {
    delay(10);
    delta_time_core1 = millis() - last_time_core1;
    if(delta_time_core1 > 6000) {
        delta_time_core1 /= max(loops_counter_core1, 1);
        Serial.print("Core ");
        Serial.print(xPortGetCoreID());
        Serial.print(" FPS=");
        Serial.print(int(1000.0/delta_time_core1));
        Serial.print("Hz, buffidx=");
        Serial.print(reading_buffer_index);
        Serial.println(". ");
        print_bars();
        Serial.println();
        last_time_core1 = millis();
        loops_counter_core1 = 0;
    }    
    loops_counter_core1++;
}

 

 

Edytowano Grudzień 16, 2021 przez Gieneq

[ethanak]

8 minut temu, Gieneq napisał:

Może @ethanak coś wiesz? Pamiętam, że w syntezatorze robiłeś coś na 2 rdzeniach.

Ja zawsze sobie upraszczałem sprawę i wywoływałem delay(1) na tyle często, aby watchdog się uspokoił (np. raz na sekundę).

Tu masz rozwiązanie bez delay: https://forum.arduino.cc/t/esp32-a-better-way-than-vtaskdelay-to-get-around-watchdog-crash/596889/13

Nie próbowałem.

[Gieneq]

@ethanak dokładnie o to chodziło, dziękuję Wpadł dodatkowy 1 Hz.

[Gieneq]

Obudowa

Po 5 tygodniach dotarły do mnie elementy obudowy  Największy problem był z dostępnością 10 mm czarnej plexi.

Elementy obudowy cięte laserowo i poddawane relaksacji. Na zdjęciu część elementów:

Płytki "pixele" frezowane. Ściągane folii ochronnej z 400 kawałków plexi to była męczarnia, ale znalazła się jeszcze jedna para rąk do pracy 

Pozostało klejenie. To mnie trochę zaskoczyło, bo strzykawka polecana przez sprzedawcę nie jest dobrym pomysłem. Wystarczy na chwilę odłożyć, igła blokuje się i trzeba zaprawdę dużo wyczucia, żeby nie usmarować całego elementu. Dlatego dobrze jest kleić od strony z której nie widać.

Jeszcze nie zabrałem się za klejenie osłony, ale to będzie bardzo ryzykowne, bo osłona jest na pierwszym planie i wszystkie brzydkie ślady kleju będzie widać  

Aktualizacja programu

W międzyczasie zmieniłem trochę program - głównie eksperymenty z rozłożeniem kubełków. Dodałem też "fizykę" ruchu:

void calc_movement(double* thrs, double* pos, double* vel, double grav, int datalen, double dt) {
    for(int i = 0; i < BARS_COUNT; i++) {
        pos[i] += dt * vel[i];

        if(pos[i] < 0.0) {
            pos[i] = 0.0;
            vel[i] = 0.0;
        }

        if(pos[i] > 21.0) {
            pos[i] = 21.0;
            vel[i] = 0.0;
        }
    }

    for(int i = 0; i < BARS_COUNT; i++) {
        thrs[i] = constrain(thrs[i], 0.0, 21.0);

        double diff = thrs[i] - pos[i];
        if(diff >= 0.0) {
            pos[i] = thrs[i];
            vel[i] = 0;
        }
        else{
            vel[i] += -grav * dt - 0.5;
        }
    }
}

Pamiętam, że jak programowałem silnik gry to trzeba było zwrócić uwagę na kolejność przeliczania położenie i prędkości. Nie wiem czy kolejność: położenie prędkość jest tu dobrze, może ktoś się wypowie. Wydaje mi się, że prędkość liczy się później, tak by w kolejnym obiegu pętli poprzednia prędkość stała się podstawą wyznaczania nowego położenia (pochodna po czasie).

Pomijając te szczegóły, kod działa. Słupki opadają teraz wraz z "grawitacją", którą można regulować - im większy współczynnik tym szybciej słupki są ściągane do aktualnej wartości. Tu test z generatorem sinusa:

Jak połączę elektronikę z obudową co mam nadzieję nastąpi w tym tygodniu - wszystko co potrzeba już jest to będę testował różne efekty.

Powyższy kod daje naprawdę spore pole do popisu, wystarczy np. wyznaczyć moment w którym różnica diff wzrasta (sprawdzać zachowanie diff pomiędzy 2 klatkami) i mamy bardzo ciekawe dynamiczne zachowanie. Np taką "pochodną" z diff czyli różnicę różnic można potraktować jako prędkość dzięki czemu słupki będą miały przeregulowanie - na chwilę przeskoczą swój poziom docelowy.

Mam w odległych planach pomysł na porządne materiały - dokument, film, gdzie to wszystko będzie przedstawione  Opus magnum zobowiązuje, ale jest jeszcze sporo pracy. Choć mam już gwarantowanie 30 FPS, to dalej mam ambicję na sprzętowe FFT, co jakiś czas przeglądam rozwiązania ASIC FFT, albo IP Core FPGA ale to jeszcze daleko.

Mam jeszcze bardziej realny plan - animacje niezwiązane z widmem audio. Znalazłem kilka portów szumu Perlina w tym simplex noise i open simplex noise który nie jest objęty patentem i mam plan coś z tego zrobić. Jak ktoś nie wie co to za zwierz, polecam poczytać jak generowany jest świat w minecrafcie - ta niby prosta gra jest prawdziwą kopalnią wiedzy.

 

 

[ethanak]

A propos klejenia - czego używasz?

[MR1979]

Bardzo fajny projekt i dobre wykonanie Szkoda że dopiero teraz zauważyłem, ale będę śledził postępy.

Czekam na efekt końcowy i filmik

Pozdr!
Marek

 

[Gieneq]

@ethanak to jest jakiś klej do plexi PMMA firmy Artcofix. Są jeszcze kleje gęste, ten jest na bazie silnego rozpuszczalnika i jest rzadki także sam rozprowadza się po łączeniach. Łączy całkiem solidnie i szybko wysycha. Oczywiście cudów nie ma co się spodziewać - odporności na ścinanie to nie ma zbyt wysokiej.

@MR1979 dziękuję  projekt dopiero się rozkręca także jeszcze będzie wiele do omówienia.

Obudowa

Wczoraj przymocowałem profil aluminiowy i da się już postawić:

Przykręciłem tez tylną część obudowy - to mocowanie wyszło całkiem fajnie - w obrzeże wkleiłem kawałki 10mm plexi w które wtopiłem nitonakrętki:

Wstępnie przystawiłem podstawę - jedna para otworów się nie zgadza, ale to już drobiazg:

Gorzej, że otwory na kostki są wycięte... jakoś!? Rozrzut długości sąsiednich otworów to około 0,5mm przez co niektóre kostki nie pasują. Sprawdziłem mniej więcej jak duża jest skala problemu i na szczęście tylko ~1/4 ma ten problem. Próbowałem zeszlifować otwór pilnikiem ale będzie ciężko - łatwiej nieco przeszlifować kostkę. Także nie ma lekko, ale widać już, że coś z tego będzie  

[Gieneq]

Wreszcie zaczyna to wyglądać, no i działać  Kilak zdjęć i na dziś tyle, nie ma wiele technikaliów - prawie same babranie się w plastiku, kleju i kablach.

Bez kostek wygląda całkiem ładnie, ale tylko od frontu. Kostki nadają przestrzenny kształt  

I na koniec kilka zdjęć "artistiko"

Czas na klejenie 399 kostek 

[slon]

@Gieneq możesz też podejrzeć ten projekt (link jest w opisie)

 

[Gieneq]

@slon dziękuję, wygląda ciekawie. Jestem teraz na etapie przygotowywania animacji więc skorzystam.

Kolejne aktualizacje, obudowa

Klejenie kostek nie było tak trudne, choć 3 paski basowe były trochę eksperymentalne, ale plamy kleju na czarnej plexi nie rzucają się w oczy  

Najwięcej problemów miałem z dopasowaniem kostek. Naprawdę nie wiem jak to zrobili na produkcji, że co 2 kolumna nie pasuje. Kostki choć frezowane też maja małe odchyłki. W końcu wyciągnąłem dremela i pościnałem niektóre kostki przy podstawie.

Kilka zdjęć z klejenia:

Drobny test, działa!

I tu końcówka:

Przykręciłem podstawę, choć tu nie koniec - jeszcze wejdą tam 4 krótkie paski LEDów ale to już drobiazg:

No i wreszcie można coś obejrzeć. Dodałem nową animację, narazie bardzo roboczo. Miał to być ogień, który zostawia wypalony ślad. W sumie jest to dość proste.

Kolejny test:

Program

Dodałem kilka zmiennych i tablicę obrazującą wypalenie:

int burnt[DISPLAY_LEDS_COUNT];
static int fire_hue = 22;

constexpr long FIRE_HUE_INTERVAL = 2000;
long last_fire_hue_time;

constexpr long BURN_INTERVAL = 300;
long last_burn_time;

Pojawienie się słupka w danym pixelu powoduje odświeżenie licznika w danej komórce tablicy burnt, który nieodświeżany będzie malał do zera.

Nastepnie funkcja rysowania słupków. Tu pojawiają się 2 liczniki, które służą do spowalniania zmiany koloru ognia (hue bierze tylko w tym udział) oraz do wyzwalania zmiejszania wartości tablicy burnt:

void draw_bars(int* bar_heights, double* bar_thrs, int effect) {
  
  // ...

  // FIRE
  if (effect == FIRE) {

    if(millis() - last_fire_hue_time > FIRE_HUE_INTERVAL) {
      fire_hue += 4;
      fire_hue %= 256;
      last_fire_hue_time += FIRE_HUE_INTERVAL;
    }

    int reduce_burn = 0;
    if(millis() - last_burn_time > BURN_INTERVAL){
      reduce_burn = 1;
      last_burn_time += BURN_INTERVAL;
    }

    for(int display_x = 0; display_x < DISPLAY_W; display_x++) {
      for(int display_y = 0; display_y < DISPLAY_H; display_y++)
        set_rgb(display_x, display_y, 0,0,0);

      for(int display_y = 0; display_y < bar_heights[display_x]; display_y++) {
        // uint8_t hue = CLASSIC_BAR_HUE[display_y];
        int factor = DISPLAY_H - (bar_heights[display_x] - display_y - 1) - 1; // dla BH=4, 17, 18, 19, 20
        set_hsv(display_x, display_y, fire_hue, 50 + factor * 10, 255);
        burnt[get_idx(display_x, display_y)] = 28;

      }
      for(int display_y = bar_heights[display_x]; display_y < DISPLAY_H; display_y++) {
        int idx = get_idx(display_x, display_y);
        if(reduce_burn == 1 && burnt[idx] > 0){
          burnt[idx]--;
        }
        set_hsv(display_x, display_y, fire_hue, 255, burnt[idx]);

      }
    }
  }

Co do wyliczania wartości slupków, to ciekawa jest ta część:

int factor = DISPLAY_H - (bar_heights[display_x] - display_y - 1) - 1; // dla BH=4, 17, 18, 19, 20
set_hsv(display_x, display_y, fire_hue, 50 + factor * 10, 255);
burnt[get_idx(display_x, display_y)] = 28;

Steruję tu nasyceniem - dzięki temu ogień przy podstawie może być biały. Jest to jednak zrobione dość sensownie - im wyższy słupek tym podstawa jest bielsza. Można to sobie wyobrazić jak przesuwanie całego słupka: gdy jest małe wzmocnienie widać tylko jego czubek 9wysoka saturacja), a gdy jest duże wzmocnienie widać cały płomyk - przy podstawie pokazuje się niska saturacja. 

Wartość 28 ustawiłem dla dość dużej ogólnej jasności FastLED, dla mniejszych wartości trzeba tu dać przynajmiej 2x większą wartość. Mam zamiar dać regulację jasności, więc to kiedyś funkcyjnie powiążę.

Efekty

Niestety, zabardzo na zdjęciach nie widać tego efektu ze zmienną factor, widać za to dopalanie. Po prawej mamy wysokie słupki:

które zostawiają po chwili ślad:

 

Zanika sygnał, mija trochę czasu i ten się dopala:

@MR1979 Filmik niedługo, jak skompletuję podstawę i przynajmniej wstępnie zamknę tył. Płytka elektroniczna jest dalej w rozsypce więc nie ma czym się chwalić, ale wszystko działa jak należy i projekt zmierza do końca. 

A tu miałem gościa, sójka:

 

Edytowano Grudzień 27, 2021 przez Gieneq

[pmochocki]

@Gieneq rozważasz udostępnienie całego kodu? Bo staram się tu nadążyć: grawitacja, wypalanie... Grawitacja ma opóźniać opadanie słupków. Wypalanie wpływa na jasność... dobrze rozumiem? Łatwiej by było gdyby człowiek miał kod przed nosem. Pozatym najbardziej interesuje mnie aspekt wielowątkowości. Liczenie FFT w jednym wątku, a animacja w drugim. Co jest w sekcji krytecznej? Czy masz dwa bufory i robisz swap? Na jak długo wyświetlanie może blokować dane? FFT liczone pewnie w regularnych odstępach trigrowane licznikiem. Gdzie jest sprawdzane czy można zrobić swapa? Itd... 

[Gieneq]

@pmochocki Tak udostępnię kod, ale jest on na razie w bałaganie. To nad czym teraz pracuję - animacje itp. nie jest już stricte związane z mikrokontrolerami, korzystam tu z doświadczenia w pisaniu gier z OpenGL. Domyslam się, że kod na ESP32 jest nieoptymalny i pewnie są tam babole o których nie mam pojęcia. Wielowątkowością nie będę się też chwalił, bo nie dodałem żadnego wyrafinowanego mechanizmu kontroli dostępu - semafora czy czegoś podobnego. Bufor jest typu volataile i działa. Ale wniknę temat jak minie hype na implementacje efektów  

To na ten moment kod programu. bands.h - kubełki do przelicznia 512 punktów FFT na pasma:

#pragma once

const int bands512[255] = {
0, 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 7, 7, 7, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 
10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13, 
13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 16, 16, 
16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 
17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 
17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 
18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18};

display.h - wyświetlanie i sterowanie diodami:

#pragma once

#include "Arduino.h"
#include "FastLED.h"

#define  LED_TYPE   WS2812B
#define ZIGZAGING 1

enum class animation_t {
    SPECTRUM,
    POINTS,
    FLAMES
};

constexpr auto  COLOR_ORDER  =  GRB;
constexpr int  MAX_BRIGHTNESS = 210;

// FRONT MATRIX DISPLAY: 19 COLS, 21 ROWS
constexpr int DISPLAY_PIN = 19;
constexpr int DISPLAY_W = 19;
constexpr int DISPLAY_H = 21;
constexpr int DISPLAY_LEDS_COUNT = DISPLAY_W * DISPLAY_H;

// UNDERLIGHT: 2 SHORT STRIPS
constexpr int BASE_PIN = 18;
constexpr int BASE_LEDS_COUNT = 2*7;

void display_begin();
void display_show();
void display_animate(animation_t type, int *bars);
void inline set_rgb(int x, int y, uint8_t r, uint8_t g, uint8_t b);
void inline set_hsv(int x, int y, uint8_t h, uint8_t s, uint8_t v);
void fill_rgb(uint8_t r, uint8_t g, uint8_t b);
void test_bench();
void draw_bars(int* bar_heights, double* bar_thrs, int effect);

display.cpp

#include "display.h"

// static unsigned long last_micros;

static constexpr uint8_t CLASSIC_BAR_HUE[] = {100, 100, 100, 100, 100, 100, 100, 100, 50, 50, 50, 50, 50, 50, 50, 50, 0, 0, 0, 0, 0};

int burnt[DISPLAY_LEDS_COUNT];
static int fire_hue = 22;

constexpr long FIRE_HUE_INTERVAL = 2000;
long last_fire_hue_time;

constexpr long BURN_INTERVAL = 300;
long last_burn_time;

CRGB display_leds[DISPLAY_LEDS_COUNT];

void display_begin() {
  FastLED.addLeds<LED_TYPE, DISPLAY_PIN, COLOR_ORDER>(display_leds, DISPLAY_LEDS_COUNT).setCorrection(TypicalSMD5050);
  FastLED.setBrightness(MAX_BRIGHTNESS);
  fill_rgb(0, 0, 0);
  display_show();
  last_fire_hue_time = millis();
}


static inline int get_idx(int x, int y) {
  x = DISPLAY_W - x - 1;
  #if ZIGZAGING == 1
      return (x&1 ? DISPLAY_H - y - 1 : y) + x * DISPLAY_H;
  #else
      return y + x * DISPLAY_H;
  #endif
}

void display_show(){
  FastLED.show();
}

void inline set_rgb(int x, int y, uint8_t r, uint8_t g, uint8_t b) {
  display_leds[get_idx(x, y)] = CRGB(r,g,b);
}

void inline set_hsv(int x, int y, uint8_t h, uint8_t s, uint8_t v) {
  display_leds[get_idx(x, y)] = CHSV(h,s,v);
}

void fill_rgb(uint8_t r, uint8_t g, uint8_t b) {
  for(int display_y = 0; display_y < DISPLAY_H; display_y++){
    for(int display_x = 0; display_x < DISPLAY_W; display_x++)
      set_rgb(display_x, display_y, r,g,b);
  }
}

void test_bench() {
}

#define ORIGINAL 0
#define CLASSIC 1
#define FIRE 2 //TO MA ZOSTAWIAC ZANIKAJACY WYPALONY ŚLAD, CZYLI TEZ W KODZIE GRAWITACJI COS TRZEBA ZMIENIC
#define ARCTIC 3 //HM
#define VENOMOUS 4 //HM

void draw_bars(int* bar_heights, double* bar_thrs, int effect) {
  
  // ORIGINAL
  if (effect == ORIGINAL) {
    for(int display_x = 0; display_x < DISPLAY_W; display_x++) {
      for(int display_y = 0; display_y < DISPLAY_H; display_y++)
        set_rgb(display_x, display_y, 0,0,0);

      for(int display_y = 0; display_y < bar_heights[display_x]; display_y++) {
        uint8_t hue = uint8_t(display_y * 255.0 / DISPLAY_H);
        set_hsv(display_x, display_y, hue,255,255);
      }
      
      if(bar_heights[display_x] > 0)
        set_rgb(display_x, bar_heights[display_x] - 1, 255,255,255);
    }
  }

  // CLASSIC
  if (effect == CLASSIC) {
    for(int display_x = 0; display_x < DISPLAY_W; display_x++) {
      for(int display_y = 0; display_y < DISPLAY_H; display_y++)
        set_rgb(display_x, display_y, 0,0,0);

      for(int display_y = 0; display_y < bar_heights[display_x]; display_y++) {
        uint8_t hue = CLASSIC_BAR_HUE[display_y];
        set_hsv(display_x, display_y, hue, 255, 255);
      }
    }
  }

  // FIRE
  if (effect == FIRE) {

    if(millis() - last_fire_hue_time > FIRE_HUE_INTERVAL) {
      fire_hue += 4;
      fire_hue %= 256;
      last_fire_hue_time += FIRE_HUE_INTERVAL;
    }

    int reduce_burn = 0;
    if(millis() - last_burn_time > BURN_INTERVAL){
      reduce_burn = 1;
      last_burn_time += BURN_INTERVAL;
    }

    for(int display_x = 0; display_x < DISPLAY_W; display_x++) {
      for(int display_y = 0; display_y < DISPLAY_H; display_y++)
        set_rgb(display_x, display_y, 0,0,0);

      for(int display_y = 0; display_y < bar_heights[display_x]; display_y++) {
        // uint8_t hue = CLASSIC_BAR_HUE[display_y];
        int factor = DISPLAY_H - (bar_heights[display_x] - display_y - 1) - 1; // dla BH=4, 17, 18, 19, 20
        set_hsv(display_x, display_y, fire_hue, 50 + factor * 10, 255);
        burnt[get_idx(display_x, display_y)] = 28;

      }
      for(int display_y = bar_heights[display_x]; display_y < DISPLAY_H; display_y++) {
        int idx = get_idx(display_x, display_y);
        if(reduce_burn == 1 && burnt[idx] > 0){
          burnt[idx]--;
        }
        set_hsv(display_x, display_y, fire_hue, 255, burnt[idx]);

      }
    }
  }

  // ELECTRIC - hue:140-180, impulsy - podpijaja, gasnie jak opada
  //th pojawia sie tylko na chwile wiec trzeba to 
  if (effect == 3) {
    for(int display_x = 0; display_x < DISPLAY_W; display_x++) {
      for(int display_y = 0; display_y < DISPLAY_H; display_y++)
        set_rgb(display_x, display_y, 0,0,0);

      for(int display_y = 0; display_y < bar_heights[display_x]; display_y++) {
        uint8_t hue = random8(146, 182);
        uint8_t value = random8(200, 255);

        set_hsv(display_x, display_y, hue, 255, value);
      }

        if(bar_heights[display_x] > 0)
          set_rgb(display_x, bar_heights[display_x] - 1, 255,255,255);
    }
  }

}

Kod związany z FFT - wynikiem jest tablica wzmocnień. analyser.h

#pragma once

#include <Arduino.h>
#include "arduinoFFT.h"
#include "bands.h"

#define AUX_PIN A6
#define MICRO_PIN A3

constexpr int AUDIO_PIN = AUX_PIN; // A3 - module, A0 - not used anymore, A6 - jack

constexpr uint16_t SAMPLES_COUNT = 512; //1024

constexpr double SAMPLING_FREQUENCY = 40000.0;

constexpr int BANDS_COUNT = 19;
constexpr int COLS_HEIGHT = 21;

void analyser_begin();
void sample_blocking();
void load_samples(int read_index, volatile int* read_buffer, const int buffersize);
void calculate_bars();
void feedTone(double frequency);
double* get_magnitudes();

i plik cpp:

#include "analyser.h"
#include "math.h"

constexpr double NOISE_LIMIT = 512.0 * 4;
constexpr double BAR_HEIGHT_MODIFIER = COLS_HEIGHT/(1024.0*128.0); //(COLS_HEIGHT)/1512.0/128.0;
constexpr unsigned long SAMPLING_PERIOD_US = static_cast<unsigned long>(1000000.0 / SAMPLING_FREQUENCY);
constexpr uint16_t USABLE_SAMPLES_COUNT = SAMPLES_COUNT/2 - 1;
unsigned long sampling_time_us;
int sampling_counter;

double vReal[SAMPLES_COUNT];
double vImag[SAMPLES_COUNT];

arduinoFFT FFT = arduinoFFT(vReal, vImag, SAMPLES_COUNT, SAMPLING_FREQUENCY);

double magnitude_bands[BANDS_COUNT];

extern const int bands512[];

void analyser_begin() {
    for (int i = 0; i < SAMPLES_COUNT; i++) {
        vReal[i] = 0.0;
        vImag[i] = 0.0;
    }
    for (int i = 0; i < BANDS_COUNT; i++) {
        magnitude_bands[i] = 0.0;
    }
}

void sample_blocking(){
    for (int i = 0; i < SAMPLES_COUNT; i++) {
        vReal[i] = analogRead(AUDIO_PIN);
        vImag[i] = 0;
        delayMicroseconds(SAMPLING_PERIOD_US);
    }
}

void load_samples(int read_index, volatile int* read_buffer, const int buffersize) {
    for (int i = 0; i < SAMPLES_COUNT; i++) {
        vReal[i] = 2*(read_buffer[read_index--] - 1800); //DC removal
        vImag[i] = 0;
        if(read_index < 0)
            read_index = buffersize-1;
    }
}

void calculate_bars() {
    // FFT.DCRemoval();
    FFT.Windowing(FFT_WIN_TYP_HAMMING, FFT_FORWARD);

    FFT.Compute(FFT_FORWARD);

    FFT.ComplexToMagnitude();  // wynik w vReal
  
    for (int i = 0; i < BANDS_COUNT; i++)
      magnitude_bands[i] = 0.0;

    for (int i = 1; i < USABLE_SAMPLES_COUNT; i++) {
        if (vReal[i] > NOISE_LIMIT)
            magnitude_bands[bands512[i]] += vReal[i];
    }
    for (int i = 0; i < BANDS_COUNT; i++)
      magnitude_bands[i] *= BAR_HEIGHT_MODIFIER;
}

double* get_magnitudes() {
    return magnitude_bands;
}

void feedTone(double frequency) {
    for (int i = 0; i < SAMPLES_COUNT; i++) {
        vReal[i] = 512.0 + 256.0*sin(2.0*3.1415*frequency * i / SAMPLING_FREQUENCY);
        vImag[i] = 0;
    }
}

I teraz plik mian wiążący wszystko w całość, tu można wyróżnić rozbicie na 2 rdzenie:

#include <Arduino.h>
#include "display.h"
#include "analyser.h"
#include "cmath"
// #include "soc/rtc_wdt.h"
// #include "esp_task_wdt.h" // esp_task_wdt_reset();
#include "soc/timer_group_struct.h"
#include "soc/timer_group_reg.h"

int sel_effect = 2;

void feedTheDog(){
  // feed dog 0
  TIMERG0.wdt_wprotect=TIMG_WDT_WKEY_VALUE; // write enable
  TIMERG0.wdt_feed=1;                       // feed dog
  TIMERG0.wdt_wprotect=0;                   // write protect
  // feed dog 1
  TIMERG1.wdt_wprotect=TIMG_WDT_WKEY_VALUE; // write enable
  TIMERG1.wdt_feed=1;                       // feed dog
  TIMERG1.wdt_wprotect=0;                   // write protect
}

#define BAR_HEIGHT 21
#define BARS_COUNT 19

volatile double mags[BARS_COUNT];

// void print_bars() {
//     Serial.print("B: |");
//     for(int i=0; i<BARS_COUNT; i++) {
//         Serial.print(bars[i]);
//         Serial.print(" | ");
//     }
//     Serial.println();
// }

// constexpr int MEAN_BUFFER_LEN = 1;
// constexpr int MEAN_BUFFER_TOTAL_LEN = MEAN_BUFFER_LEN * BARS_COUNT;
// double mean_buffer[MEAN_BUFFER_TOTAL_LEN];
// int free_index = 0;

// void feed_mean_buffer(double* samples_batch, int datalen){
//     for(int i=0; i<datalen; i++) {
//         mean_buffer[i + free_index * datalen] = samples_batch[i];
//     }

//     free_index++;
//     free_index %= MEAN_BUFFER_LEN;
// }

// void eval_buffer_mean(double* dst_batch, int datalen) {
//     for(int i=0; i<datalen; i++) {
//         dst_batch[i] = 0.0;
//         for(int j=0; j<MEAN_BUFFER_LEN; j++){
//             dst_batch[i] += mean_buffer[i + j * datalen];
//         }
//         dst_batch[i] /= MEAN_BUFFER_LEN;
//         Serial.println(dst_batch[i]);
//     }
// }



long last_time_1;
int loops_counter_1;

constexpr int READING_BUFFER_SIZE = 512 * 2;	
volatile int adc_readings_counter;
volatile int readings_buffer[READING_BUFFER_SIZE];
volatile int reading_buffer_index = 0;
hw_timer_t * sampling_timer = NULL;
portMUX_TYPE sampling_timerMux = portMUX_INITIALIZER_UNLOCKED;

void IRAM_ATTR on_timer_sample() {
  portENTER_CRITICAL_ISR(&sampling_timerMux);
  adc_readings_counter++;
  readings_buffer[reading_buffer_index++] = analogRead(A6);
  if(reading_buffer_index >= READING_BUFFER_SIZE)
    reading_buffer_index = 0;
  portEXIT_CRITICAL_ISR(&sampling_timerMux);
}


void core0_task( void * parameter) {
    Serial.print("FFT sampler/processor running on core ");
    Serial.println(xPortGetCoreID());
    // analyser_begin();
    static long last_time = millis();
    static int loops_counter = 0;
    static double delta_time;
    
    // #interrupt
    sampling_timer = timerBegin(0, 80, true);
    timerAttachInterrupt(sampling_timer, &on_timer_sample, true);
    timerAlarmWrite(sampling_timer, 25, true); //40 kHz
    timerAlarmEnable(sampling_timer);
    // #interrupt

    for(;;) {
        load_samples(reading_buffer_index, readings_buffer, READING_BUFFER_SIZE);
        calculate_bars();
        double* fft_bars = get_magnitudes();
        // feed_mean_buffer(fft_bars, BARS_COUNT);
        for(int i = 0; i < BARS_COUNT; i++)
            mags[i] = fft_bars[i];


        delta_time = millis() - last_time;
        if(delta_time > 4000) {
            delta_time /= max(loops_counter, 1);
            Serial.print("Core ");
            Serial.print(xPortGetCoreID());
            Serial.print(" FPS=");
            Serial.print(int(1000.0/delta_time));
            Serial.print("Hz, buffidx=");
            Serial.print(reading_buffer_index);
            Serial.print(", sr=");
            Serial.print(int(adc_readings_counter/4.0));
            Serial.println("Hz");
            Serial.println();
            last_time = millis();
            adc_readings_counter = 0;
            loops_counter = 0;
        }

        // vTaskDelay(pdMS_TO_TICKS(1));
        feedTheDog();
        loops_counter++;
    }
}

long last_time_core1;
int loops_counter_core1;
double delta_time_core1;

#define DRAW_INTERVAL_MS 33
long last_time_draw;
int loops_counter_draw;

#define UPDATE_INTERVAL_MS 16
long last_time_update;
int loops_counter_update;



void setup() {
    Serial.begin(115200);
    Serial.println(F("FFT Spectrum Display"));
    display_begin();

    Serial.println(xPortGetCoreID());

    xTaskCreatePinnedToCore(core0_task, "FFT_processor", 64000, NULL, 1, NULL,  0);
    last_time_core1 = millis();
    last_time_draw = millis();
}


double bars_threshold[BARS_COUNT];
double bars_pos[BARS_COUNT];
double diffs[BARS_COUNT];

double dt;
double velocities[BARS_COUNT];
double gravity = 100;

void calc_movement(double* thrs, double* pos, double* vel, double grav, int datalen, double dt, double* diffs) {


    for(int i = 0; i < BARS_COUNT; i++) {
        pos[i] += dt * vel[i];

        if(pos[i] < 0.0) {
            pos[i] = 0.0;
            vel[i] = 0.0;
        }

        if(pos[i] > 21.0) {
            pos[i] = 21.0;
            vel[i] = 0.0;
        }
    }

    for(int i = 0; i < BARS_COUNT; i++) {
        thrs[i] = constrain(thrs[i], 0.0, 21.0);


        diffs[i] = thrs[i] - pos[i];
        // idz w gore
        if(diffs[i] >= 0.0) {
            // vel[i] += 32.0 * diff/21.0;
            pos[i] = thrs[i];
            vel[i] = 0;
        }
        else{
            vel[i] += -grav * dt - 0.5;
        }

        // vel[i] += -grav * dt;
    }
}

int bars[BARS_COUNT]; //rendering

void loop() {
    // UPDATE
    if(millis() - last_time_update > UPDATE_INTERVAL_MS) {
    // Serial.print("Update: ");
    // Serial.println(millis() - last_time_update - UPDATE_INTERVAL_MS);
        dt = (millis() - last_time_update)/1000.0; //sekundy

        for(int i = 0; i < BARS_COUNT; i++)
            bars_threshold[i] = mags[i];

        // eval_buffer_mean(bars_threshold, BARS_COUNT);
        calc_movement(bars_threshold, bars_pos, velocities, gravity, BARS_COUNT, dt, diffs);

        for(int i = 0; i < BARS_COUNT; i++)
            bars[i] = constrain(int(bars_pos[i]), 0, 21);

        draw_bars(bars, bars_threshold, sel_effect);
        last_time_update += UPDATE_INTERVAL_MS;
    }

    // DRAW
    if(millis() - last_time_draw > DRAW_INTERVAL_MS) {
        // Serial.print("Render: ");
        // Serial.println(millis() - last_time_draw - DRAW_INTERVAL_MS);
        display_show();
        last_time_draw += DRAW_INTERVAL_MS;
    }

    // delta_time_core1 = millis() - last_time_core1;
    // if(delta_time_core1 > 6000) {
    //     delta_time_core1 /= max(loops_counter_core1, 1);
    //     Serial.print("Core ");
    //     Serial.print(xPortGetCoreID());
    //     Serial.print(" FPS=");
    //     Serial.print(int(1000.0/delta_time_core1));
    //     Serial.print("Hz, buffidx=");
    //     Serial.print(reading_buffer_index);
    //     Serial.println(". ");
    //     // print_bars();
    //     // Serial.println();
    //     last_time_core1 = millis();
    //     loops_counter_core1 = 0;
    // }    
    // loops_counter_core1++;
}

Zostawiam komentarze, bo w jednym z nich jest implementacja średniej kroczącej, o której komuś niedawno wspomniałem. Ostatecznie nie była potrzebna, bo grawitacja lepiej opóźniła zmiany  

Jak pisałem, kod to taki trochę bałagan. Wstyd patrzeć na magiczne liczby i stałe które są kopiowane w plikach zamiast linkowane... cóż, będzie lepiej  Wrzucę niedługo kod na gita.

 

 

[Gieneq]

Pierwsza sprawa wrzuciłem kod na gita https://github.com/Gieneq/RGBHSV , dalej nie jest zbyt piękny, ale coś będzie lepiej  

Na pewno wyświetlacz dostarcza wielu pomysłów na futurystyczne zdjęcia na tapetę:

Program

Ale może coś o konkretach  Pomyślałem, że napiszę efekt ognia ale taki bardziej realistyczny. Na początek poprawiłem wygląd języków ognia. Wyświetliłem sobie wszystkie kolory - 255 wartości hue i wybrałem te bardziej pasujące:

W efekcie tablica wygląda tak:

constexpr uint8_t FIRE_TONGUE_HUE[] = {12, 16, 32, 33, 34, 35, 36, 37, 37, 37, 37, 36, 35, 34, 33, 20, 19, 18, 255, 255, 255};

Ale to nie wszystko - bo płomień u podstawy mógłby być trochę jaśniejszy, dlatego trzeba tam zmniejszyć saturację, służy do tego wyprowadzony wcześniej współczynnik (związany z wysokością słupków i przesunięciem indeksu w tablicy) factor:

    for(int display_x = 0; display_x < DISPLAY_W; display_x++) {
      for(int display_y = 0; display_y < bar_heights[display_x]; display_y++) {
        int factor = DISPLAY_H - (bar_heights[display_x] - display_y - 1) - 1; // dla BH=4, 17, 18, 19, 20
        uint8_t fire_hue = FIRE_TONGUE_HUE[factor];

        uint8_t fire_saturation = 255;
        if(factor < 10)
          fire_saturation -= (10-factor-1) * 28;

        set_hsv(display_x, display_y, fire_hue, fire_saturation, 255);
      }
    }
  }

Ale takie paski są wciąż zbyt monotonne, pomyślałem że dodam trochę zniekształceń. Tu pierwszy pomysł, żeby wjechać z szumem Perlina, ale wolałem szybko uzyskać efekt i w sumie dobrze. Wymyśliłem że stablicuję jakąś okresową funkcję, więc napisałem prosty kod w Pythonie do wygenerowania przebiegu z kilku oktaw sinusa:

import math
import random
from matplotlib import pyplot as plt
octaves = 6
base_freq = 1 #Hz
samples_count = 128
min_val = 40
max_val = 255

samples = [0.0]*samples_count
samples_int = [0]*samples_count


for ocateve in range(1, octaves+1):
    print(f"Octave {ocateve}")
    freq = base_freq * ocateve
    amplitude = 1
    phase = random.random()
    for i in range(samples_count):
        samples[i] += amplitude * math.sin(phase + 2*math.pi*freq*i/samples_count)

amp = max(samples) - min(samples)
for i in range(samples_count):
    samples_int[i] = int(((samples[i]-min(samples))/amp) * (max_val - min_val)) + min_val
print(f"Min: {min(samples_int)}, max: {max(samples_int)}")

plt.plot(samples_int)
plt.show()
print(samples_int)

Sygnał składa się z sumy kilku tzw. harmonicznych o coraz większej częstotliwości. W wyniku otrzymałem wykres:

oraz tablice 128 próbek sygnału w przedziale wartości od 40 do 255:

const uint8_t NOISE_FLAMES[] = {199, 218, 234, 245, 252, 255, 253, 248, 239, 228, 216, 204, 191, 180, 170, 163, 157, 154, 152, 152, 153, 155, 157, 159, 160, 160, 159, 157, 154, 151, 147, 143, 139, 136, 134, 133, 133, 134, 136, 138, 140, 143, 144, 146, 146, 145, 143, 140, 136, 131, 127, 122, 119, 116, 114, 114, 114, 116, 119, 123, 127, 131, 135, 137, 139, 139, 138, 136, 132, 128, 123, 119, 115, 112, 110, 110, 111, 114, 118, 124, 130, 137, 143, 148, 151, 153, 153, 151, 147, 141, 135, 127, 120, 114, 108, 105, 104, 105, 109, 115, 122, 131, 140, 148, 155, 160, 163, 162, 157, 150, 139, 126, 110, 94, 79, 64, 53, 44, 40, 40, 45, 55, 69, 87, 108, 131, 155, 178};

Jak widać jest tu spora górka i dołek, ale to dobrze - uzyskam w ten sposób wyraźny błysk jak w świeczce na wietrze 

To teraz czas zamieszać w składowej value profilu HSV - im mniejsza wartość tym bliżej czerni (dlatego dodałem w kodzie Pythonia minimum w 40 żeby nie było zbyt dużych zaburzeń). Wewnętrzna pętla wygląda teraz tak:

      for(int display_y = 0; display_y < bar_heights[display_x]; display_y++) {
        int factor = DISPLAY_H - (bar_heights[display_x] - display_y - 1) - 1; // dla BH=4, 17, 18, 19, 20
        uint8_t fire_hue = FIRE_TONGUE_HUE[factor];

        uint8_t fire_saturation = 255;
        if(factor < 10)
          fire_saturation -= (10-factor-1) * 28;

        uint8_t fire_value = 255;
        if(factor > 9 && factor < 21){
          fire_value = NOISE_FLAMES[(twinkle_counter + display_y + display_x*6)%128];
          
          if(factor > 9 && factor < 17){
            //factor: 10...16
            double mix_factor = (factor - 10)/6.0;
            fire_value = (mix_factor * fire_value + (1.0 - mix_factor) * 255); //mix
            if(fire_value>255)
              fire_value = 255;
          }
        }

        set_hsv(display_x, display_y, fire_hue, fire_saturation, fire_value);

Saturation bez zmian, ale poniżej jest zmienna fire_value. Jeżeli jesteśmy przy czubku płomyka (factor od 9 do 21) to wybieramy próbki z naszej ztablicowanej funkcji NOISE_FLAMES. Indeks bazuje na zmiennej twinkle_counter, która jest inkrementowana co każdy obrót pętli (30Hz) i zawijana do wartości 0-255:

  else if (effect == effect_t::FIRE) {
    ++twinkle_counter%=128;
    //...
  }

Tak przy okazji, ciekawy przykład - z postinkrementacją to nie działa. Wracając, twinkle_counter powoduje, że animacja działa w czasie, uzależnienie od display_x powoduje, że każda kolumna ma swoje małe przesunięcie - nie są zsynchronizowane, a zależność od display_y powoduje, że widoczny jest efekt w pionie.

Zmieniając value okresowo są "przetarcia" w kolorze - są ciemne plamy jakby płomyk tracił jasność. Efekt jest genialny, ale tak mocno ucięty na 9 wysokości w słupku brzydko wygląda. Dlatego skorzystałem z doświadczenia z języków shaderów GLSL i napisałem odpowiednik funkcji mix:

double mix_factor = (factor - 10)/6.0;
fire_value = (mix_factor * fire_value + (1.0 - mix_factor) * 255); //mix
if(fire_value>255)
  fire_value = 255;

W ten sposób przechodząc współczynnikiem od 0.0 do 1.0 nastąpi stopniowe przejście (liniowe) pomiędzy 2 efektami i zostanie zatarta granica animacji i koloru bazowego.

Tak nawias, w grafice komputerowej jest funkcja wielomianowa smoothstep która robi to ładniej 9ale wolniej), ale na takim wyświetlaczu nie będzie widać różnicy  

Dobra, to animowane języki są, ale co z tłem. Wypalenie o którym pisałem wcześniej wygląda teraz tak sobie. Bez zmian pozostaje fragment dotyczący odświeżania:

    static int reduce_burn = 0;
    if(millis() - last_burn_time > BURN_INTERVAL){
      reduce_burn = 1;
      last_burn_time += BURN_INTERVAL;
    }

Ale pomyślałem że dodam pewną losowość:

burnt[get_idx(display_x, display_y)] = FIRE_BASE_TICS + random(FIRE_RANDOM_TICS);

i inny sposób interpretowania wartości:

      for(int display_y = bar_heights[display_x]; display_y < DISPLAY_H; display_y++) {
        int idx = get_idx(display_x, display_y);
        if(burnt[idx] > 0){
          set_hsv(display_x, display_y, BURNT_HUE, 255, BURNT_HSV_VALUE);
          if(reduce_burn == 1)
            burnt[idx]--;
        } else
          set_rgb(display_x, display_y, 0, 0, 0);
      }

W ten sposób można lepiej sterować jasnością cieni w zależności od ogólnie ustawionej jasności - nie wpływa już na długość opóźnienia, które teraz jest stałe. W efekcie w tle mam poprzecinane języki ognia, które z czasem zanikają.

Dalej nie mam filmu, bo szukałem miejsca gdzie wyświetlacz będzie w miarę ładnie się prezentował:

Efekt płomyków można obejrzeć na zdjęciach:

oraz w całości:

Jak widać paski tła są czasem przecięte tak jakby tylko szczątki języków ognia gdzieś tam ulatywały. Animowany kominek ruszający się w rytm muzyki gotowy!  

Jeszcze na koniec dnia trochę grzebania w elektronice, udało się zamknąć obudowę, ale jeszcze sporo pracy...

I tak w oderwaniu od elektroniki, kodu, coś z natury za oknem - przyszedł gość:

Edytowano Styczeń 3, 2022 przez Gieneq