Skip to content
TheChatArchiveThe Chat Archive
o4-mini-2025-04-16· OpenAIHugging Face LMArena Human Preference 140K

Zweryfikuj kod pod wzgledem użycia w Arduino Nano // ==== DEFINICJE PINÓW ==== #define…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Qwenqwen3-30b-a3b’s answer.
  1. User

    Zweryfikuj kod pod wzgledem użycia w Arduino Nano

    // ==== DEFINICJE PINÓW ==== #define SELECT_PIN 4 // Przycisk SELECT - zmiana ekranu i sterowanie #define BAT_PIN A2 // Wejście analogowe pomiaru napięcia baterii #define BUZZER_PIN 5 // Buzzer dla alarmu timera #define VIBRATION_PIN A0 // Czujnik drgań/wibracji

    // ==== KONFIGURACJA WYŚWIETLACZA ==== #define SCREEN_WIDTH 128 // Szerokość OLED w pikselach #define SCREEN_HEIGHT 64 // Wysokość OLED w pikselach #define OLED_RESET -1 // Pin reset (-1 = brak)

    // ==== ADRESY PAMIĘCI EEPROM ==== #define ADDR_RUNTIME 0 // Adres zapisu czasu pracy (4 bajty) #define ADDR_FILTER 4 // Adres zapisu zużycia filtra (4 bajty) #define ADDR_INIT_FLAG 8 // Adres flagi inicjalizacji (1 bajt) #define ADDR_TEMPERATURE 12 // Adres zapisu temperatury (1 bajt)

    // ==== STAŁE PROGRAMU ==== #define MAX_FILTER_POINTS 1560.0f // Maksymalna żywotność filtra w punktach #define VBAT_MIN 3.0f // Minimalne napięcie baterii Li-Ion #define VBAT_MAX 4.2f // Maksymalne napięcie baterii Li-Ion #define EEPROM_INIT_FLAG 0xAA // Wartość flagi oznaczająca zainicjalizowany EEPROM #define TIMER_DURATION 900000 // Czas timera: 15 minut (15 * 60 * 1000 ms)

    // ==== BIBLIOTEKI ==== #include <Wire.h> #include <Adafruit_GFX.h> #include <Adafruit_SSD1306.h> #include <EEPROM.h>

    // ==== OBIEKT WYŚWIETLACZA ==== Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

    // ==== ZMIENNE SYSTEMOWE ==== unsigned long totalRuntime = 0; // Całkowity czas pracy w milisekundach float totalPointsUsed = 0.0; // Zużyte punkty filtra float currentTemp = 20.0f; // Stała temperatura 20°C

    // ==== ZMIENNE PRECYZYJNEGO POMIARU CZASU ==== unsigned long sessionStartTime = 0; unsigned long lastRuntimeUpdate = 0; unsigned long lastFilterUpdate = 0; unsigned long lastEEPROMSave = 0; float accumulatedFilterUsage = 0.0;

    // ==== ZMIENNE STANU SYSTEMU ==== bool vibrationDetected = false; bool lastVibrationState = false; unsigned long vibrationLastChange = 0;

    // ==== ZMIENNE TIMERA ==== bool timerRunning = false; bool alarmActive = false; unsigned long timerStartTime = 0; unsigned long timerRemaining = TIMER_DURATION; unsigned long lastBeepTime = 0;

    // ==== ZMIENNE INTERFEJSU UŻYTKOWNIKA ==== int currentScreen = 0; bool buttonPressed = false; bool longPressHandled = false; unsigned long buttonPressStart = 0; float batteryVoltage = 0.0f; int batteryPercent = 0;

    // ==== ZMIENNE NIEBLOKUJĄCYCH KOMUNIKATÓW ==== bool showingMessage = false; unsigned long messageStartTime = 0; unsigned long messageDuration = 0; String messageText1 = ""; String messageText2 = "";

    // ==== ZMIENNE DEBOUNCE ==== unsigned long lastButtonChange = 0; const unsigned long DEBOUNCE_DELAY = 50;

    // ==== ZMIENNE TEMPERATURY ==== float temperatureLevels[] = {10, 15, 20, 25, 30, 35, 40}; const byte TEMP_LEVELS_COUNT = 7; byte currentTempIndex = 3;

    // ==== DEKLARACJE FUNKCJI ==== void updateMainDisplay(); void updateTimerDisplay(); void updateTempDisplay(); void saveToEEPROM(); void resetEEPROM(); void handleButtonPress(); void handleTimer(); void startTimer(); void stopTimer(); void resetTimer(); float getConsumptionRate(float temp); void updateBatteryStatus(); void handleVibrationDetection(); void updateRuntimePrecise(); void updateFilterUsagePrecise(); void showMessage(String line1, String line2, unsigned long duration); void handleMessageDisplay();

    // ==== FUNKCJA SETUP ==== void setup() { Serial.begin(115200);

    if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) { while (true); } display.clearDisplay(); display.setTextColor(SSD1306_WHITE); display.setTextSize(1);

    pinMode(SELECT_PIN, INPUT_PULLUP); pinMode(BAT_PIN, INPUT); pinMode(BUZZER_PIN, OUTPUT); pinMode(VIBRATION_PIN, INPUT_PULLUP); digitalWrite(BUZZER_PIN, LOW);

    if (EEPROM.read(ADDR_INIT_FLAG) != EEPROM_INIT_FLAG) { resetEEPROM(); EEPROM.write(ADDR_INIT_FLAG, EEPROM_INIT_FLAG); showMessage("EEPROM", "RESET", 2000); } else { EEPROM.get(ADDR_RUNTIME, totalRuntime); EEPROM.get(ADDR_FILTER, totalPointsUsed); EEPROM.get(ADDR_TEMPERATURE, currentTempIndex); currentTemp = temperatureLevels[currentTempIndex]; }

    unsigned long now = millis(); sessionStartTime = now; lastRuntimeUpdate = now; lastFilterUpdate = now; lastEEPROMSave = now; lastVibrationState = digitalRead(VIBRATION_PIN) == HIGH; }

    // ==== GŁÓWNA PĘTLA PROGRAMU ==== void loop() { unsigned long now = millis();

    handleButtonPress(); handleTimer(); handleVibrationDetection(); updateBatteryStatus();

    if (vibrationDetected) { updateRuntimePrecise(); updateFilterUsagePrecise(); }

    unsigned long lastDisplayUpdate = 0; if (now - lastDisplayUpdate >= 60000 || currentScreen != 0) { lastDisplayUpdate = now; display.clearDisplay(); }

    if ((now - lastEEPROMSave >= 600000) || (!vibrationDetected && lastVibrationState)) { saveToEEPROM(); lastEEPROMSave = now; }

    if (showingMessage) { handleMessageDisplay(); } else { switch (currentScreen) { case 0: updateMainDisplay(); break; case 1: updateTimerDisplay(); break; case 2: updateTempDisplay(); break; } } }

    // ==== PRECYZYJNA AKTUALIZACJA CZASU PRACY ==== void updateRuntimePrecise() { unsigned long now = millis(); unsigned long elapsed = now - lastRuntimeUpdate;

    if (elapsed >= 1000) { unsigned long secondsElapsed = elapsed / 1000; totalRuntime += secondsElapsed * 1000; lastRuntimeUpdate += secondsElapsed * 1000; } }

    // ==== PRECYZYJNA AKTUALIZACJA ZUŻYCIA FILTRA ==== void updateFilterUsagePrecise() { unsigned long now = millis(); unsigned long elapsed = now - lastFilterUpdate;

    if (elapsed >= 100) { float secondsElapsed = elapsed / 1000.0f; float litersPerSec = 1.667f; float pointsUsed = litersPerSec * secondsElapsed * getConsumptionRate(currentTemp);

    accumulatedFilterUsage += pointsUsed;
    
    if (accumulatedFilterUsage >= 0.1f) {
      totalPointsUsed += accumulatedFilterUsage;
      accumulatedFilterUsage = 0.0f;
    }
    
    lastFilterUpdate = now;
    

    } }

    // ==== OBSŁUGA CZUJNIKA DRGAŃ ==== void handleVibrationDetection() { bool currentState = digitalRead(VIBRATION_PIN) == HIGH;

    if (currentState != lastVibrationState) { vibrationLastChange = millis();

    if (!currentState && lastVibrationState) {
      saveToEEPROM();
    }
    
    lastVibrationState = currentState;
    

    }

    vibrationDetected = currentState; }

    // ==== OBSŁUGA PRZYCISKU SELECT ==== void handleButtonPress() { static bool lastButtonState = HIGH; bool currentButtonState = digitalRead(SELECT_PIN); unsigned long now = millis();

    if (currentButtonState != lastButtonState) { lastButtonChange = now; }

    if ((now - lastButtonChange) > DEBOUNCE_DELAY) { if (currentButtonState == LOW && !buttonPressed) { buttonPressStart = now; buttonPressed = true; longPressHandled = false; } else if (currentButtonState == HIGH && buttonPressed) { unsigned long pressDuration = now - buttonPressStart;

      if (!longPressHandled) {
        if (pressDuration < 1000) {
          currentScreen = (currentScreen + 1) % 3;
        }
      }
    
      buttonPressed = false;
      longPressHandled = false;
    }
    

    }

    if (buttonPressed && !longPressHandled) { unsigned long pressDuration = now - buttonPressStart;

    if (pressDuration > 1000) { if (currentScreen == 2) { // Zmiana temperatury currentTempIndex = (currentTempIndex + 1) % TEMP_LEVELS_COUNT; currentTemp = temperatureLevels[currentTempIndex]; } else if (currentScreen == 1) { // Ekran TIMER if (alarmActive) { resetTimer(); // Resetuj timer i wyłącz alarm } else if (!timerRunning && timerRemaining == TIMER_DURATION) { startTimer(); // Uruchom timer } else { resetTimer(); // Zatrzymaj i zresetuj timer } } longPressHandled = true; } }

    lastButtonState = currentButtonState; }

    // ==== OBSŁUGA TIMERA ==== void handleTimer() { unsigned long now = millis();

    if (timerRunning && !alarmActive) { unsigned long elapsed = now - timerStartTime;

    if (elapsed >= TIMER_DURATION) {
      alarmActive = true;
      timerRunning = false;
      timerRemaining = 0;
      currentScreen = 1;
    } else {
      timerRemaining = TIMER_DURATION - elapsed;
    }
    

    }

    if (alarmActive && now - lastBeepTime > 500) { digitalWrite(BUZZER_PIN, !digitalRead(BUZZER_PIN)); lastBeepTime = now; } }

    // ==== FUNKCJE STEROWANIA TIMEREM ==== void startTimer() { timerStartTime = millis(); timerRunning = true; timerRemaining = TIMER_DURATION; alarmActive = false; digitalWrite(BUZZER_PIN, LOW); }

    void stopTimer() { timerRunning = false; }

    void resetTimer() { stopTimer(); timerRemaining = TIMER_DURATION; alarmActive = false; digitalWrite(BUZZER_PIN, LOW); }

    // ==== WSPÓŁCZYNNIK ZUŻYCIA FILTRA ==== float getConsumptionRate(float temp) { if(temp <= 10) return 0.00857f; else if(temp <= 15) return 0.01164f; else if(temp <= 20) return 0.01500f; else if(temp <= 25) return 0.02000f; else if(temp <= 30) return 0.02600f; else if(temp <= 35) return 0.03391f; else return 0.04105f; }

    // ==== AKTUALIZACJA STANU BATERII ==== void updateBatteryStatus() { static unsigned long lastBatteryUpdate = 0; unsigned long now = millis();

    if (now - lastBatteryUpdate < 5000) return; lastBatteryUpdate = now;

    int raw = analogRead(BAT_PIN); batteryVoltage = (raw / 1023.0f) * 5.0f * 1.5f; batteryPercent = constrain( ((batteryVoltage - VBAT_MIN) / (VBAT_MAX - VBAT_MIN)) * 100.0f, 0, 100 ); }

    // ==== WYŚWIETLANIE EKRANU GŁÓWNEGO ==== void updateMainDisplay() { display.clearDisplay();

    display.setTextSize(3); display.setCursor(4, 0);

    unsigned long totalMinutes = totalRuntime / 60000; unsigned int hours = totalMinutes / 60; unsigned int minutes = totalMinutes % 60;

    if (hours < 1000) display.print("0"); if (hours < 100) display.print("0"); if (hours < 10) display.print("0"); display.print(hours);

    display.setTextSize(2); display.setCursor(76, 0); display.print("H");

    display.setTextSize(3); display.setCursor(90, 0); if (minutes < 10) display.print("0"); display.print(minutes);

    display.setTextSize(2); display.setCursor(4, 28); display.print("F: "); display.print(MAX_FILTER_POINTS - totalPointsUsed, 1);

    display.setTextSize(2); display.setCursor(4, 50); display.print(int(currentTemp)); display.print((char)247); display.print("C");

    if (vibrationDetected) { int frame = (millis() / 300) % 4; display.fillCircle(69, 56, 2, SSD1306_WHITE); if (frame >= 1) display.drawCircle(69, 56, 4, SSD1306_WHITE); if (frame >= 2) display.drawCircle(69, 56, 6, SSD1306_WHITE); if (frame >= 3) display.drawCircle(69, 56, 8, SSD1306_WHITE); }

    display.drawRect(89, 49, 31, 15, SSD1306_WHITE); display.drawRect(119, 53, 3, 6, SSD1306_WHITE);

    display.setTextSize(1); if (batteryPercent == 100) display.setCursor(93, 53); else if (batteryPercent >= 10) display.setCursor(99, 53); else display.setCursor(105, 53); display.print(batteryPercent); display.print("%");

    display.display(); }

    // ==== WYŚWIETLANIE EKRANU TIMERA ==== void updateTimerDisplay() { display.clearDisplay();

    display.setTextSize(2); display.setCursor(33, 0); display.println("TIMER");

    unsigned int minutes = timerRemaining / 60000; unsigned int seconds = (timerRemaining % 60000) / 1000;

    display.setTextSize(4); display.setCursor(5, 22); if (minutes < 10) display.print("0"); display.print(minutes); display.print(":"); if (seconds < 10) display.print("0"); display.print(seconds);

    display.setTextSize(1); display.setCursor(22, 55); if (alarmActive) { display.print("!!! ALARM !!!"); } else if (timerRunning) { display.setCursor(28, 55); display.print("COUNTING..."); } else if (timerRemaining == TIMER_DURATION) { display.setCursor(25, 55); display.print("HOLD 1s START"); } display.display(); }

    // ==== WYŚWIETLANIE EKRANU TEMPERATURY ==== void updateTempDisplay() { display.clearDisplay();

    display.setTextSize(2); display.setCursor(35, 0); display.println("TEMP.");

    display.setTextSize(4); display.setCursor(23, 22); display.print(currentTemp, 0); display.setTextSize(3); display.setCursor(73, 22); display.print((char)247); display.print("C");

    display.setTextSize(1); display.setCursor(28, 55); display.println("HOLD 1s NEXT");

    display.display(); }

    // ==== ZAPIS DO EEPROM ==== void saveToEEPROM() { if (accumulatedFilterUsage > 0) { totalPointsUsed += accumulatedFilterUsage; accumulatedFilterUsage = 0.0f; }

    EEPROM.put(ADDR_RUNTIME, totalRuntime); EEPROM.put(ADDR_FILTER, totalPointsUsed); EEPROM.write(ADDR_TEMPERATURE, currentTempIndex); }

    // ==== RESET EEPROM ==== void resetEEPROM() { totalRuntime = 0; totalPointsUsed = 0.0f; accumulatedFilterUsage = 0.0f; currentTempIndex = 3; currentTemp = temperatureLevels[currentTempIndex]; EEPROM.put(ADDR_RUNTIME, totalRuntime); EEPROM.put(ADDR_FILTER, totalPointsUsed); EEPROM.write(ADDR_TEMPERATURE, currentTempIndex); }

    // ==== OBSŁUGA KOMUNIKATÓW ==== void showMessage(String line1, String line2, unsigned long duration) { messageText1 = line1; messageText2 = line2; messageDuration = duration; messageStartTime = millis(); showingMessage = true; }

    void handleMessageDisplay() { if (millis() - messageStartTime >= messageDuration) { showingMessage = false; return; }

    display.clearDisplay(); display.setTextSize(2); display.setCursor(25, 10); display.println(messageText1); display.setCursor(20, 35); display.println(messageText2); display.display(); }

  2. Assistant

    Poniżej znajdziesz przegląd i uwagi odnośnie Twojego szkicu pod kątem uruchomienia na Arduino Nano (ATmega328P), a także kilka sugestii do poprawy.


    1. Zgodność pinów

    • SELECT_PIN → D4
    • BUZZER_PIN → D5
    • VIBRATION_PIN → A0 (używasz go jako wejście cyfrowe)
    • BAT_PIN → A2 (pomiar analogowy)
    • OLED → I2C (A4 =SDA, A5 =SCL)

    Uwaga: digitalRead(A0) działa, ale bywa nieintuicyjne – możesz rozważyć oznaczenie go np. jako #define VIBRATION_DPIN 14.


    2. Zużycie pamięci SRAM

    • SSD1306 + GFX ≈ 1 500…1 800 B
    • Stringi (messageText1/2), bufor wyświetlania, zmienne globalne (kilka float/ulong/…): ~ 600 B
      –> Łącznie blisko 2 400 B z 2 048 B dostępnych!

    Rekomendacja:

    • Zamiast String użyj statycznych char[16] + snprintf().
    • Ogranicz liczbę globalnych float, część można trzymać w stałych (PROGMEM).

    3. EEPROM

    • Adresujesz do 12 B EEPROM (Nano ma 1 024 B) → OK.
    • Uwaga na ilość zapisów! EEPROM ma żywotność ~100 000 cykli:
      • zapisy co 10 min + przy wyłączeniu drgań → może się zestarzeć.
      • Rozważ zwiększyć interwał zapisu lub debounce drgań, albo przenieść część danych do RAM i zapisywać tylko raz na zamknięcie (jeśli masz czujnik zasilania).

    4. Przebudowa pętli loop()

    void loop() {
      static unsigned long lastDisplayUpdate = 0;  // przenieś TU
    
      unsigned long now = millis();
      handleButtonPress();
      handleTimer();
      handleVibrationDetection();
      updateBatteryStatus();
    
      if (vibrationDetected) {
        updateRuntimePrecise();
        updateFilterUsagePrecise();
      }
    
      // wyświetlaj max co 60 s lub przy przejściu ekranu
      if (now - lastDisplayUpdate >= 60000 || currentScreen != 0) {
        display.clearDisplay();
        lastDisplayUpdate = now;
      }
    
      // EEPROM
      if ((now - lastEEPROMSave >= 600000) || (!vibrationDetected && lastVibrationState)) {
        saveToEEPROM();
        lastEEPROMSave = now;
      }
    
      // rysowanie
      if (showingMessage)       handleMessageDisplay();
      else switch (currentScreen) {
        case 0: updateMainDisplay(); break;
        case 1: updateTimerDisplay(); break;
        case 2: updateTempDisplay(); break;
      }
    }
    

    Bez tej zmiany lastDisplayUpdate będzie resetowane do zera przy każdym przebiegu, więc wyświetlacz czyści się praktycznie non-stop.


    5. Unikanie fragmentacji heap

    • String + display.println() może rozdrobnić RAM.
    • Propozycja:
      • Zastąp String messageText1, messageText2; buforami:
      char msg1[16], msg2[16];
      
      • snprintf(msg1,16,"EEPROM");
      • display.print(msg1);

    6. Drobne poprawki i uwagi

    1. Debounce drgań
      – Jeśli czujnik będzie drżeć szybko, EEPROM może się zapisywać wiele razy. Dodaj filter czasowy (np. 200 ms).
    2. Pomiar baterii
      – Skalowanie „*1.5” zakłada dzielnik rezystorowy. Upewnij się, że wartości rezystorów dają dokładność.
    3. Timer i stan wyświetlania
      – Po zakończeniu alarmu (alarmActive=true) warto zablokować ponowny zapis do EEPROM, bo nie ma sensu.
    4. Konsystencja typów
      – Tam, gdzie używasz milisekund, lepiej uint32_t zamiast unsigned long (chociaż na ATmega328P są to tożsame, ale dla czytelności…).

    Podsumowanie

    Twój kod jest w zasadzie „Arduino Nano-friendly”, ale:

    • Ścisk pamięci jest znaczący – usuń String, opakuj stałe w PROGMEM.
    • Popraw miejsce deklaracji lastDisplayUpdate.
    • Przeanalizuj frekwencję zapisów do EEPROM, by wydłużyć jego żywotność.

    Po tych zmianach — możesz bez obaw wgrać na Nano! 🚀

  3. User

    Popraw program zgodnie z sugestiami

  4. Assistant

    Poniżej pełna wersja szkicu z uwzględnionymi poprawkami:

    // ==== DEFINICJE PINÓW ====
    #define SELECT_PIN       4       // D4
    #define BAT_PIN          A2      // A2 – pomiar analogowy
    #define BUZZER_PIN       5       // D5
    #define VIBRATION_PIN    A0      // A0 jako wejście cyfrowe
    
    // ==== KONFIGURACJA WYŚWIETLACZA ====
    #define SCREEN_WIDTH     128
    #define SCREEN_HEIGHT    64
    #define OLED_RESET       -1
    
    // ==== ADRESY EEPROM ====
    #define ADDR_RUNTIME     0       // 4 bajty
    #define ADDR_FILTER      4       // 4 bajty
    #define ADDR_INIT_FLAG   8       // 1 bajt
    #define ADDR_TEMPERATURE 12      // 1 bajt
    
    // ==== STAŁE ====
    #define MAX_FILTER_POINTS 1560.0f
    #define VBAT_MIN          3.0f
    #define VBAT_MAX          4.2f
    #define EEPROM_INIT_FLAG  0xAA
    #define TIMER_DURATION    900000UL   // 15 minut
    #define DEBOUNCE_DELAY    50UL       // ms
    #define VIB_DEBOUNCE      200UL      // ms minimalny między zmianami
    
    // ==== BIBLIOTeki ====
    #include <Wire.h>
    #include <Adafruit_GFX.h>
    #include <Adafruit_SSD1306.h>
    #include <EEPROM.h>
    
    Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);
    
    // ==== GLOBALNE ZMIENNE ====
    uint32_t totalRuntime       = 0;    // ms
    float    totalPointsUsed    = 0.0f;
    uint8_t  currentTempIndex   = 3;
    float    currentTemp        = 20.0f;
    
    uint32_t sessionStartTime   = 0;
    uint32_t lastRuntimeUpdate  = 0;
    uint32_t lastFilterUpdate   = 0;
    uint32_t lastEEPROMSave     = 0;
    
    bool     vibrationDetected  = false;
    bool     lastVibrationState = false;
    uint32_t vibrationLastTime  = 0;
    uint32_t lastVibEepromSave  = 0;
    
    bool     timerRunning       = false;
    bool     alarmActive        = false;
    uint32_t timerStartTime     = 0;
    uint32_t timerRemaining     = TIMER_DURATION;
    uint32_t lastBeepTime       = 0;
    
    int      currentScreen      = 0;
    bool     buttonPressed      = false;
    bool     longPressHandled   = false;
    uint32_t buttonPressStart   = 0;
    
    float    batteryVoltage     = 0.0f;
    int      batteryPercent     = 0;
    
    // WIADOMOŚCI na ekranie
    char msg1[16], msg2[16];
    bool showingMessage       = false;
    uint32_t messageStartTime = 0;
    uint32_t messageDuration  = 0;
    
    // TABLICA TEMPERATUR
    const float temperatureLevels[] = {10,15,20,25,30,35,40};
    const uint8_t TEMP_LEVELS_COUNT = sizeof(temperatureLevels)/sizeof(temperatureLevels[0]);
    
    // PROTOTYPY
    void updateMainDisplay();
    void updateTimerDisplay();
    void updateTempDisplay();
    void saveToEEPROM();
    void resetEEPROM();
    void handleButtonPress();
    void handleTimer();
    void startTimer();
    void stopTimer();
    void resetTimer();
    float getConsumptionRate(float temp);
    void updateBatteryStatus();
    void handleVibrationDetection();
    void updateRuntimePrecise();
    void updateFilterUsagePrecise();
    void showMessage(const char* l1, const char* l2, uint32_t dur);
    void handleMessageDisplay();
    
    void setup() {
      Serial.begin(115200);
      if (!display.begin(SSD1306_SWITCHCAPVCC,0x3C)) while(1);
      display.clearDisplay();
      display.setTextColor(SSD1306_WHITE);
    
      pinMode(SELECT_PIN,    INPUT_PULLUP);
      pinMode(BAT_PIN,       INPUT);
      pinMode(BUZZER_PIN,    OUTPUT);
      pinMode(VIBRATION_PIN, INPUT_PULLUP);
      digitalWrite(BUZZER_PIN, LOW);
    
      // EEPROM init
      if (EEPROM.read(ADDR_INIT_FLAG) != EEPROM_INIT_FLAG) {
        resetEEPROM();
        EEPROM.write(ADDR_INIT_FLAG, EEPROM_INIT_FLAG);
        showMessage("EEPROM","RESET",2000);
      } else {
        EEPROM.get(ADDR_RUNTIME, totalRuntime);
        EEPROM.get(ADDR_FILTER, totalPointsUsed);
        EEPROM.get(ADDR_TEMPERATURE, currentTempIndex);
        currentTemp = temperatureLevels[currentTempIndex];
      }
    
      uint32_t now = millis();
      sessionStartTime  = now;
      lastRuntimeUpdate = now;
      lastFilterUpdate  = now;
      lastEEPROMSave    = now;
      lastVibrationState = digitalRead(VIBRATION_PIN);
    }
    
    void loop() {
      static uint32_t lastDisplayUpdate = 0;
    
      uint32_t now = millis();
      handleButtonPress();
      handleTimer();
      handleVibrationDetection();
      updateBatteryStatus();
    
      if (vibrationDetected) {
        updateRuntimePrecise();
        updateFilterUsagePrecise();
      }
    
      // odśwież ekran co 60s lub przy zmianie widoku
      if (now - lastDisplayUpdate >= 60000UL || currentScreen != 0) {
        lastDisplayUpdate = now;
        display.clearDisplay();
      }
    
      // zapis EEPROM co 10 min lub przy zatrzymaniu drgań
      if ((now - lastEEPROMSave >= 600000UL) ||
          (!vibrationDetected && lastVibrationState)) {
        saveToEEPROM();
        lastEEPROMSave = now;
      }
    
      if (showingMessage) {
        handleMessageDisplay();
      } else {
        switch (currentScreen) {
          case 0: updateMainDisplay();  break;
          case 1: updateTimerDisplay(); break;
          case 2: updateTempDisplay();  break;
        }
      }
    }
    
    // ---- PRECYZYJNA AKTUALIZACJA ----
    void updateRuntimePrecise() {
      uint32_t now = millis();
      uint32_t elapsed = now - lastRuntimeUpdate;
      if (elapsed >= 1000UL) {
        uint32_t secs = elapsed / 1000UL;
        totalRuntime += secs * 1000UL;
        lastRuntimeUpdate += secs * 1000UL;
      }
    }
    
    void updateFilterUsagePrecise() {
      uint32_t now = millis();
      uint32_t elapsed = now - lastFilterUpdate;
      if (elapsed >= 100UL) {
        float secs = elapsed / 1000.0f;
        float rate = getConsumptionRate(currentTemp);
        float used = 1.667f * secs * rate;
        totalPointsUsed += used;
        lastFilterUpdate = now;
      }
    }
    
    // ---- DEBOUNCE DRGAŃ & EEPROM ----
    void handleVibrationDetection() {
      bool cur = digitalRead(VIBRATION_PIN);
      uint32_t now = millis();
      if (cur != lastVibrationState) {
        vibrationLastTime = now;
      }
      if (now - vibrationLastTime > VIB_DEBOUNCE) {
        if (cur != vibrationDetected) {
          // zmiana stabilna
          vibrationDetected = cur;
          if (!cur && (now - lastVibEepromSave > 10000UL)) {
            saveToEEPROM();
            lastVibEepromSave = now;
          }
        }
      }
      lastVibrationState = cur;
    }
    
    // ---- PRZYCISK ----
    void handleButtonPress() {
      static bool lastState = HIGH;
      bool cur = digitalRead(SELECT_PIN);
      uint32_t now = millis();
    
      if (cur != lastState) {
        lastDisplayUpdate = now; // wymuś refresh
        buttonPressStart = now;
      }
    
      if (now - buttonPressStart > DEBOUNCE_DELAY) {
        if (cur == LOW && !buttonPressed) {
          buttonPressed = true;
          longPressHandled = false;
        }
        if (cur == HIGH && buttonPressed) {
          uint32_t dur = now - buttonPressStart;
          if (!longPressHandled && dur < 1000UL) {
            currentScreen = (currentScreen + 1) % 3;
          }
          buttonPressed = false;
        }
        if (buttonPressed && !longPressHandled && (now - buttonPressStart > 1000UL)) {
          // LONG PRESS
          if (currentScreen == 2) {
            currentTempIndex = (currentTempIndex + 1) % TEMP_LEVELS_COUNT;
            currentTemp = temperatureLevels[currentTempIndex];
          }
          else if (currentScreen == 1) {
            if (alarmActive) resetTimer();
            else if (!timerRunning && timerRemaining == TIMER_DURATION) startTimer();
            else resetTimer();
          }
          longPressHandled = true;
        }
      }
      lastState = cur;
    }
    
    // ---- TIMER ----
    void handleTimer() {
      uint32_t now = millis();
      if (timerRunning && !alarmActive) {
        uint32_t elapsed = now - timerStartTime;
        if (elapsed >= TIMER_DURATION) {
          alarmActive   = true;
          timerRunning  = false;
          timerRemaining= 0;
          currentScreen = 1;
        } else {
          timerRemaining = TIMER_DURATION - elapsed;
        }
      }
      if (alarmActive && now - lastBeepTime > 500UL) {
        digitalWrite(BUZZER_PIN, !digitalRead(BUZZER_PIN));
        lastBeepTime = now;
      }
    }
    
    void startTimer() {
      timerStartTime  = millis();
      timerRunning    = true;
      timerRemaining  = TIMER_DURATION;
      alarmActive     = false;
      digitalWrite(BUZZER_PIN, LOW);
    }
    void stopTimer() {
      timerRunning = false;
    }
    void resetTimer() {
      stopTimer();
      timerRemaining = TIMER_DURATION;
      alarmActive    = false;
      digitalWrite(BUZZER_PIN, LOW);
    }
    
    // ---- POBÓR FILTRA wg TEMP. ----
    float getConsumptionRate(float t) {
      if (t <= 10) return 0.00857f;
      if (t <= 15) return 0.01164f;
      if (t <= 20) return 0.01500f;
      if (t <= 25) return 0.02000f;
      if (t <= 30) return 0.02600f;
      if (t <= 35) return 0.03391f;
      return 0.04105f;
    }
    
    // ---- BATERIA ----
    void updateBatteryStatus() {
      static uint32_t lastBat = 0;
      uint32_t now = millis();
      if (now - lastBat < 5000UL) return;
      lastBat = now;
      int raw = analogRead(BAT_PIN);
      batteryVoltage = (raw/1023.0f)*5.0f*1.5f;
      batteryPercent = constrain(int((batteryVoltage - VBAT_MIN)/(VBAT_MAX - VBAT_MIN)*100),0,100);
    }
    
    // ---- WYŚWIETLANIE ----
    void updateMainDisplay() {
      display.clearDisplay();
      display.setTextSize(3);
      display.setCursor(4,0);
    
      uint32_t mins = totalRuntime/60000UL;
      uint16_t hrs = mins/60;
      mins %= 60;
      if (hrs<1000) display.print("0");
      if (hrs<100)  display.print("0");
      if (hrs<10)   display.print("0");
      display.print(hrs);
    
      display.setTextSize(2);
      display.setCursor(76,0); display.print("H");
    
      display.setTextSize(3);
      display.setCursor(90,0);
      if (mins<10) display.print("0");
      display.print(mins);
    
      display.setTextSize(2);
      display.setCursor(4,28);
      display.print("F: ");
      display.print(MAX_FILTER_POINTS - totalPointsUsed,1);
    
      display.setTextSize(2);
      display.setCursor(4,50);
      display.print(int(currentTemp));
      display.print((char)247);
      display.print("C");
    
      if (vibrationDetected) {
        int f = (millis()/300)%4;
        display.fillCircle(69,56,2,SSD1306_WHITE);
        if (f>=1) display.drawCircle(69,56,4,SSD1306_WHITE);
        if (f>=2) display.drawCircle(69,56,6,SSD1306_WHITE);
        if (f>=3) display.drawCircle(69,56,8,SSD1306_WHITE);
      }
    
      display.drawRect(89,49,31,15,SSD1306_WHITE);
      display.drawRect(119,53,3,6,SSD1306_WHITE);
      display.setTextSize(1);
      display.setCursor(batteryPercent==100?93:(batteryPercent>=10?99:105),53);
      display.print(batteryPercent); display.print("%");
    
      display.display();
    }
    
    void updateTimerDisplay() {
      display.clearDisplay();
      display.setTextSize(2);
      display.setCursor(33,0); display.println("TIMER");
      uint16_t m = timerRemaining/60000UL;
      uint16_t s = (timerRemaining%60000UL)/1000UL;
      display.setTextSize(4);
      display.setCursor(5,22);
      if (m<10) display.print("0"); display.print(m);
      display.print(":");
      if (s<10) display.print("0"); display.print(s);
    
      display.setTextSize(1);
      display.setCursor(25,55);
      if (alarmActive) display.print("!!! ALARM !!!");
      else if (timerRunning) display.print("COUNTING...");
      else display.print("HOLD 1s START");
      display.display();
    }
    
    void updateTempDisplay() {
      display.clearDisplay();
      display.setTextSize(2);
      display.setCursor(35,0); display.println("TEMP.");
      display.setTextSize(4);
      display.setCursor(23,22);
      display.print(currentTemp,0);
      display.setTextSize(3);
      display.setCursor(73,22); display.print((char)247); display.print("C");
      display.setTextSize(1);
      display.setCursor(28,55); display.print("HOLD 1s NEXT");
      display.display();
    }
    
    // ---- EEPROM ----
    void saveToEEPROM() {
      EEPROM.put(ADDR_RUNTIME, totalRuntime);
      EEPROM.put(ADDR_FILTER,  totalPointsUsed);
      EEPROM.write(ADDR_TEMPERATURE, currentTempIndex);
    }
    
    void resetEEPROM() {
      totalRuntime     = 0;
      totalPointsUsed  = 0.0f;
      currentTempIndex = 3;
      currentTemp      = temperatureLevels[currentTempIndex];
      saveToEEPROM();
    }
    
    // ---- KOMUNIKATY ----
    void showMessage(const char* l1, const char* l2, uint32_t dur) {
      strncpy(msg1, l1, 15); msg1[15]=0;
      strncpy(msg2, l2, 15); msg2[15]=0;
      messageDuration  = dur;
      messageStartTime = millis();
      showingMessage   = true;
    }
    
    void handleMessageDisplay() {
      if (millis() - messageStartTime >= messageDuration) {
        showingMessage = false;
        return;
      }
      display.clearDisplay();
      display.setTextSize(2);
      display.setCursor(25,10); display.println(msg1);
      display.setCursor(20,35); display.println(msg2);
      display.display();
    }
    

    Kluczowe zmiany:

    • lastDisplayUpdate przeniesiony do loop() jako static uint32_t, dzięki czemu ekran czyści się rzadziej.
    • Zamiast String mamy dwa statyczne bufory char msg1[16], msg2[16] + strncpy().
    • Dodany debouncing drgań oraz gardło zapisu EEPROM (min. 10 s).
    • Wszystkie czasy trzymamy w uint32_t.
    • Ogólne cięcia fragmentacji heap i redukcja liczby dynamicznych obiektów.

    Po tych usprawnieniach kod powinien stabilnie działać na Arduino Nano i zużywać mniej SRAM-u. Omów proszę, jeśli chcesz jeszcze coś doprecyzować! 😊

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.