miercuri, 27 mai 2026

Fântână pentru Pisa

 Am achizitionat de pe Temu o fantana pentru animalele de companie, la un pret modic. Are o pompa, destul de silentioasa, cu debit reglabil. Am vrut sa o modernizez, astfel incat functionarea sa fie temporizata si numai la detectia pisicii.

Initial am incercat cu senzor PIR AM312, dar din cauza limitarilor senzorului (nu se poate regla timpul de detectie) am renuntat si am incercat cu senzor laser VL53L0XV2. 

Partea dificila este setarea in program a distantei de detectie ; dar se poate scrie un program simplu care sa afiseze pe monitorul serial momentul cand senzorul detecteaza corpul in miscare. In functie de acest prag se modifica corespunzator programul. Deocamdata functioneaza destul de bine...


 


#include "Adafruit_VL53L0X.h"

// Configurare Pini
const int pinPompa = 3; 
const int pinLedL = 13; 

// Parametri Proiect Finali
const int distantaPragMax = 170;   // 170 mm (17 cm) - Prag optim de siguranță
const int distantaPragMin = 15;    // Min 1.5 cm - Ignoră reflexiile parazite
const int secundeDetectie = 3;     // Trebuie să stea 3 secunde continuu
const int secundePompa = 180;      // Pompa merge 3 minute
const int minutePauza = 3;         // Pauză de siguranță de 3 minute după băut

Adafruit_VL53L0X lox = Adafruit_VL53L0X();

void setup() {
  pinMode(pinPompa, OUTPUT);
  pinMode(pinLedL, OUTPUT);
  digitalWrite(pinPompa, LOW);
  digitalWrite(pinLedL, LOW);

  Serial.begin(9600);
  while (!Serial) { delay(1); } 

  Serial.println("--- Fantana Pisa ---");

  if (!lox.begin()) {
    while (1) {
      digitalWrite(pinLedL, HIGH); delay(100);
      digitalWrite(pinLedL, LOW); delay(100);
    }
  }
  Serial.println("Sistem pornit si calibrat. Pregatit pentru utilizare.");
}

void loop() {
  VL53L0X_RangingMeasurementData_t measure;
  lox.rangingTest(&measure, false); 

  // Verificăm dacă apare un obiect în zona de băut (între 1.5 cm și 17 cm)
  if (measure.RangeStatus != 4 && measure.RangeMilliMeter >= distantaPragMin && measure.RangeMilliMeter < distantaPragMax) {
    
    Serial.print("[Detecție] Obiect la ");
    Serial.print(measure.RangeMilliMeter);
    Serial.println(" mm. Începe monitorizarea de 3 secunde...");

    unsigned long startDetectie = millis();
    bool prezentaContinua = true;
    int contorSecunde = 0;

    // --- MONITORIZARE 3 SECUNDE ---
    while (millis() - startDetectie < (secundeDetectie * 1000)) {
      lox.rangingTest(&measure, false);
      
      // Dacă pisica pleacă sau se îndepărtează peste 17 cm, anulăm totul 
      if (measure.RangeStatus == 4 || measure.RangeMilliMeter > distantaPragMax || measure.RangeMilliMeter < distantaPragMin) {
        Serial.println("[Anulare] Pisica a plecat înainte de termen.");
        prezentaContinua = false;
        break;
      }
      
      delay(100); 
      contorSecunde++;
      if (contorSecunde % 10 == 0) {
        Serial.print("... confirmat ");
        Serial.print(contorSecunde / 10);
        Serial.println(" sec.");
      }
    }

    // --- DETECȚIE VALIDATĂ ---
    if (prezentaContinua) {
      Serial.println(">>> PISICA CONFIRMATA! PORNESTE POMPA (3 MINUTE) <<<");
      digitalWrite(pinLedL, HIGH);
      digitalWrite(pinPompa, HIGH); 

      // Ciclul de funcționare 3 minute
      for (int s = 1; s <= secundePompa; s++) {
        delay(1000);
        if (s % 30 == 0) {
          Serial.print("Pompa rulează de ");
          Serial.print(s);
          Serial.println(" secunde.");
        }
      }

      Serial.println("<<< Timp expirat. Oprire pompă. >>>");
      digitalWrite(pinPompa, LOW);
      digitalWrite(pinLedL, LOW);

      // --- PERIOADĂ DE PAUZĂ (3 MINUTE) ---
      Serial.println("Intrare în pauza de 3 minute...");
      for (int i = 1; i <= (minutePauza * 2); i++) {
        delay(29900);
        digitalWrite(pinLedL, HIGH); delay(100); digitalWrite(pinLedL, LOW);
      }
      Serial.println("Pauză terminată. Sistemul revine în Stand-by.");
    }
  }

  // Heartbeat Stand-by la fiecare 10 secunde
  static unsigned long timpUltimaClipire = 0;
  if (millis() - timpUltimaClipire > 10000) {
    digitalWrite(pinLedL, HIGH); delay(50); digitalWrite(pinLedL, LOW);
    timpUltimaClipire = millis();
    Serial.println("Stand-by: Monitorizare activă...");
  }
}
Publicat de la Niciun comentariu:

sâmbătă, 4 aprilie 2026

VU metru cu Arduino si ST7735

 Va salut !

La cererea prietenului Dragos (care mi-a trimis un clip cu un vu-metru cu display color), bazandu-ma pe IA am conceput acest vu-metru, cu un Arduino Nano si un display LCD tip ST7735. 

Are un encoder care permite selectia diferitelor tipuri de afisare ; rotirea encoderului permite navigarea printre moduri, apasarea permite selectarea/deselectarea modurilor (se pot selecta toate). Prin combinatiile intre moduri se poate ajunge la o functionare conforma preferintelor.

Semnalul audio se aplica pe pinii A0 si A1 ; audio stereo de la orice preamp (prin 1N4148, 10k, 1-10uF spre masa, A0/A1) sau de la iesirea unui preamplificator de microfon electret (caz in care se unesc A0si A1 iar semnalul afisat va fi mono).

Aici am postat un mic clip cu functionarea.

Enjoy ! 


 


/*
 * VU-METER 04.2026
 * BASED ON GRAPHIC IDEEA OF ericBcreator 
 * https://youtu.be/E2tdxQf2Cbg?si=SEzUlVO9j4TcPfIn

Display    Arduino
SCL       D13
SDA       D11
RST       D9
DC        D8
CS        D10

ENCODER
OUT1      D2
OUT2      D3
SW        D4

INPUT AUDIO : A0 SI A1

*/

#include <Adafruit_GFX.h>    
#include <Adafruit_ST7735.h> 
#include <SPI.h>
#include <Encoder.h>           

#define TFT_CS     10
#define TFT_RST    9
#define TFT_DC     8
Adafruit_ST7735 tft = Adafruit_ST7735(TFT_CS, TFT_DC, TFT_RST);

Encoder myEnc(2, 3);
#define ENC_SW 4 

const char* menuOptions[] = {"PEAK HLD", "FULL SCR", "WIDE AGC", "SMOOTH"};
const uint16_t menuColors[] = {ST7735_WHITE, ST7735_YELLOW, 0x07E0, 0x07FF}; 

bool optStates[] = {true, false, false, false}; 
int menuIndex = 0;
long oldPosition = -999;
int leftPeak = 0, rightPeak = 0;
int lastLeftPeakY = 139, lastRightPeakY = 139;
unsigned long lastPeakMillis = 0;

byte lastStateL[15] = {0}, lastStateR[15] = {0};
int lastLvlH = -1;

const int BORDER_X = 65;      
const int BORDER_W = 58;      
const int BAR_W = 18;         
const int PADDING = 6;        
const int POS_L = BORDER_X + PADDING;      
const int POS_R = BORDER_X + BORDER_W - PADDING - BAR_W; 

void setup() {
  pinMode(ENC_SW, INPUT_PULLUP);
  tft.initR(INITR_BLACKTAB);
  tft.setRotation(0); 
  tft.fillScreen(ST7735_BLACK);
  deseneazaInterfataStatica();
  actualizeazaSelector(0);
}

void loop() {
  long newPos = myEnc.read() / 4;
  if (newPos != oldPosition) {
    menuIndex = abs(newPos % 4);
    actualizeazaSelector(menuIndex);
    oldPosition = newPos;
  }

  if (digitalRead(ENC_SW) == LOW) {
    delay(200); 
    optStates[menuIndex] = !optStates[menuIndex];
    actualizeazaSelector(menuIndex);
    while(digitalRead(ENC_SW) == LOW);
  }

  int gain = optStates[2] ? 450 : 800; 
  int rawL = analogRead(A0);
  int rawR = analogRead(A1);

  int segL = constrain(map(rawL, 10, gain, 0, 15), 0, 15);
  int segR = constrain(map(rawR, 10, gain, 0, 15), 0, 15);
  
  int curPeakL = map(segL, 0, 15, 0, 92);
  int curPeakR = map(segR, 0, 15, 0, 92);
  if (curPeakL > leftPeak) leftPeak = curPeakL;
  if (curPeakR > rightPeak) rightPeak = curPeakR;

  int fallSpeed = optStates[3] ? 100 : 50; 
  if (millis() - lastPeakMillis > fallSpeed) {
    if (leftPeak > 0) leftPeak -= 1; 
    if (rightPeak > 0) rightPeak -= 1;
    lastPeakMillis = millis();
  }

  deseneazaDale(POS_L, segL, lastStateL); 
  deseneazaDale(POS_R, segR, lastStateR);
  
  if (optStates[0]) {
    actualizeazaPeak(POS_L, leftPeak, lastLeftPeakY);
    actualizeazaPeak(POS_R, rightPeak, lastRightPeakY);
  }

  // --- LOGICA LEVEL GAUGE (X=30, Y_start=91, H=49) ---
  int lvlH = constrain(map(rawL, 10, gain, 0, 49), 0, 49); 
  if (lvlH != lastLvlH) {
    int xLvl = 30; int yBottom = 140;
    tft.fillRect(xLvl, 91, 10, 49 - lvlH, 0x000F); // Fundal inactiv
    if (lvlH > 0) {
      tft.fillRect(xLvl, yBottom - lvlH, 10, lvlH, 0x5DFF); // Bara activa
    }
    lastLvlH = lvlH;
  }
  delay(5); 
}

void deseneazaDale(int x, int count, byte last[]) {
  for (int i = 0; i < 15; i++) {
    byte s = (i < count) ? 1 : 0;
    if (s != last[i]) {
      uint16_t c = (s == 1) ? (i < 9 ? ST7735_GREEN : (i < 12 ? ST7735_YELLOW : ST7735_RED)) : 0x1082;
      tft.fillRect(x, 135 - (i * 6), BAR_W, 4, c);
      last[i] = s;
    }
  }
}

void actualizeazaPeak(int x, int p, int &lY) {
  int cY = 139 - p;
  if (cY != lY) {
    tft.drawFastHLine(x, lY, BAR_W, ST7735_BLACK);
    if (p > 2) tft.drawFastHLine(x, cY, BAR_W, ST7735_WHITE);
    lY = cY;
  }
}

void deseneazaInterfataStatica() {
  tft.fillRect(5, 5, 118, 20, ST7735_BLUE);
  tft.setTextColor(ST7735_WHITE);
  tft.setCursor(38, 12); tft.print("VU METER");

  for (int i = 0; i < 4; i++) {
    tft.setTextColor(menuColors[i]);
    tft.setCursor(10, 40 + (i * 12));
    tft.print(menuOptions[i]);
  }

  tft.drawRect(BORDER_X, 40, BORDER_W, 101, ST7735_WHITE); 
  tft.fillRect(POS_L, 145, BAR_W, 12, ST7735_RED);
  tft.fillRect(POS_R, 145, BAR_W, 12, ST7735_RED);
  tft.setTextColor(ST7735_WHITE); 
  tft.setCursor(POS_L + 6, 147); tft.print("L");
  tft.setCursor(POS_R + 6, 147); tft.print("R");

  // --- LEVEL CALIBRATE ---
  int xLvl = 30; int yTop = 90; int yBot = 141;
  tft.drawRect(xLvl - 1, yTop, 12, (yBot - yTop) + 1, ST7735_WHITE); 
  tft.setCursor(12, yTop + 2); tft.print("10");
  tft.setCursor(18, yBot - 8); tft.print("0"); 
  tft.setCursor(20, 147); tft.print("LEVEL"); 

  // Cele 10 gradații 
  for (int i = 0; i <= 10; i++) {
    int yT = yBot - (i * 5);
    tft.drawFastHLine(xLvl - 4, yT, 3, ST7735_WHITE);
    tft.drawFastHLine(xLvl + 11, yT, 3, ST7735_WHITE);
  }
}

void actualizeazaSelector(int index) {
  for(int i = 0; i < 4; i++) {
    tft.fillRect(2, 40 + (i * 12), 7, 8, ST7735_BLACK);
    tft.fillRect(58, 40 + (i * 12), 6, 8, ST7735_BLACK);
    if (i == index) {
      tft.setTextColor(ST7735_RED);
      tft.setCursor(2, 40 + (i * 12));
      tft.print(">");
    }
    if (optStates[i]) {
      tft.fillRect(59, 43 + (i * 12), 3, 3, ST7735_GREEN);
    }
  }
}
Publicat de la Niciun comentariu:

joi, 19 martie 2026

Ceas analogic - OLED GC9A01 si Wemos D1 mini

Acesta este proiectul unui ceas analogic. Se poate configura intr-o multitudine de "fețe". In poze sunt preferatele mele. Enjoy !

 

 


#include <ESP8266WiFi.h>
#include <WiFiUdp.h>
#include <NTPClient.h>
#include <TFT_eSPI.h>
#include <TimeLib.h>

// --- CONFIGURARE WIFI ---
const char *ssid     = "yourSSID";
const char *password = "yourPSW";

TFT_eSPI tft = TFT_eSPI();
TFT_eSprite spr = TFT_eSprite(&tft);
WiFiUDP ntpUDP;
NTPClient timeClient(ntpUDP, "pool.ntp.org", 0, 86400000); // Sincronizare la 24h

uint16_t palettePtr[16];

// --- PROTOTIPURI ---
void drawStickHand(float deg, int len, int tail, int width, int colIdx);
int getOffset(time_t t);

void setup() {
  tft.init();
  tft.setRotation(0);
  tft.fillScreen(TFT_BLACK);
  
  tft.setTextColor(TFT_WHITE);
  tft.setTextDatum(MC_DATUM);
  tft.setFreeFont(&FreeSansBold12pt7b);
  tft.drawString("Conectare...", 120, 120);

  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) delay(500);

  timeClient.begin();
  timeClient.update(); 

  // --- PALETĂ (4 biți = 16 culori) ---
  palettePtr[0] = TFT_BLACK;                 
  palettePtr[1] = tft.color565(230, 0, 0);     // Roșu intens ace
  palettePtr[2] = TFT_WHITE;                   // Cifre / Gradații 
  palettePtr[3] = tft.color565(80, 80, 80);    // Gradații minute (Gri)
  palettePtr[4] = tft.color565(140, 140, 140); // Dată (Gri discret)
  palettePtr[5] = tft.color565(0, 255, 120);   // Verde Neon pentru secundar

  spr.setColorDepth(4); 
  spr.createSprite(240, 240);
  spr.createPalette(palettePtr, 16);
}

void loop() {
  timeClient.update();
  time_t rawTime = timeClient.getEpochTime();
  time_t localTime = rawTime + getOffset(rawTime);
  
  int h = hour(localTime) % 12, m = minute(localTime), s = second(localTime);
  float sDeg = s * 6, mDeg = m * 6 + s * 0.1, hDeg = h * 30 + m * 0.5;

  spr.fillScreen(0); 

  // 1. GRADAȚII MARGINE 
  for (int i = 0; i < 60; i++) {
    float rad = (i * 6 - 90) * 0.0174532925;
    float w = (i % 5 == 0) ? 0.035 : 0.018; 
    int rIn = (i % 5 == 0) ? 105 : 112; 
    int x1 = 120 + cos(rad - w) * rIn; int y1 = 120 + sin(rad - w) * rIn;
    int x2 = 120 + cos(rad + w) * rIn; int y2 = 120 + sin(rad + w) * rIn;
    int x3 = 120 + cos(rad - w) * 120; int y3 = 120 + sin(rad - w) * 120;
    int x4 = 120 + cos(rad + w) * 120; int y4 = 120 + sin(rad + w) * 120;
    spr.fillTriangle(x1, y1, x2, y2, x3, y3, (i % 5 == 0) ? 2 : 3);
    spr.fillTriangle(x2, y2, x3, y3, x4, y4, (i % 5 == 0) ? 2 : 3);
  }

  // 2. CIFRE MARI
  spr.setFreeFont(&FreeSansBold18pt7b); spr.setTextColor(2); spr.setTextDatum(MC_DATUM);
  spr.drawString("12", 120, 42); spr.drawString("06", 120, 198);
  spr.drawString("09", 42, 120); spr.drawString("03", 198, 120);
  
  // 3. DATA (zz-ll-aaaa)
  spr.setFreeFont(&FreeSans9pt7b); spr.setTextColor(4);
  char dataStr[12]; sprintf(dataStr, "%02d-%02d-%04d", day(localTime), month(localTime), year(localTime));
  spr.drawString(dataStr, 120, 155);

  // 4. ACE ORE & MINUTE 
  // Parametri: Unghi, Lungime vârf, Lungime, Lățime, Culoare
  drawStickHand(hDeg, 58, 18, 10, 1); // Ore: Grosime 10px, coadă 18px
  drawStickHand(mDeg, 105, 18, 6, 1); // Minute: Lung (până la marcaje), subțire 6px, coadă 18px

  // 5. SECUNDARUL 
  drawStickHand(sDeg, 110, 25, 2, 5); // Secundar: Foarte subțire 2px, coadă lungă 25px

  // 6. CENTRUL (Cerc alb cu contur negru)
  spr.fillCircle(120, 120, 4, 2); 
  spr.drawCircle(120, 120, 4, 0);

  spr.pushSprite(0, 0);
  delay(150);
}

// --- FUNCȚIE PENTRU ACE DREPTUNGHIULARE  ---
void drawStickHand(float deg, int len, int tail, int width, int colIdx) {
  float rad = (deg - 90) * 0.0174532925;
  // Vector normal pentru lățime constantă
  float nx = -sin(rad) * (width / 2.0);
  float ny = cos(rad) * (width / 2.0);

  // Calculăm cele 4 puncte: coada acului se extinde în direcția opusă vârfului
  int x1 = 120 - cos(rad) * tail + nx; int y1 = 120 - sin(rad) * tail + ny;
  int x2 = 120 - cos(rad) * tail - nx; int y2 = 120 - sin(rad) * tail - ny;
  int x3 = 120 + cos(rad) * len + nx;  int y3 = 120 + sin(rad) * len + ny;
  int x4 = 120 + cos(rad) * len - nx;  int y4 = 120 + sin(rad) * len - ny;

  spr.fillTriangle(x1, y1, x2, y2, x3, y3, colIdx);
  spr.fillTriangle(x2, y2, x3, y3, x4, y4, colIdx);
}

int getOffset(time_t t) {
  tmElements_t tm; breakTime(t, tm);
  if (tm.Month < 3 || tm.Month > 10) return 7200; 
  if (tm.Month > 3 && tm.Month < 10) return 10800;
  int dSun = tm.Day - ((tm.Wday - 1 + 7) % 7);
  if (tm.Month == 3) return (dSun >= 25) ? 10800 : 7200;
  return (dSun >= 25) ? 7200 : 10800;
}

Publicat de la Niciun comentariu:

duminică, 1 martie 2026

O simpla statie de lipit cu Arduino

 

Va salut !

Va prezint statia mea de lipit cu Arduino. Realizata cu AI Gemini, updatata cu Vercel si Qwen ; eu doar am formulat cerintele si am testat codul, deci nu am prea multe merite. Inspiratia mea au fost nenumaratele exemple existente.

Pe scurt : ciocan Pensol SL-10 (cel pe care-l am de mai bine de 15 ani si nu renunt la el, e prea bun !), Arduino Nano, display LED 7 segmente 3 digiti, encoder rotativ, 2 butoane pentru memorare 2 temperaturi de lucru, stand-by dupa 30 minute.

Am testat-o cateva zile, pe parcursul carora am rezolvat diverse buguri. In prezent functioneza destul de bine, zic eu. Am vrut initial cu PID, dar inertia termica mare a ciocanului m-a facut sa renunt ; Qwen a sugerat un algoritm "predictiv" surprinzator de eficient .

Orice comentariu sau sugestie sunt binevenite. Statia este prezentata si pe Elforum (https://www.elforum.info/topic/165506-statie-de-lipit-cu-arduino/), cine vrea o poate modifica dupa cum doreste (recomand Vercel / Perplexity / Qwen / Gemini, nu neaparat in aceasta ordine). Numai bine ! 

 

Update : versiunea imbunatatita/updatata pe Elforum.



 

 

 


/*
//
// STATIE DE LIPIT CU ARDUINO
// DISPLAY LED CU 7 SEGMENTE
//   ENCODER SI 2 MEMORII
// STAND-BY DUPA 30 MINUTE
//     pt PENSOL SL-10
//
//
// mai multe info aici :
// 
// www.elforum.info/topic/165506-statie-de-lipit-cu-arduino
*/


#include <max6675.h>
#include <Encoder.h>
#include <EEPROM.h>
#include <EasyButton.h>
#include <avr/wdt.h>
#include <avr/io.h>
#include <avr/interrupt.h>

// --- CONFIGURARE HARDWARE ---
MAX6675 thermocouple(10, 9, 8);
Encoder myEnc(2, 3);
const int segPins[] = {4, 5, 6, 7, 12, 13, A0}; 
const int digitPins[] = {A3, A4, A5};
const int heaterPin = 11;

// --- VARIABILE CONTROL ---
double Setpoint = 350.0;
double Input = 0;
int pwm = 0;
long oldPosition = 0;
unsigned long lastUpdate = 0;
unsigned long lastEncoderTime = 0;
unsigned long lastAdjustTime = 0;
bool sensorError = false;
int errorCounter = 0;
const int MAX_ERROR_COUNT = 4;

float lastInput = 0;
float tempTrend = 0;
int pwm_hold_base = 150;

// --- LOGICA MEMORIE SI TIMER ---
const int EEPROM_ADDR[] = {0, 2};
int savedTemps[] = {0, 0};
unsigned long blinkUntil = 0;
unsigned long lastActivityTime = 0;
const unsigned long TIMEOUT_OFF = 1800000;
bool isSystemOff = false;

EasyButton btn1(A1);
EasyButton btn2(A2);

// --- VARIABILE PENTRU DISPLAY ---
volatile uint8_t isrCurrentDigit = 0;
volatile int isrDisplayValue = 0;
volatile bool isrDisplayEnabled = true;

// TABEL CIFRE 
byte const digits[] = {
  B00111111, B00000110, B01011011, B01001111, B01100110,
  B01101101, B01111101, B00000111, B01111111, B01101111 
};

// --- FUNCTII AUXILIARE ---
void triggerBlink() { blinkUntil = millis() + 500; }
void resetActivity() { lastActivityTime = millis(); }
void wakeSystem() { if (isSystemOff) isSystemOff = false; resetActivity(); }

void onBtn1Short() { wakeSystem(); if (savedTemps[0] > 0) { Setpoint = savedTemps[0]; lastAdjustTime = millis(); triggerBlink(); } }
void onBtn1Long() { wakeSystem(); savedTemps[0] = (int)Setpoint; EEPROM.put(EEPROM_ADDR[0], savedTemps[0]); triggerBlink(); }
void onBtn2Short() { wakeSystem(); if (savedTemps[1] > 0) { Setpoint = savedTemps[1]; lastAdjustTime = millis(); triggerBlink(); } }
void onBtn2Long() { wakeSystem(); savedTemps[1] = (int)Setpoint; EEPROM.put(EEPROM_ADDR[1], savedTemps[1]); triggerBlink(); }

// --- INTERRUPT SERVICE ROUTINE (DISPLAY) ---
ISR(TIMER1_COMPA_vect) {
  digitalWrite(digitPins[isrCurrentDigit], LOW);
  isrCurrentDigit = (isrCurrentDigit + 1) % 3;
  byte segments = 0;

  if (!isrDisplayEnabled) {
    segments = 0;
  } else if (isrDisplayValue == -1) { 
    if (isrCurrentDigit == 0) segments = B01101101; 
    else if (isrCurrentDigit == 1) segments = B01111000; 
    else segments = B01111100; 
  } else if (isrDisplayValue == -111) { 
    if (isrCurrentDigit == 0) segments = B01111001; 
    else segments = B01010000; 
  } else {
    int t = abs(isrDisplayValue);
    int d = 0;
    if (isrCurrentDigit == 0) d = (t / 100) % 10;
    else if (isrCurrentDigit == 1) d = (t / 10) % 10;
    else d = t % 10;

    if (isrCurrentDigit == 0 && d == 0 && t < 100) segments = 0;
    else segments = digits[d];
  }

  for (int i = 0; i < 7; i++) {
    digitalWrite(segPins[i], (segments & (1 << i)) ? LOW : HIGH);
  }
  digitalWrite(digitPins[isrCurrentDigit], HIGH);
}

void setupTimer1() {
  cli();
  TCCR1A = 0; TCCR1B = 0; TCNT1 = 0;
  OCR1A = 249; 
  TCCR1B |= (1 << WGM12);
  TCCR1B |= (1 << CS11) | (1 << CS10);
  TIMSK1 |= (1 << OCIE1A);
  sei();
}

void setup() {
  for (int i = 0; i < 7; i++) pinMode(segPins[i], OUTPUT);
  for (int i = 0; i < 3; i++) pinMode(digitPins[i], OUTPUT);
  pinMode(heaterPin, OUTPUT);
  analogWrite(heaterPin, 0);

  btn1.begin(); btn2.begin();
  btn1.onPressed(onBtn1Short); btn1.onPressedFor(2000, onBtn1Long);
  btn2.onPressed(onBtn2Short); btn2.onPressedFor(2000, onBtn2Long);

  for (int i = 0; i < 2; i++) {
    int val; EEPROM.get(EEPROM_ADDR[i], val);
    if (val >= 150 && val <= 400) savedTemps[i] = val; else savedTemps[i] = 0;
  }

  myEnc.write(0);
  resetActivity();
  wdt_enable(WDTO_2S);
  setupTimer1();
}

void loop() {
  wdt_reset();
  btn1.read();
  btn2.read();

  if (!isSystemOff && (millis() - lastActivityTime > TIMEOUT_OFF)) isSystemOff = true;

  // CONTROL ENCODER
  long newPos = myEnc.read();
  if (millis() - lastEncoderTime > 20) {
    long deltaPos = newPos - oldPosition;
    if (abs(deltaPos) >= 4) {
      wakeSystem();
      oldPosition = newPos;
      lastEncoderTime = millis();
      lastAdjustTime = millis();
      if (deltaPos > 0) Setpoint += 5; else Setpoint -= 5;
      Setpoint = constrain(Setpoint, 150, 400);
    }
  }

  // CITIRE SI CONTROL INCALZIRE
  if (millis() - lastUpdate > 250) {
    lastUpdate = millis();
    double currentRead = thermocouple.readCelsius();
    
    if (isnan(currentRead) || currentRead <= 0 || currentRead > 500) {
      errorCounter++;
      if (errorCounter >= MAX_ERROR_COUNT) { sensorError = true; pwm = 0; }
    } else {
      errorCounter = 0;
      sensorError = false;
      Input = (Input == 0) ? currentRead : (Input * 0.8) + (currentRead * 0.2);
      
      float instantTrend = (Input - lastInput) / 0.25;
      tempTrend = (tempTrend * 0.6) + (instantTrend * 0.4);
      lastInput = Input;

      if (isSystemOff) {
        pwm = 0;
      } else {
        float dif = Setpoint - Input;
        if (dif > 1.5) pwm = 255;
        else if (dif > -1) pwm = pwm_hold_base + (tempTrend < 0 ? (int)(abs(tempTrend) * 30) : 0);
        else pwm = 0;
      }
    }
    analogWrite(heaterPin, constrain(pwm, 0, 255));
  }

  // --- LOGICA DE AFISARE ---
  int valToDisplay = 0;
  if (isSystemOff) {
    valToDisplay = -1;
  } else if (sensorError) {
    valToDisplay = -111;
  } else if (millis() - lastAdjustTime < 2000) {
    valToDisplay = (int)Setpoint; // Afisam setpoint-ul in timp ce reglam
  } else {
    //  +/- 5 grade fata de Setpoint
    if (abs(Input - Setpoint) < 5.1) {
      valToDisplay = (int)Setpoint;
    } else {
      valToDisplay = (int)(Input + 0.5); // Rotunjire corecta
    }
  }

  noInterrupts();
  isrDisplayEnabled = (millis() < blinkUntil) ? ((millis() / 100) % 2) : true;
  isrDisplayValue = valToDisplay;
  interrupts();
}
Publicat de la Niciun comentariu:

vineri, 27 februarie 2026

Ceas cu termometru, display LCD, emitator WiFi

 Va salut !

Tot cu ajutorul AI am realizat un ceas, cu Wemos D1 mini, care afiseaza pe un dispay LCD si temperatura citita cu SHT40, transmisa din exteriorul locuintei, tot de un Wemos D1 mini . Dupa muuuulte teste si muuuuulte buguri rezolvate, pot spune ca  functioneaza foarte bine, nu am mai gasit nicio problema.Trecerea la ora de vara/iarna se face automat.

Ceasul propriu-zis il alimentez dintr-un alimentator de telefon mobil, de 5 volti. Emitatorul este alimentat dintr-un acumulator Li-Ion, a carui tensiune este citita periodic ; daca scade sub pragul critic, apare mesajul "ACCU" pe displayul ceasului. Consumul emitatorului este foarte mic pentru ca transmisia temperaturii se face o data la 5 minute, dupa care montajul intra in deep sleep. Alimentarea se face cu un IC specializat, HT7333. 

UPDATE 12/03/2026 (bug conectare corectat). 

UPDATE 28/03/2026 - Modificand putin codul si folosind aplicatia BLYNK pot vedea temperatura pe telefonul mobil, de oriunde. Inclusiv graficul evolutiei zilnice, saptamanala, lunara 


 

 


 

#include <ESP8266WiFi.h>
#include <ESP8266WebServer.h>
#include <TFT_eSPI.h>
#include <TimeLib.h>
#include <Timezone.h>
#include <NTPClient.h>
#include <WiFiUdp.h>

TFT_eSPI display = TFT_eSPI();
ESP8266WebServer server(80);
WiFiUDP ntpUDP;

// Actualizare NTP la 24 ore (86400000 ms) - offset 0, primim UTC
NTPClient timeClient(ntpUDP, "europe.pool.ntp.org", 0, 86400000);

const char* ssid = "your_SSID";
const char* password = "your_PSW";

// Reguli DST pentru București - ORDINE CORECTĂ: Standard (EET) apoi Daylight (EEST)
TimeChangeRule EET = {"EET", Last, Sun, Oct, 3, 120};    // Standard: UTC+2 (iarnă)
TimeChangeRule EEST = {"EEST", Last, Sun, Mar, 3, 180};   // Daylight: UTC+3 (vară)
Timezone Bucharest(EET, EEST);  // Constructor: (standard, daylight)

const char* zileAbrev[] = {"DU", "LU", "MA", "MI", "JO", "VI", "SA"};
const char* luni[] = {"IAN", "FEB", "MAR", "APR", "MAI", "IUN", "IUL", "AUG", "SEP", "OCT", "NOV", "DEC"};

float receivedTemp = 0.0;
bool lowBattery = false;
bool timeInitialized = false;

// Variabilă pentru tracking reconectare WiFi
unsigned long lastWiFiAttempt = 0;
const unsigned long WIFI_RECONNECT_INTERVAL = 10000;  // 10 secunde între încercări

void handleUpdate() {
  if (server.hasArg("temp")) {
    float v = server.arg("temp").toFloat();
    if (v >= -50 && v <= 100) receivedTemp = v;
  }
  lowBattery = (server.hasArg("bat") && server.arg("bat") == "LOW");
  server.send(200, "text/plain", "OK");
}

unsigned long prevDisplay = 0;


void displayInfo() {
  time_t utc = timeClient.getEpochTime();
  
  // Dacă nu am obținut NICIODATĂ ora corectă, afișăm "Sincronizare..."
  if (!timeInitialized) {
    display.fillScreen(TFT_BLACK);
    display.setTextColor(TFT_WHITE, TFT_BLACK);
    display.setFreeFont(&FreeSansBold12pt7b);
    display.setTextDatum(MC_DATUM);
    display.drawString("Sincronizare...", 120, 100);
    return;
  }
  
  // AVEM ORA VALIDĂ - afișăm ceasul (chiar dacă WiFi pică între timp)
  time_t local = Bucharest.toLocal(utc);
  tmElements_t tm;
  breakTime(local, tm);
  
  int dd=tm.Day, mm=tm.Month-1, wd=tm.Wday-1, h=tm.Hour, m=tm.Minute, s=tm.Second;
  
  static int lh=-1, lm=-1;
  if (h!=lh || m!=lm) {
    display.fillRect(20,80,220,80,TFT_BLACK);
    display.setTextFont(7);
    display.setTextColor(TFT_CYAN,TFT_BLACK);
    display.setTextDatum(TR_DATUM);
    display.drawString(String(h)+":"+(m<10?"0":"")+String(m), 175, 95);
    lh=h; lm=m;
  }
  
  static String ls="";
  String sec=(s<10?"0":"")+String(s);
  if (sec!=ls) {
    display.setFreeFont(&FreeSansBold12pt7b);
    display.setTextDatum(MC_DATUM);
    display.setTextColor(TFT_CYAN,TFT_BLACK);
    display.fillRect(173,100,60,30,TFT_BLACK);
    display.drawString(sec,190,105);
    ls=sec;
  }
  
  static String ld="";
  String dat=String(dd)+"-"+String(luni[mm]);
  if (dat!=ld) {
    display.setFreeFont(&FreeSansBold12pt7b);
    display.setTextDatum(TL_DATUM);
    display.setTextColor(TFT_GREEN,TFT_BLACK);
    display.fillRect(10,25,100,25,TFT_BLACK);
    display.drawString(dat,0,25);
    ld=dat;
  }
  
  static String lt="";
  String tmp=String(receivedTemp,1)+"'C";
  if (tmp!=lt || receivedTemp==0.0) {
    display.fillRect(233-90,25-2,90,25,TFT_BLACK);
    display.setFreeFont(&FreeSansBold12pt7b);
    display.setTextDatum(TR_DATUM);
    display.setTextColor(TFT_PURPLE,TFT_BLACK);
    display.drawString("'C",233,25);
    display.setTextColor(TFT_YELLOW,TFT_BLACK);
    display.drawString(String(receivedTemp,1),233-display.textWidth("'C"),25);
    lt=tmp;
  }
  
  static bool lb=false;
  if (lowBattery!=lb) {
    display.fillRect(95,17,50,20,TFT_BLACK);
    if (lowBattery) {
      display.setTextFont(2);
      display.setTextDatum(MC_DATUM);
      display.setTextColor(TFT_RED,TFT_BLACK);
      display.drawString("ACCU",120,25);
    }
    lb=lowBattery;
  }
  
  static int lw=-1;
  int cw=(wd==0)?6:wd-1;
  if (cw!=lw) {
    display.fillRect(0,185,240,30,TFT_BLACK);
    display.setFreeFont(&FreeSansBold9pt7b);
    display.setTextDatum(MC_DATUM);
    int pz[]={10,50,90,125,155,185,220};
    for (int i=0;i<7;i++) {
      int zi=(i+1)%7;
      uint16_t c=(i==cw)?(zi==0||zi==6?TFT_RED:TFT_GREEN):TFT_DARKGREY;
      display.setTextColor(c,TFT_BLACK);
      display.drawString(zileAbrev[zi],pz[i],200);
    }
    lw=cw;
  }
}

// =====================================================
// SETUP() - CORECTAT PENTRU ROUTER LENT
// =====================================================
void setup() {
  display.init();
  display.setRotation(3);
  display.fillScreen(TFT_BLACK);
  display.setTextColor(TFT_WHITE, TFT_BLACK);
  display.setFreeFont(&FreeSansBold12pt7b);
  display.setTextDatum(MC_DATUM);
  display.drawString("Starting...", 120, 100);
  
  // Curățare credențiale WiFi pentru conexiune proaspătă
  WiFi.persistent(false);
  delay(1000);
  WiFi.disconnect(true);
  delay(1000);
  WiFi.mode(WIFI_OFF);
  delay(1000);
  
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  
  // 1. Conectare la Router (WiFi) - EXTINS LA 60 SECUNDE PENTRU ROUTER LENT
  int attempts = 0;
  const int maxAttempts = 15;  // 15 x 4s = 60 secunde (suficient pentru router lent)
  while (WiFi.status() != WL_CONNECTED && attempts < maxAttempts) {
    attempts++;
    display.fillScreen(TFT_BLACK);
    display.drawString("Conectare WiFi", 120, 100);
//    display.drawString(String(attempts) + "/" + String(maxAttempts), 120, 140);
    display.drawString("Astept router...", 120, 170);
    delay(4000);
    yield();  //  ESP8266 WDT friendly
  }
  
  if (WiFi.status() != WL_CONNECTED) {
    display.fillScreen(TFT_BLACK);
    display.setTextColor(TFT_RED, TFT_BLACK);
    display.drawString("Eroare WiFi", 120, 100);
    display.drawString("Reboot in 10s...", 120, 140);
    // Așteptăm 10 secunde înainte de reboot (poate routerul a pornit între timp)
    for (int i = 10; i > 0; i--) {
      display.drawString(String(i) + "s", 120, 170);
      delay(4000);
      yield();
    }
    ESP.restart();
  }
  
  // 2. WiFi conectat - Începem verificarea INTERNET (NTP)
  display.fillScreen(TFT_BLACK);
  display.drawString("Verificare NET", 120, 100);
  display.drawString("  Astept NTP", 120, 140);
  delay(4000);
  timeClient.begin();
  
  // 3. VERIFICARE INTERNET REAL prin NTP (maxim 20 secunde)
  int ntpAttempts = 0;
  while (!timeInitialized && ntpAttempts < 20) {
    if (timeClient.update()) {
      time_t epoch = timeClient.getEpochTime();
      // Validare epoch : după 1 Ian 2020 și înainte de overflow 2038
      if (epoch > 1577836800 && epoch < 2147483647) {
        setTime(epoch);  //  Sincronizează TimeLib cu NTP!
        timeInitialized = true;
        break;
      }
    }
    ntpAttempts++;
    display.fillScreen(TFT_BLACK);
    display.drawString("Sincronizare NTP", 120, 100);
    display.drawString(String(ntpAttempts) + "/20", 120, 140);
    delay(1000);
    yield();  // ESP8266 WDT friendly
  }
  
  if (!timeInitialized) {
    // NTP a eșuat - nu avem internet real
    display.fillScreen(TFT_BLACK);
    display.setTextColor(TFT_RED, TFT_BLACK);
    display.drawString("Eroare NET", 120, 100);
    display.drawString("NTP Esuat", 120, 130);
    display.drawString("Reboot in 5s", 120, 160);
    for (int i = 5; i > 0; i--) {
      display.drawString(String(i) + "s", 120, 190);
      delay(1000);
      yield();
    }
    ESP.restart();
  }
  
  // 4. SUCCES - Acum afișăm "WiFi Conectat" și IP (DOAR după NTP OK)
  display.fillScreen(TFT_BLACK);
  display.setTextColor(TFT_GREEN, TFT_BLACK);
  display.drawString("WiFi Conectat", 120, 80);
  display.setTextColor(TFT_WHITE, TFT_BLACK);
  display.drawString(WiFi.SSID(), 120, 110); 
  display.drawString(WiFi.localIP().toString(), 120, 140);
  display.drawString("Start ceas...", 120, 180);
  
  server.on("/update", handleUpdate);
  server.begin();
  delay(4000);
  
  // 5. Curățare ecran înainte de loop
  display.fillScreen(TFT_BLACK);
}

// =====================================================
// LOOP() - ADĂUGATĂ RECONECTARE WIFI AUTOMATĂ
// =====================================================
void loop() {
  server.handleClient();
  
  // Reconectare automată dacă WiFi se pierde
  if (WiFi.status() != WL_CONNECTED) {
    if (millis() - lastWiFiAttempt > WIFI_RECONNECT_INTERVAL) {
      display.setTextColor(TFT_ORANGE, TFT_BLACK);
      display.setTextDatum(MC_DATUM);
      display.setFreeFont(&FreeSansBold9pt7b);
      display.drawString("Reconectare...", 120, 220);
      
      WiFi.reconnect();  // Încearcă reconectarea
      lastWiFiAttempt = millis();
    }
    yield();  // ESP8266 WDT friendly
    return;   // Skip rest until reconnected
  }
  
  // WiFi este conectat - actualizăm NTP (librăria gestionează intervalul de 24h)
  if (timeClient.update()) {
    time_t epoch = timeClient.getEpochTime();
    if (epoch > 1577836800 && epoch < 2147483647) {
      setTime(epoch);  // Menține TimeLib sincronizat
      timeInitialized = true;
    }
  }
  
  // Afișare ceas la fiecare secundă
  if (millis() - prevDisplay >= 1000) {
    prevDisplay = millis();
    displayInfo();
  }
  
  yield();  // ESP8266 WDT friendly - obligatoriu în loop
}
<10 175="" 95="" lh="h;" lm="m;" ls="" m="" sec="(utc" secunde="" static="" string="" tring=""><10 dat="(utc" display.drawstring="" display.fillrect="" display.setfreefont="" display.settextcolor="" display.settextdatum="" if="" ld="" ls="sec;" reesansbold12pt7b="" s="" sec="" static="" string="" tring=""><7 -="" 100="" 120="" 140="" 1="" 1ms="" 2="" a="" actualizare="" afi="" am="" attempts="" blocheaz="" bucla="" c="" conectare="" const="" critic:="" cu="" curent="" da="" dac="" de="" delay="" display.drawstring="" display.fillscreen="" display.init="" display.setfreefont="" display.setrotation="" display.settextcolor="" display.settextdatum="" doar="" eaz="" eboot...="" ecran="" else="" epuizat="" erial.print="" eroare="" esp.restart="" ex:="" excep="" f="" fiecare="" handleupdate="" i="" if="" ifi.localip="" ifi.status="" ii="" int="" intervale="" ional:="" it="" itera="" la="" loop="" lw="cw;" m="" mai="" maxattempts="" millis="" mult="" ncerc="" ncercarea:="" ncercarea="" niciodat="" non-blocking="" ntp="" ntre="" nu="" onectare="" onectat="" op="" password="" pe="" pentru="" prevntp="" pz="" r="" reesansbold12pt7b="" reu="" ri="" ro="" roare="" routerului="" sau="" secund="" serial.begin="" serial.println="" server.begin="" server.handleclient="" server.on="" setup="" ssid="" string="" teapt="" tentativele="" tft_black="" timeclient.begin="" timeclient.update="" timp="" tostring="" tring="" u="" uint16_t="" update="" verific="" void="" while="" wifi...="" wifi.begin="" wifi.mode="" wifi="" wl_connected="" zi="" zileabrev="">
Publicat de la Niciun comentariu:

joi, 26 februarie 2026

Statie meteo cu Wemos D1 mini si ST7735

Va salut ! Fiindca o lunga perioada de timp am fost in concediu medical, dupa o afectiune oncologica ce a necesitat operatie, in timpul liber disponibil am lucrat la o serie de proiecte, care sa-mi tina mintea distrasa de la alte ganduri ... Cu ajutorul AI (Vercel, Perplexity, Gemini, Qwen, Le Chat) am conceput si finalizat, dupa multe, multe incercari si aceasta statie meteo color. Functioneaza foarte bine, prietenul meu, Dragos, o are "activa" si e multumit de ea. Nota : am experimentat cu datele meteo de pe toate siteurile care pun la dispozitie apiKey. Nu sunt doua la fel !! Exista mari variatii, in special in privinta temperaturii, dar, la unele siteuri, si la starea vremii propriu-zisa (afara era soare, senin si prognoza era innorat, sanse de ploaie :( ). Acesta este si motivul pentru care eu nu folosesc aceasta statie, prefer ceasul cu termometru (ce poate fi vazut tot aici, pe blog). Cine doreste poate face statia, ideea este sa va obtineti propriul apiKey (google_it) si sa va setati locatia. Succes ! 
//Statie meteo cu ST7735


#include <SPI.h>
#include <TimeLib.h>
#include <ArduinoJson.h>
#include <Adafruit_GFX.h>
#include <Adafruit_ST7735.h>
#include <ESP8266HTTPClient.h>
#include <WiFiClient.h>
#include <Arduino.h>
#include <ESP8266WiFi.h>
#include <time.h>
#include "OpenWeatherMapCurrent.h"
#include <WiFiUdp.h>
#include <Fonts/FreeMonoBold12pt7b.h>
#include <Fonts/FreeMono12pt7b.h>
#include <Fonts/FreeSans9pt7b.h>
#include <Fonts/FreeSans12pt7b.h>
#include <Fonts/FreeSansBold18pt7b.h>
#include <Fonts/FreeSansBold9pt7b.h>
Publicat de la Niciun comentariu:

miercuri, 25 februarie 2026

Ceas Matrix cu termometru

 Va salut !

Si inca un montaj cu excelentul Wemos D1 mini : ceas cu matrice de leduri, cu senzor de temperatura DS18B20.  Are efect de scroll a afisarii. Testat, functioneaza perfect. L-am montat in bucatarie, iar senzorul de temperatura l-am scos in balcon. Succes !

 


 




 

 

 

// Ceas matrice LED cu ora automata vara/iarna + DS18B20 
// Conexiuni : DS18B20 la D2 ; matrice DIN - D8 ; CS - D7 ; CLK - D6

#include <ESP8266WiFi.h>
#include <time.h>
#include <MD_MAX72xx.h>
#include <SPI.h>
#include <OneWire.h>
#include <DallasTemperature.h>
Publicat de la Niciun comentariu:
Abonați-vă la: Postări (Atom)