Internet radio and audio file player on ESP32-S3

1. Gdzie to jest w kodzie

W main_with_volume_analyzer_ok.cpp znajdź funkcję:

void vuMeterMode5() // Tryb 5: 16 słupków – dynamiczny analizator z zegarem i ikonką głośnika


Końcówka tej funkcji wygląda mniej więcej tak (to jest TEN fragment, który steruje wyglądem):

  // Linia oddzielająca pasek od słupków
  u8g2.drawHLine(0, 13, SCREEN_WIDTH);

  // Obszar słupków – od linii w dół do końca ekranu
  const uint8_t eqTopY      = 14;                    // pod paskiem
  const uint8_t eqBottomY   = SCREEN_HEIGHT - 1;     // do dołu
  const uint8_t eqMaxHeight = eqBottomY - eqTopY + 1;

  // 32 segmenty na wysokość
  const uint8_t maxSegments = 32;
  const float segmentStep = (float)eqMaxHeight / (float)maxSegments;

  // Parametry słupków – 16 sztuk na szerokość ekranu (prawie na całość)
  const uint8_t barWidth = 10;
  const uint8_t barGap   = 6;

  const uint16_t totalBarsWidth = EQ_BANDS * barWidth + (EQ_BANDS - 1) * barGap;
  int16_t startX = (SCREEN_WIDTH - totalBarsWidth) / 2;
  if (startX < 0) startX = 0;

  for (uint8_t i = 0; i < EQ_BANDS; i++)
  {
    uint8_t level = eqLevel[i];
    uint8_t peak  = eqPeak[i];

    // Ile segmentów zapalonych (0..32)
    uint8_t segCount = map(level, 0, 100, 0, maxSegments);
    uint8_t peakSeg  = map(peak,  0, 100, 0, maxSegments);

    uint8_t x = startX + i * (barWidth + barGap);

    // Segmenty – słupki z „klocków”
    for (uint8_t s = 0; s < segCount; s++)
    {
      int16_t segBottom = eqBottomY - (int16_t)(s * segmentStep);
      int16_t segTop    = segBottom - (int16_t)(segmentStep * 0.6f);

      if (segTop < eqTopY) segTop = eqTopY;
      if (segBottom < eqTopY) break;

      uint8_t segH = (segBottom - segTop + 1);
      if (segH < 1) segH = 1;

      u8g2.drawBox(x, segTop, barWidth, segH);
    }

    // Peak – cienka kreska nad słupkiem
    if (peakSeg > 0)
    {
      uint8_t ps = peakSeg - 1;
      int16_t peakBottom = eqBottomY - (int16_t)(ps * segmentStep);
      int16_t peakY      = peakBottom - 1;
      if (peakY >= eqTopY && peakY <= eqBottomY)
      {
        u8g2.drawBox(x, peakY, barWidth, 1);
      }
    }
  }


To jest miejsce, gdzie zmieniasz „stylistykę”.

2. Najważniejsze gałki

Masz kilka podstawowych parametrów:

const uint8_t maxSegments = 32;   // ile "klocków" w pionie
const float segmentStep = (float)eqMaxHeight / (float)maxSegments;

const uint8_t barWidth = 10;      // szerokość słupka
const uint8_t barGap   = 6;       // przerwa między słupkami


węższe słupki → zmniejszasz barWidth

mniej/więcej przerw → zmieniasz barGap

więcej "klocków" na wysokość → zwiększasz maxSegments (np. 40)

bardziej ciągłe słupki → zamiast pętli po segmentach robisz jeden drawBox (patrz niżej)

3. Przykład 1 – „ciągłe” słupki zamiast klocków

Jeśli chcesz zwykłe prostokąty od dołu do góry, podmień środek pętli na coś takiego:

  for (uint8_t i = 0; i < EQ_BANDS; i++)
  {
    uint8_t level = eqLevel[i];
    uint8_t peak  = eqPeak[i];

    // wysokość słupka w pikselach
    uint8_t barHeight = map(level, 0, 100, 0, eqMaxHeight);
    uint8_t peakPix   = map(peak,  0, 100, 0, eqMaxHeight);

    uint8_t x = startX + i * (barWidth + barGap);

    // CIĄGŁY słupek: jeden prostokąt
    if (barHeight > 0)
    {
      int16_t yTop = eqBottomY - barHeight + 1;
      if (yTop < eqTopY) yTop = eqTopY;

      u8g2.drawBox(x, yTop, barWidth, barHeight);
    }

    // Peak jako cienka kreska
    if (peakPix > 0)
    {
      int16_t yPeak = eqBottomY - peakPix;
      if (yPeak >= eqTopY && yPeak <= eqBottomY)
      {
        u8g2.drawBox(x, yPeak, barWidth, 1);
      }
    }
  }


Resztę (eqTopY, eqBottomY, barWidth, barGap) zostawiasz jak jest.

Efekt: pełne słupki jak typowy analizator w wieży.

4. Przykład 2 – cieńsze słupki, więcej „korony” na górze

Chcesz styl „dużo słupków, wąskie kreski”? Zmień parametry:

const uint8_t maxSegments = 40;  // więcej segmentów = wyższa rozdzielczość
const uint8_t barWidth    = 6;   // węższe słupki
const uint8_t barGap      = 4;   // trochę mniejszy odstęp


I zostaw pętlę segmentową jak była – będziesz miał więcej cienkich klocków, bardziej „dyskotekowo”.

Możesz też skrócić segmenty, żeby między nimi były przerwy (już teraz jest 0.6f):

int16_t segTop = segBottom - (int16_t)(segmentStep * 0.4f);
// 0.4f -> krótszy klocek, większa przerwa

5. Przykład 3 – „odwrócone” słupki (ciemny słupek na jasnym tle)

Na OLEDzie też można pobawić się tłem:

Przed pętlą:

// jasne tło pod słupkami
u8g2.setDrawColor(1);
u8g2.drawBox(0, eqTopY, SCREEN_WIDTH, eqMaxHeight);

// słupki "dziury" – rysowane jako czarne
u8g2.setDrawColor(0);


A w pętli zamiast drawBox(...) możesz rysować „wycięty” prostokąt (czarny na białym tle).
Na końcu (przed u8g2.sendBuffer()) ustaw z powrotem u8g2.setDrawColor(1); żeby napisy były normalne.

6. Gdzie zmieniać styl 6

vuMeterMode6() ma bardzo podobny kawałek – też pętla for (uint8_t i = 0; i < EQ_BANDS; i++) i rysowanie słupków tylko cieńszych.

Zasada jest ta sama:

szukasz w vuMeterMode6() miejsca, gdzie są:

const uint8_t maxSegments = ...;
const uint8_t barWidth    = ...;
const uint8_t barGap      = ...;


modyfikujesz tak samo jak w stylu 5 (szerokość, ilość segmentów, wzór na segTop / barHeight).

Możesz np. zrobić:

styl 5 – grube słupki ciągłe (jak z przykładu 3),

styl 6 – cienkie segmenty „hi-res”.

Jeśli powiesz mi konkretnie, jaki efekt chcesz (np. „bardzo wąskie słupki na całej szerokości” albo „słupki tylko na środku, reszta pusta”), mogę Ci dać gotowy fragment vuMeterMode5() już przerobiony pod ten wygląd, do wklejenia 1:1.

Powiedziałeś(-aś):
Teraz analizator przy volume do 6 słabo działa  gdzie moge to poprawic w kodzie 
ChatGPT powiedział:
Myślał przez 2m 5s

To, co widzisz (że przy volume 0–6 analizator „słabo rusza”), jest do ustawienia w parametrach analizatora, nie w samym rysowaniu słupków.

Masz trzy główne „gałki”:

eqAnalyzerSensitivity – ogólna czułość

AGC (eqAnalyzerAGC + ANALYZER_AGC_TARGET) – automatyczne wzmocnienie

PreGain – czy analizator patrzy przed głośnością, czy po (czyli ma reagować na volume, czy nie)

Pokażę Ci konkretnie, gdzie to ruszyć w Twoim kodzie.

1. Najprostsze: podbij czułość analizatora

W Twoim main.cpp masz taki fragment przy globalnych zmiennych (u Ciebie wygląda prawie 1:1 tak):

// Runtime EQ / Analyzer globals (for AudioRuntimeEQ_Evo)
bool eqEnabled = false;                        // DSP EQ off by default (only analyzer)
bool eqAnalyzerEnabled = true;                 // enable FFT analyzer
float eqBandGains[RUNTIME_EQ_BANDS] = {0.0f};  // 16-band EQ gains in dB (all 0dB)

// Analyzer control globals required by AudioRuntimeEQ_Evo.cpp
float eqAnalyzerSensitivity = DEFAULT_ANALYZER_SENSITIVITY;  // start from default sensitivity
bool  eqAnalyzerPreGain     = true;                          // analyze signal before global volume
bool  eqAnalyzerNormalize   = true;                          // enable input normalization
bool  eqAnalyzerAGC         = true;                          // enable automatic gain control

Zrób to tak:

Na początek zmień linijkę z sensitivity na większą, np.:

float eqAnalyzerSensitivity = 0.7f;   // było DEFAULT_ANALYZER_SENSITIVITY (0.3f)


albo nawet:

float eqAnalyzerSensitivity = 1.0f;


Im wyższa wartość, tym większe słupki przy tym samym sygnale.
Domyślne DEFAULT_ANALYZER_SENSITIVITY to 0.3f, więc nic dziwnego, że przy cichszych kawałkach i małym volume wygląda to „leniwie”.

To jest najprostsza korekta: jedna liczba, kompilacja, gotowe.

2. Czy analizator ma reagować na volume? (PreGain)

Teraz tak:

Teraz masz:

bool eqAnalyzerPreGain = true;


To znaczy, że analizator robi FFT na sygnale przed głośnością – czyli nie obchodzi go czy masz volume=3 czy 15, słupki zależą tylko od tego, co leci z radia.

Jeśli chcesz, żeby przy małym volume słupki też były mniejsze, a przy dużym volume większe (czyli żeby zachowywał się bardziej jak VU zależne od gałki głośności) – zmień na:

bool eqAnalyzerPreGain = false;


Wtedy przy volume 0–6 faktycznie będzie „mniejszy”, ale skoro Ty mówisz, że przy 0–6 słabo działa, to raczej chcesz odwrotność:
– więcej czułości, ale nadal niezależnie od gałki volume → zostaw true, podbij sensitivity jak wyżej.

3. Dodatkowe pokrętła (jak będzie Ci mało)

W AudioRuntimeEQ_Evo.h masz jeszcze stałe:

static const float DEFAULT_ANALYZER_SENSITIVITY = 0.3f;
// ...
// ANALYZER_AGC_TARGET, ANALYZER_AGC_SPEED itd.


Jeśli chcesz:

mocniejsze „dopalenie” słabych sygnałów – możesz:

podnieść DEFAULT_ANALYZER_SENSITIVITY (np. na 0.5–0.7),

albo zostawić default, a w main.cpp i tak nadpisać eqAnalyzerSensitivity na większe (to, co pokazałem w pkt 1).

bardziej agresywne AGC (szybsze dopasowanie, większe wzmocnienie) – w tym samym headerze znajdziesz ANALYZER_AGC_TARGET i ANALYZER_AGC_SPEED. Modyfikujesz:

wyższy ANALYZER_AGC_TARGET → chce trzymać wyższy poziom słupków,

mniejszy ANALYZER_AGC_SPEED → wolniej reaguje, większy → szybciej (ale może „pompować”).

Na start naprawdę wystarczy:

float eqAnalyzerSensitivity = 0.7f;   // albo 1.0f

Co konkretnie zrób teraz

W main_with_volume_analyzer_ok.cpp (lub aktualnym main.cpp) znajdź blok:

float eqAnalyzerSensitivity = DEFAULT_ANALYZER_SENSITIVITY;
bool  eqAnalyzerPreGain     = true;
bool  eqAnalyzerNormalize   = true;
bool  eqAnalyzerAGC         = true;


Podmień pierwszą linijkę na:

float eqAnalyzerSensitivity = 0.7f;   // albo dla testu 1.0f