Gondolom zárt szelvényt sem készítesz pl. otthon.

Otthon hazilagosan is pofon egyszerű osszeforrasztani , saját anyagból.
Ha érdekel leírom bár már többször is leírtam itt .

Sziasztok!
Egy hőelemet szeretnék páka hőmérsékletmérésre használni. Eddigi méréseim szerint "K" típusú a szonda. A táblázat amit letöltöttem a nulla fokos befogóra adja a hőmérsékletekhez az értékeket. Ahhoz, hogy valós értéket kapjak a mérésnél jó megoldás-e ha a táblázatban megadott pl. 22 fokra megadott értéket a mért értékhez hozzáadom? Későbbiekben egy PIC-es áramkör kerül rá megfelelő erősítővel, és az kompenzálja egy hőmérővel a kijelzett értéket. Nem labor alkalmazásnak szeretném használni, csak amatőr felhasználású a készülék. Jó-e az elgondolásom vagy valami más megoldást javasoltok?
Köszönöm a segítséget!
Üdv: Gábor

Hello! Jól gondolod, de kapható MAX6675 amiben benne van a hidegpont kompenzáció is.

Szia!
Köszönöm. A MAX jó lenne ha tudnék programozni.
Üdv: Gábor

Ha nem tudsz programozni hogyan lesz pices áramkör rajta ?

Szuicid hajlamaid vannak.

Szia!
Mondjuk ebben a formában nem teljesen igaz, PARSIC segítségével konyhanyelven elvagyunk egymással. Kb. ezen a szinten megy a PIC programozás.
Üdv: Gábor

Ha esetleg más is számításba jöhet nem csak PIC, akkor vannak komplett projektek ARDUINO-ra.
wokwi
Arduino
video1
video2

Köszönöm!
Úgy tűnik tovább kell képezzem magam, tetszenek a megoldások.
Üdv: Gábor

Szia. A hestore ben vett MAX6675 modulokat használom, de a hőfok szabályzóban zavar az érték ugrálás. Az összeállításom :Arduino nano, 2*16 LCD, piros- zöld led és Relé. Mikor a beállított hőfok környékén a lassú hőfok változás miatt ki-be kapcsolgat a relé az zavar.(meg a működtetett eszközt)
Te találtál megoldást érték átlagolással, erre lennék kíváncsi. Hol találok rá megoldást, mitkell a programban módosítani.
Köszi : pittyu

Számolj standard eloszlást a több mérés adatából és dobd el belőle a standard eloszlási sávon kívülieket. Minden analógban végződő szenzornál ha fontos a biztos mérés, legalább ezt kell használni. Sima 10K-s NTC-nél is van ilyen környezet okozta zaj probléma, nem csak a K-ra jellemző.
Sok helyen használom az AVT algoritmust, mert sokkal egyszerűbb mint FIR vagy FFT-t csinálni. Az AVT egyszerű mint a faék. De ha nem is standard eloszlást számolsz, simán eldobhatsz minden olyan értéket ami az eddigi átlag 2x-ese mondjuk, de akkor figyelni kell hogy amíg nincs meg a kellő minta szám a tömbödbe addig nem szabad, mert sosem fog feltöltődni.

AVT algoritmus

Gyakorlati, egyszerű megoldások a kétféle problémára:
- ugrálás: átlagolás 1 = 10 elemű tömbbe sorban írom a mért értékeket, ha az eltérés nagyobb, mint az átlag X%-ánál, 0-át írok, majd átlagolom a nem 0 értékeket;
átlagolás 2 = 10 elemű tömbbe sorban írom a mért értékeket, ha az eltérés nagyobb az előző X%-ánál, eldobom az értéket, majd átlagolom a 10 értéket;
- ki-be kapcsolgató relé: hiszterézis alkalmazása: relét akkor kapcsolsz, ha az új átlag X%-nál kisebb/nagyobb az előző átlagnál.
Minden mérésnél megteszem ezen számításokat, nem várok 10 új mérésre - van ahol elég 10 mérésenként számolni, ez függ a mérés sebességénél.
klaus18 által javasolt Antonyan Vardan Transform (AVT) módszer is ilyesmi.

Köszi , de ez nekem magas. Nem tudok programozni- csak lemásolni és feltölteni mások által megírt programokat.

Egyfajta megoldás chatgpt által:

* 10 darab analóg mérést átlagol (pl. hőmérséklet szenzor)
* Hiszterézist alkalmaz egy kapcsolási küszöb körül
* Relét (vagy LED-et) vezérel

A példa feltételezi, hogy:
* Az analóg hőmérséklet szenzor az **A0** lábon van (pl. LM35)
* A kimenet egy relé vagy LED a **8-as digitális lábon**

## Működési elv:
* 10 mintát veszünk gyors egymásutánban
* Kiszámoljuk az átlagot
* Ha az átlag **küszöb fölé megy + hiszterézis/2**, bekapcsol
* Ha az átlag **küszöb alá megy - hiszterézis/2**, kikapcsol
* A köztes tartományban nem változtat állapotot, ami megakadályozza a ki-be kapcsolgatást határértéken.

## Arduino példa kód:

const int sensorPin = A0;
const int outputPin = 8;

const int sampleCount = 10;

float threshold = 25.0; // Kapcsolási hőmérséklet (°C)
float hysteresis = 1.0; // Hiszterézis sáv (°C)

bool outputState = false;

float readAverageTemperature() {
long sum = 0;

for (int i = 0; i < sampleCount; i++) {
sum += analogRead(sensorPin);
delay(10); // kis stabilizációs késleltetés
}

float averageADC = sum / (float)sampleCount;

// LM35 esetén: 10mV / °C
// Arduino 5V referencia → 1023 = 5V
float voltage = averageADC * (5.0 / 1023.0);
float temperature = voltage * 100.0;

return temperature;
}

void setup() {
pinMode(outputPin, OUTPUT);
Serial.begin(9600);
}

void loop() {

float temp = readAverageTemperature();

Serial.print("Atlagolt homerseklet: ");
Serial.println(temp);

// Hiszterézis logika
if (!outputState && temp > (threshold + hysteresis / 2.0)) {
outputState = true;
digitalWrite(outputPin, HIGH);
}
else if (outputState && temp < (threshold - hysteresis / 2.0)) {
outputState = false;
digitalWrite(outputPin, LOW);
}

delay(1000);
}

## Példa beállítás

* threshold = 25°C
* hysteresis = 1°C

Kapcsolás:
* Bekapcsol: 25.5°C felett
* Kikapcsol: 24.5°C alatt

## Miért jobb ez így?

* ✔ Zajcsökkentés (10 minta átlagolás)
* ✔ Nem vibrál a relé
* ✔ Egyszerű, gyors, kis RAM igény
* ✔ AVR-en stabilan fut

Más megoldások:

* ✔ ESP32-re optimalizálva
* ✔ AVT jellegű statisztikai szűréssel
* ✔ Mozgóátlagos (rolling average) változatra
* ✔ Fixpontos (float nélküli) verzióra AVR-hez

Csak szólj

Zajos értékek szűrése AVT módszerrel:

const int sensorPin = A0;
const int outputPin = 8;

const int sampleCount = 10;

float threshold = 25.0; // Kapcsolási hőmérséklet
float hysteresis = 1.0; // Hiszterézis sáv (°C)

bool outputState = false;

float readTemperatureAVT() {

float samples[sampleCount];
float sum = 0;

// 1. Mintavétel
for (int i = 0; i < sampleCount; i++) {
int raw = analogRead(sensorPin);
float voltage = raw * (5.0 / 1023.0);
float temp = voltage * 100.0; // LM35

samples[i] = temp;
sum += temp;
delay(10);
}

// 2. Első átlag
float mean = sum / sampleCount;

// 3. Szórás számítás
float variance = 0;
for (int i = 0; i < sampleCount; i++) {
variance += pow(samples[i] - mean, 2);
}
variance /= sampleCount;
float stddev = sqrt(variance);

// 4. Outlier eldobás (±1 szórás)
float filteredSum = 0;
int validCount = 0;

for (int i = 0; i < sampleCount; i++) {
if (abs(samples[i] - mean) <= stddev) {
filteredSum += samples[i];
validCount++;
}
}

// Ha minden kiesne (ritka eset), visszatérünk az első átlaggal
if (validCount == 0) return mean;

// 5. Új átlag (AVT eredmény)
return filteredSum / validCount;
}

void setup() {
pinMode(outputPin, OUTPUT);
Serial.begin(9600);
}

void loop() {

float temp = readTemperatureAVT();

Serial.print("AVT homerseklet: ");
Serial.println(temp);

// Hiszterézis logika
if (!outputState && temp > (threshold + hysteresis / 2.0)) {
outputState = true;
digitalWrite(outputPin, HIGH);
}
else if (outputState && temp < (threshold - hysteresis / 2.0)) {
outputState = false;
digitalWrite(outputPin, LOW);
}

delay(1000);
}

Gyorsabb, integer (egész számokkal operáló, ezért kb. 4–6× gyorsabb) alapú, robusztus AVT módszer (hadd ne javasoljak további programmegoldásokat ):

const int sensorPin = A0;
const int outputPin = 8;

const byte sampleCount = 10;

int threshold = 250; // 25.0 °C (tized fokban)
int hysteresis = 10; // 1.0 °C (tized fokban)

bool outputState = false;

int readTemperatureAVT() {

int samples[sampleCount];
long sum = 0;

// 1. Mintavétel (ADC → tized °C)
for (byte i = 0; i < sampleCount; i++) {
int raw = analogRead(sensorPin);

// LM35 integer átszámítás:
// raw * 5000mV / 1023 → mV
// LM35: 10mV / °C
// → °C = mV / 10
// → tized °C = mV
long milliVolt = (long)raw * 5000L / 1023L;
int temp10 = milliVolt; // 1mV = 0.1°C

samples[i] = temp10;
sum += temp10;

delay(5);
}

// 2. Első átlag
int mean = sum / sampleCount;

// 3. Átlagos abszolút eltérés (MAD jelleg)
long devSum = 0;
for (byte i = 0; i < sampleCount; i++) {
devSum += abs(samples[i] - mean);
}

int avgDev = devSum / sampleCount;

// Robusztus szűrési faktor (állítható)
// 1.5x szórás jellegű küszöb (integerben)
int limit = avgDev * 3 / 2;

// 4. Outlier szűrés
long filteredSum = 0;
byte validCount = 0;

for (byte i = 0; i < sampleCount; i++) {
if (abs(samples[i] - mean) <= limit) {
filteredSum += samples[i];
validCount++;
}
}

if (validCount == 0)
return mean;

return filteredSum / validCount;
}

void setup() {
pinMode(outputPin, OUTPUT);
Serial.begin(9600);
}

void loop() {

int temp = readTemperatureAVT();

Serial.print("Robusztus AVT homerseklet (0.1C): ");
Serial.println(temp);

// Hiszterézis logika
if (!outputState && temp > (threshold + hysteresis / 2)) {
outputState = true;
digitalWrite(outputPin, HIGH);
}
else if (outputState && temp < (threshold - hysteresis / 2)) {
outputState = false;
digitalWrite(outputPin, LOW);
}

delay(1000);
}

Ha még stabilabbat akarsz:

limit = avgDev * 2; → lazább szűrés;
limit = avgDev; → agresszívebb szűrés;
kombinálható medián előszűréssel;
sliding window megoldással is átalakítható.

Vedd tekintetbe, a MAX6675-nek 12 bites (0,25 Celsius fok) felbontásnál ~220 msec a konverziós ideje, tehát másodpercenként kb 4-szer mérhetsz.
Az újabb, gyorsabb, 14 bites verzió = MAX31855.
Nomeg minek méred a hőmérsékletét, mire használod a mért értéket?
Kemencénél lassú mozgókorrekciós zajszűrés célravezető, gyorsabb vezérléshez PID (proporcionális + integráló + deriváló) szükséges, adaptív-zajszint alapú hiszterézis stb...

Nagyon hálás vagyok neked , valóban részletes leírás hogy mit kell csinálnom.
Azt hiszem lesz min gondolkodnom pár napig.Mit hova kell illeszteni a programban. Amúgy "hackster.IO program."
Nincsenek nagy igények, a kijelzőt sem igazán nézi senki-csak a kazán szivattyú ki-be kapcsolását kell elintézni.Azt is kézzel mechanikusan végezzük. DEE !! ha véletlenül tűzrakásnál nincs bekapcsolva, vagy az utolsó tűzrakás után még parázsnál nincs kikapcsolva- akkor avatkozzon be.
Ha kialszik a tűz ,de a szivattyú még jár(mondjuk egész éjszaka ) akkor a pufferből jelentős hő veszlik el kéményen keresztül.Kissé értelmetlennek tűnik amit írok .Mégegyszer köszönöm a hozzászólásodat : pittyu
UI: A kémény kilépő hőfokát mérem.

Itt biztos segítünk a programban, ha ez a rész okoz gondot neked, így tudsz koncentrálni a projekted többi részére, amik szintén nagyon fontosak!
Igaz, ritkán fogjátok nézni a kijelzőt (pl 2x20 karakteres LCD vagy minimum 1"-os OLED), de javaslom, hiszen információt nyújt, könnyű a beállításokat megtenni-megváltoztatni, nem drága (1-2ezer forint), minimális a fogyasztása és nem egy szürke (fekete) dobozt kell nézned, amiben ki tudja mi történik-történt...
Sőt, ESP modulos megoldással mobiltelefonon is nézheted mi történik, mik a beállítások, stb.

Szia. Hálás vagyok azért mert foglalkozol a gondommal . Olyan sok lehetőséget kínáltál fel, hogy teljesen bele zavarodtam. Kiemelnéd azt a részt ami rám legjobban illik ??
Tehát az összeállításom : Ardu Nano,Max6675, 2*16 LCD, relé. Ez így már megvan- működik.
Max6675 : A0--S0: ,A1--CS.: A2--SCK.
Kimenet : D13--Relé--D8: ,LED-D9--LED
LCD: D2--D7

Szevasz!
Szemtelen voltam és behúztam a códodat az AI-ba.
Ami feltünt benne, hogy lehetséges hibát is feltárt.
Ami nem biztos hogy az, de esetleg lehet le kellene ellenőrizned.
Üdv. M.

Hirtelen 2 hiba + 1 hiányosság:
pinMode-okat a program elejére tedd;
MAX6675 kiolvasása nem 16 bites;
nincs benne zajszűrés.

Példa (LCD kezelés nélkül -> azt megoldottad és delay()-t használ, amit célszerű elkerülni, de itt nem kritikus):
const int SO = 4;
const int CS = 5;
const int SCK = 6;

const int outputPin = 8;

const byte sampleCount = 10;

int threshold = 100 * 4; // 100°C (0.25°C egységben)
int hysteresis = 4 * 2; // 2°C hiszterézis (0.25°C egységben)

bool outputState = false;

uint16_t readMAX6675raw() {
digitalWrite(CS, LOW);
delayMicroseconds(10);

uint16_t value = 0;

for (byte i = 0; i < 16; i++) {
digitalWrite(SCK, LOW);
delayMicroseconds(1);

value <<= 1;
if (digitalRead(SO))
value |= 1;

digitalWrite(SCK, HIGH);
delayMicroseconds(1);
}

digitalWrite(CS, HIGH);

// Bit 2 = thermocouple disconnected
if (value & 0x4) return 0xFFFF;

value >>= 3; // 12 bites adat
return value; // 0.25°C egység
}

int readTemperatureAVT() {

int samples[sampleCount];
long sum = 0;

for (byte i = 0; i < sampleCount; i++) {

uint16_t raw = readMAX6675raw();
if (raw == 0xFFFF) return 0; // hiba eset

samples[i] = raw;
sum += raw;

delay(220); // MAX6675 konverziós idő!
}

int mean = sum / sampleCount;

long devSum = 0;
for (byte i = 0; i < sampleCount; i++) {
devSum += abs(samples[i] - mean);
}

int avgDev = devSum / sampleCount;

int limit = avgDev * 3 / 2;

long filteredSum = 0;
byte validCount = 0;

for (byte i = 0; i < sampleCount; i++) {
if (abs(samples[i] - mean) <= limit) {
filteredSum += samples[i];
validCount++;
}
}

if (validCount == 0)
return mean;

return filteredSum / validCount;
}

void setup() {
pinMode(SO, INPUT);
pinMode(CS, OUTPUT);
pinMode(SCK, OUTPUT);
pinMode(outputPin, OUTPUT);

digitalWrite(CS, HIGH);
Serial.begin(9600);
}

void loop() {

int temp = readTemperatureAVT();

Serial.print("Homerseklet: ");
Serial.print(temp / 4.0);
Serial.println(" C");

if (!outputState && temp > (threshold + hysteresis / 2)) {
outputState = true;
digitalWrite(outputPin, HIGH);
}
else if (outputState && temp < (threshold - hysteresis / 2)) {
outputState = false;
digitalWrite(outputPin, LOW);
}
}

Szia.Ha kijavítom a leírt hibákat -PIN mode és felbontás, nem lehet csak pár sorral beilleszteni szűrést és differenciát ?
Mert már működik és csináltam LCD-t .
Most mennem kell unokázni , eltünök pár napra.