Componenti · 11 min di lettura

MAX6675 Arduino: termocoppia K per misurare fino a 1000 °C

MAX6675 con Arduino: collegamento SPI, libreria e termocoppia tipo K da 0 a 1023 °C, con LCD, stufa, forno, saldatore e codice per ESP32 e Pico.

Il MAX6675 è un chip convertitore che trasforma il segnale in millivolt di una termocoppia di tipo K direttamente in un valore digitale di temperatura; con la coppia MAX6675 Arduino puoi misurare temperature da 0 a 1023,75 °C con una risoluzione di 0,25 °C. Dove sensori come DHT11 o DS18B20 reggono al massimo 50–125 °C, per esempio sul tubo di una stufa, nel forno di casa, nel forno per la pizza, sulla punta di un saldatore o su un tubo di scarico, ci pensa la termocoppia. Il modulo si collega via SPI con soli tre fili di segnale (SCK, CS, SO) e con la libreria si legge in una riga.

In questo articolo vedrai come funziona la termocoppia, cosa contengono i 16 bit inviati dal MAX6675 e come collegarlo ad Arduino Uno, ESP32 e Raspberry Pi Pico. Poi scriveremo un allarme di temperatura con LCD per il tubo della stufa e un semplice termostato a relè per forno e stazione saldante, e infine risolveremo i problemi più comuni, come "perché leggo NAN?" o "perché il valore scende mentre scaldo?".

Che cos'è il MAX6675 e come funziona una termocoppia?

Una termocoppia è formata da due fili di metalli diversi saldati a un'estremità. Quando tra il punto di saldatura (giunzione calda) e le altre estremità dei fili (giunzione fredda) c'è una differenza di temperatura, nei fili nasce una tensione minuscola: è l'effetto Seebeck. In una termocoppia di tipo K il filo positivo è cromel (nichel-cromo), il negativo è alumel (nichel-alluminio) e la tensione prodotta è circa 41 µV/°C. Una differenza di 100 °C dà quindi appena 4 mV circa, impossibile da misurare direttamente con l'ADC a 10 bit di Arduino Uno (un passo vale circa 4,9 mV). Inoltre la termocoppia non misura la temperatura assoluta ma la differenza tra i due capi: serve quindi conoscere anche la temperatura della giunzione fredda, cioè dell'ambiente dove si trova il modulo. Il MAX6675 fa proprio questo: amplifica il segnale in microvolt, lo converte in digitale con un ADC a 12 bit e, con il sensore di temperatura interno, esegue automaticamente la compensazione della giunzione fredda. A te resta solo da leggere 16 bit via SPI. Secondo il datasheet l'errore del chip è di pochi LSB, circa ±1,5–2 °C, a cui si aggiunge la tolleranza della termocoppia stessa (±2,5 °C o 0,75% del valore per una K standard).

CaratteristicaValore
Chip convertitoreMAX6675
Termocoppia supportataSolo tipo K
Campo di misura0 °C – 1023,75 °C
Risoluzione12 bit, 0,25 °C
Compensazione giunzione freddaInterna, temperatura ambiente −20 … +85 °C
Tensione di alimentazione3,0 – 5,5 V
Consumo di correnteTipico 0,7 mA, massimo 1,5 mA
Tempo di conversioneTipico 0,17 s, massimo 0,22 s
InterfacciaCompatibile SPI, sola lettura (SCK, CS, SO), max 4,3 MHz
Rilevamento erroriBit di termocoppia aperta (D2)

MAX6675 o un altro sensore di temperatura?

SensoreCampo di misuraRisoluzioneInterfacciaUso più adatto
MAX6675 + termocoppia K0 … 1023,75 °C0,25 °CSPIStufa, forno, saldatura, scarico
MAX31855K + termocoppia K−200 … +1350 °C0,25 °CSPITemperature negative e molto alte
DS18B20−55 … +125 °C0,0625 °C1-WireAcqua, acquario, esterni
Termistore NTC (10 kΩ)Circa −40 … +125 °CDipende dall'ADCAnalogicaMisure economiche di ambiente e dispositivi
DHT110 … 50 °C1 °CDigitale a un filoTemperatura e umidità ambiente

La sonda fornita con il modulo è di solito una termocoppia K con vite M6 in punta e cavo con treccia in fibra di vetro. L'isolamento del cavo resiste in genere fino a circa 400 °C: anche se il MAX6675 può misurare 1000 °C, la sonda non è adatta. Per misure tra 600 e 1000 °C (forno per ceramica, crogiolo di fusione, forgia) devi usare una sonda con guaina ceramica o metallica e isolamento minerale. Nelle misure di superficie (tubo della stufa, piastra del ferro da stiro) premi bene la punta sulla superficie con una fascetta metallica: una sonda sospesa in aria legge decine di gradi in meno. Poiché il MAX6675 non può mostrare temperature sotto 0 °C, per un congelatore o per l'esterno in inverno scegli il DS18B20 o il MAX31855. Per vedere tutte le opzioni a confronto leggi il confronto tra sensori di temperatura.

Collegamento del MAX6675: i pin SPI

Il modulo MAX6675 ha da un lato cinque pin (GND, VCC, SCK, CS, SO) e dall'altro una morsettiera a vite a due poli (+ e −) per la termocoppia. Poiché il chip invia soltanto dati, non esiste la linea MOSI; per questo, al posto dell'SPI hardware, si può usare anche un SPI software su tre pin digitali qualsiasi. Nella tabella seguente usiamo i pin SPI hardware di ogni scheda, così con lo stesso cablaggio puoi usare sia la libreria sia il codice SPI diretto. La logica di base dell'SPI è spiegata in dettaglio in Che cos'è l'SPI?.

Pin MAX6675Arduino UnoESP32Raspberry Pi Pico
GNDGNDGNDGND
VCC5V3V33V3(OUT)
SCKD13GPIO 18GP18
CSD10GPIO 5GP17
SOD12GPIO 19GP16
Termocoppia + / −Morsetti + e − del moduloMorsetti + e − del moduloMorsetti + e − del modulo
La polarità della termocoppia è importante: se scaldando il valore letto scende invece di salire, i fili + e − sono invertiti, scambiali. I colori standard cambiano da paese a paese (standard USA: giallo positivo, rosso negativo; standard IEC: verde positivo, bianco negativo), quindi fidati del test e non del colore. Se devi allungare il cavo della termocoppia, non usare un normale cavo di rame: ogni giunzione rame-lega si comporta come una nuova termocoppia e falsa la misura. Per prolungarlo usa un cavo di estensione per termocoppie K, oppure tieni il modulo vicino alla sonda e allunga i fili di segnale (SCK, CS, SO).

Passo dopo passo: la prima misura con Arduino

  1. Avvita saldamente i due fili della termocoppia sui morsetti + e − del modulo.
  2. Collega i pin GND e VCC del modulo ai pin GND e 5V di Arduino Uno.
  3. Collega SCK a D13, CS a D10 e SO a D12.
  4. Nell'IDE di Arduino apri il Gestore delle librerie, cerca MAX6675 e installa la MAX6675 library di Adafruit. Se non hai mai installato una libreria, ti aiuta l'articolo come aggiungere una libreria Arduino.
  5. Carica il codice qui sotto, apri il Monitor seriale a 9600 baud e stringi la sonda tra le dita per vedere il valore salire.
C++ (Arduino IDE)
1#include <max6675.h>
2
3const int thermoSCK = 13;  // SCK (saat) / SCK (clock)
4const int thermoCS  = 10;  // CS (yonga seçimi) / CS (chip select)
5const int thermoSO  = 12;  // SO (veri çıkışı) / SO (data out)
6
7MAX6675 thermocouple(thermoSCK, thermoCS, thermoSO);  // sıra: SCK, CS, SO / order: SCK, CS, SO
8
9void setup() {
10  Serial.begin(9600);
11  Serial.println(F("MAX6675 test"));
12  delay(500);  // ilk dönüşümü bekle / wait for the first conversion
13}
14
15void loop() {
16  float c = thermocouple.readCelsius();
17  if (isnan(c)) {
18    Serial.println(F("Termokupl bagli degil! / Thermocouple not connected!"));
19  } else {
20    Serial.print(F("Sicaklik / Temp: "));
21    Serial.print(c, 2);
22    Serial.println(F(" C"));
23  }
24  delay(500);  // en az 250 ms bekle / wait at least 250 ms
25}

Il costruttore della libreria richiede i pin nell'ordine SCK, CS, SO; sbagliare questo ordine è l'errore software più frequente. readCelsius() restituisce la temperatura in gradi Celsius, readFahrenheit() in Fahrenheit. Se la termocoppia non è collegata o il filo è rotto, il chip lo rileva e la libreria restituisce NAN (not a number). Intercettare questo caso con isnan() e stampare un messaggio chiaro diventa vitale quando più avanti piloterai un riscaldatore con un relè. A temperatura ambiente, tenendo la sonda tra le dita, dovresti vedere il valore salire fino a circa 30 °C in pochi secondi.

Il MAX6675 completa una conversione in al massimo 0,22 secondi e portare il pin CS a LOW interrompe la conversione in corso. Se leggi più spesso di ogni 250 ms, il chip non riesce a fare una nuova misura e vedi sempre lo stesso valore. Lascia almeno 250 ms tra due letture; per un display più stabile fai la media delle ultime 4–8 misure.

Come si leggono i 16 bit di dati del MAX6675?

Se vuoi leggere senza libreria, il procedimento è semplice: porta CS a LOW, leggi due byte con 16 impulsi di clock, riporta CS a HIGH. I 16 bit ricevuti sono organizzati come nella tabella qui sotto. Per ottenere la temperatura, sposta il valore grezzo di 3 bit a destra (scartando D2, D1 e D0) e moltiplica il risultato per 0,25. Per esempio, se il valore grezzo è 3200 (0x0C80 in esadecimale), 3200 >> 3 = 400 e 400 × 0,25 = 100,00 °C. Poiché il numero massimo scrivibile con 12 bit è 4095, il limite superiore è 4095 × 0,25 = 1023,75 °C. Se non hai familiarità con shift e mascheramento dei bit, ti aiuta l'articolo sistemi numerici e operazioni sui bit.

BitSignificato
D15Bit di segno fittizio, sempre 0
D14 – D3Valore di temperatura a 12 bit (prima il bit più significativo), 1 passo = 0,25 °C
D2Termocoppia aperta: se è 1 la sonda non è collegata o il filo è rotto
D1ID del dispositivo, sempre 0
D0Tri-state, valore indefinito

Mostrare la temperatura del tubo della stufa su LCD

Nelle case con la stufa, un tubo che si surriscalda significa rischio di incendio e spreco di combustibile. Fissa la sonda vicino all'uscita della stufa, sulla superficie del tubo, con una fascetta metallica. Nelle stufe a legna la superficie del tubo con una buona combustione resta di solito tra 120 e 250 °C; oltre 300 °C indica che la stufa è troppo carica o che il tiraggio è eccessivo. Il codice seguente mostra su un LCD I2C 16x2 la temperatura attuale e il valore massimo misurato dall'accensione, e al superamento di 250 °C fa suonare un buzzer attivo collegato a D8. Per il collegamento dell'LCD (SDA ad A4, SCL ad A5) e per trovare l'indirizzo consulta l'articolo display LCD I2C.

Display LCD 16x2 con modulo I2C
LCD 16x2 con modulo I2C: ideale per mostrare la temperatura misurata con il MAX6675 usando solo due fili dati (SDA, SCL).
C++ (Arduino IDE)
1#include <Wire.h>
2#include <LiquidCrystal_I2C.h>
3#include <max6675.h>
4
5MAX6675 thermocouple(13, 10, 12);    // SCK, CS, SO
6LiquidCrystal_I2C lcd(0x27, 16, 2);  // adres 0x27 ya da 0x3F / address 0x27 or 0x3F
7
8const int BUZZER_PIN = 8;            // aktif buzzer / active buzzer
9const float ALARM_C = 250.0;         // alarm eşiği / alarm threshold
10const float HYST_C  = 10.0;          // histerezis / hysteresis
11
12float maxC = 0;
13bool alarmOn = false;
14
15void setup() {
16  pinMode(BUZZER_PIN, OUTPUT);
17  lcd.init();
18  lcd.backlight();
19  lcd.print(F("Soba borusu"));
20  delay(1000);
21}
22
23void loop() {
24  float c = thermocouple.readCelsius();
25  lcd.clear();
26
27  if (isnan(c)) {
28    lcd.print(F("Prob bagli degil"));
29    alarmOn = false;
30  } else {
31    if (c > maxC) maxC = c;                                // en yüksek değer / peak value
32    if (!alarmOn && c >= ALARM_C) alarmOn = true;          // eşik aşıldı / threshold exceeded
33    if (alarmOn && c <= ALARM_C - HYST_C) alarmOn = false; // yeterince soğudu / cooled down enough
34
35    lcd.setCursor(0, 0);
36    lcd.print(F("Boru: "));
37    lcd.print(c, 1);
38    lcd.print((char)223);                                  // derece işareti / degree sign
39    lcd.print('C');
40
41    lcd.setCursor(0, 1);
42    if (alarmOn) {
43      lcd.print(F("COK SICAK!"));
44    } else {
45      lcd.print(F("Max: "));
46      lcd.print(maxC, 0);
47      lcd.print((char)223);
48      lcd.print('C');
49    }
50  }
51  digitalWrite(BUZZER_PIN, alarmOn ? HIGH : LOW);
52  delay(500);
53}

Nel codice per l'allarme abbiamo usato l'isteresi: l'allarme scatta a 250 °C ma non si spegne finché la temperatura non scende sotto i 240 °C. In questo modo, quando il valore oscilla attorno alla soglia a passi di 0,25 °C, il buzzer non si accende e spegne di continuo. (char)223 è il simbolo del grado nella tabella caratteri degli LCD basati su HD44780. Il codice presuppone un buzzer attivo che suona da solo; se usi un buzzer passivo, al posto di digitalWrite usa tone(BUZZER_PIN, 2000) e noTone(BUZZER_PIN). Se sullo schermo non compare nulla, prova a cambiare l'indirizzo dell'LCD in 0x3F.

Forno e stazione saldante: controllo della temperatura con relè

Con la temperatura misurata puoi anche accendere e spegnere un riscaldatore. Il metodo più semplice è il controllo on-off con isteresi: il riscaldatore si accende quando la temperatura scende 3 °C sotto il valore obiettivo e si spegne quando supera l'obiettivo di 3 °C. Per il forno di casa l'obiettivo è di solito tra 50 e 250 °C; in una stazione saldante la punta si mantiene attorno a 330–370 °C per la lega senza piombo e a 300–340 °C per la lega con piombo. Per misurare la punta del saldatore usa una termocoppia sottile con la punta a perlina e crea il contatto con una piccola goccia di stagno; una sonda spessa a vite assorbe il calore della punta e legge meno. Nei sistemi con grande inerzia termica (come un forno) la temperatura continua a salire per un po' anche dopo lo spegnimento del relè; per un risultato più stabile leggi l'articolo sul controllo PID. Il codice seguente include anche un livello di sicurezza: se la sonda si scollega (NAN) o la temperatura supera 300 °C, il riscaldatore viene spento subito. Per una stazione saldante ti basta impostare TARGET_C a 350 e MAX_SAFE a 420.

C++ (Arduino IDE)
1#include <max6675.h>
2
3MAX6675 thermocouple(13, 10, 12);   // SCK, CS, SO
4
5const int RELAY_PIN  = 7;
6const float TARGET_C = 180.0;   // hedef sıcaklık / target temperature
7const float BAND_C   = 3.0;     // ± bant / ± band
8const float MAX_SAFE = 300.0;   // güvenlik sınırı / safety limit
9
10bool heaterOn = false;
11
12void setup() {
13  Serial.begin(9600);
14  pinMode(RELAY_PIN, OUTPUT);
15  digitalWrite(RELAY_PIN, LOW);   // başlangıçta kapalı / off at start
16  delay(500);
17}
18
19void loop() {
20  float c = thermocouple.readCelsius();
21
22  if (isnan(c) || c > MAX_SAFE) {
23    heaterOn = false;             // prob koptu ya da aşırı sıcak / probe lost or overheated
24  } else if (c < TARGET_C - BAND_C) {
25    heaterOn = true;              // soğudu: ısıt / too cold: heat
26  } else if (c > TARGET_C + BAND_C) {
27    heaterOn = false;             // ısındı: kapat / too hot: stop
28  }
29
30  digitalWrite(RELAY_PIN, heaterOn ? HIGH : LOW);
31
32  Serial.print(c);
33  Serial.print(F(" C, isitici / heater: "));
34  Serial.println(heaterOn ? F("ON") : F("OFF"));
35  delay(500);
36}
Pilotare dispositivi a 220 V come un forno, un riscaldatore o un saldatore comporta un rischio mortale. Assicurati che la corrente dei contatti del relè sia sufficiente (una resistenza da 1500 W assorbe circa 6,8 A a 220 V), metti il lato di rete in una scatola isolata e, se non sei sicuro, rivolgiti a un esperto. Se commuti spesso, un relè a stato solido (SSR) dura molto più di uno meccanico. Controlla nell'articolo sul modulo relè se il modulo si attiva con LOW o con HIGH; in alcuni moduli devi invertire la logica HIGH e LOW nel codice.

Usare il MAX6675 con ESP32

Poiché il MAX6675 funziona tra 3,0 e 5,5 V, si può collegare direttamente all'ESP32 alimentandolo dal pin 3V3: così anche la linea SO resta a 3,3 V e non serve un convertitore di livello. La libreria Adafruit funziona anche su ESP32, ma questa volta ti diamo un esempio che legge con l'SPI hardware senza libreria, così vedi nel codice come si decodificano i 16 bit. Il codice compila senza modifiche con ESP32 Arduino core 2.x e 3.x. Il pin MOSI (GPIO 23) viene definito per il driver SPI ma non va collegato al modulo. Se vuoi inviare la misura al telefono via Wi-Fi, puoi unire questa funzione alla struttura dell'articolo web server e WebSocket con ESP32.

C++ (Arduino IDE)
1#include <SPI.h>
2
3const int PIN_SCK  = 18;  // MAX6675 SCK
4const int PIN_SO   = 19;  // MAX6675 SO (MISO)
5const int PIN_MOSI = 23;  // tanımlı ama bağlanmaz / defined but not connected
6const int PIN_CS   = 5;   // MAX6675 CS
7
8SPISettings maxSettings(1000000, MSBFIRST, SPI_MODE0);  // 1 MHz (sınır 4,3 MHz) / 1 MHz (limit 4.3 MHz)
9
10float readMAX6675() {
11  SPI.beginTransaction(maxSettings);
12  digitalWrite(PIN_CS, LOW);
13  delayMicroseconds(1);
14  uint16_t raw = SPI.transfer16(0x0000);  // 16 bit oku / read 16 bits
15  digitalWrite(PIN_CS, HIGH);
16  SPI.endTransaction();
17
18  if (raw & 0x0004) {          // D2 = 1: termokupl açık / thermocouple open
19    return NAN;
20  }
21  return (raw >> 3) * 0.25f;   // 12 bit x 0,25 °C
22}
23
24void setup() {
25  Serial.begin(115200);
26  SPI.begin(PIN_SCK, PIN_SO, PIN_MOSI, PIN_CS);  // SCK, MISO, MOSI, SS
27  pinMode(PIN_CS, OUTPUT);
28  digitalWrite(PIN_CS, HIGH);                    // CS elle sürülür / CS driven manually
29  delay(500);
30}
31
32void loop() {
33  float c = readMAX6675();
34  if (isnan(c)) {
35    Serial.println("Termokupl yok / No thermocouple");
36  } else {
37    Serial.printf("Sicaklik / Temp: %.2f C\n", c);
38  }
39  delay(500);  // en az 250 ms / at least 250 ms
40}

Raspberry Pi Pico con MAX6675 (MicroPython)

Per il Pico non serve nessuna libreria aggiuntiva: basta la classe integrata machine.SPI di MicroPython. Usiamo i pin GP16 (MISO), GP17 (CS) e GP18 (SCK) del bus SPI0; alimenta il modulo dal pin 3V3(OUT). spi.read(2) legge due byte: il primo è la parte più significativa, il secondo la meno significativa. Poi, come su Arduino, sposti di 3 bit a destra e moltiplichi per 0,25. Se sei nuovo a MicroPython, puoi iniziare con l'articolo basi di MicroPython.

MicroPython
1from machine import Pin, SPI
2import time
3
4spi = SPI(0, baudrate=1000000, polarity=0, phase=0,
5          sck=Pin(18), mosi=Pin(19), miso=Pin(16))  # GP19 bağlanmaz / GP19 is not connected
6cs = Pin(17, Pin.OUT, value=1)
7
8def read_max6675():
9    cs.value(0)
10    data = spi.read(2)              # 16 bit oku / read 16 bits
11    cs.value(1)
12    raw = (data[0] << 8) | data[1]
13    if raw & 0x04:                  # D2 = 1: termokupl açık / thermocouple open
14        return None
15    return (raw >> 3) * 0.25        # 12 bit x 0,25 C
16
17time.sleep_ms(500)                  # ilk dönüşüm / first conversion
18while True:
19    t = read_max6675()
20    if t is None:
21        print("Termokupl bagli degil / Thermocouple not connected")
22    else:
23        print("Sicaklik / Temp: {:.2f} C".format(t))
24    time.sleep_ms(500)              # en az 250 ms / at least 250 ms

Idee di progetto con il MAX6675

  • Allarme per il tubo della stufa: porta l'esempio con LCD su un ESP32 e invia un messaggio Telegram al telefono quando il tubo si surriscalda.
  • Termometro da forno: misura la vera temperatura interna del forno di casa; non stupirti se tra questa e il valore indicato dalla manopola del termostato c'è una differenza di 10–20 °C.
  • Indicatore per forno in pietra: misura con una sonda a guaina metallica la temperatura di un forno a legna che arriva a 400–450 °C e mostrala in grande, leggibile da lontano, su una matrice LED MAX7219.
  • La tua stazione saldante: pilota la resistenza di un saldatore con un SSR e un PID e regola la temperatura obiettivo con un rotary encoder.
  • Forno reflow: trasforma un piccolo fornetto elettrico in un forno che segue il profilo di temperatura per la saldatura SMD.
  • Registratore di temperatura: salva in CSV su un modulo SD l'andamento di una grigliata, di una tostatura del caffè o di un trattamento termico, poi tracciane il grafico.
  • Monitoraggio della temperatura di scarico: controlla la temperatura dello scarico di un generatore o di una moto e dai un avviso sonoro in caso di surriscaldamento.

Errori comuni e come risolverli

SintomoCausa probabileSoluzione
Sempre NAN o messaggio "non collegata"Termocoppia non inserita, vite del morsetto allentata o filo rottoAvvita bene i fili; con il multimetro controlla che tra i due capi della sonda ci sia una resistenza bassa (da pochi a qualche decina di ohm)
Sempre 0,00 °CPin SO non collegato o ordine dei pin nel costruttore sbagliatoControlla il cablaggio e l'ordine MAX6675(SCK, CS, SO)
Scaldando il valore scendePolarità della termocoppia invertitaScambia i fili + e −
Il valore non cambia maiLetture più frequenti di 250 ms interrompono continuamente la conversioneLascia almeno 250 ms tra le letture
I valori saltano, sono rumorosiDisturbi di relè o motori, cavi lunghi, alimentazione instabileAggiungi un condensatore da 100 nF tra VCC e GND, fai la media di più misure, tieni corti i cavi di segnale
A temperatura ambiente legge qualche grado in piùIl modulo è vicino a una superficie calda o a un regolatore; la giunzione fredda vede il calore sbagliatoSposta il modulo lontano dalla fonte di calore, in un punto ventilato

Il MAX6675 è il convertitore per termocoppie più facile da imparare: rende accessibile la misura di alte temperature con pochi fili e poche righe di codice. La qualità della misura dipende quasi sempre non dal chip, ma dalla scelta e dal montaggio della sonda: fai aderire bene la sonda alla superficie, collega correttamente la polarità e non allungare il cavo con il rame. Prima di passare al controllo di un riscaldatore, dai un'occhiata anche alle precauzioni di sicurezza nell'articolo sul termostato con Arduino. Nell'app BlueGrays trovi passo dopo passo, con schemi e codice, progetti come la misura di temperatura con LCD, l'allarme con buzzer e il registratore di temperatura con ESP32, e puoi aggiungere facilmente il MAX6675 a questi progetti.

Domande frequenti

Fino a quanti gradi misura il MAX6675?

Il MAX6675 misura da 0 °C a 1023,75 °C con una risoluzione di 0,25 °C. In pratica, però, il limite superiore lo decide spesso la sonda: quelle a vite con cavo in fibra di vetro fornite con il modulo reggono in genere fino a circa 400 °C. Per misure vicine a 1000 °C serve una sonda K con guaina ceramica o metallica e isolamento minerale.

Il MAX6675 misura temperature negative?

No, il MAX6675 non può mostrare temperature sotto 0 °C: il bit di segno nel formato dei dati è sempre zero. Per le temperature negative puoi usare il MAX31855 o il MAX31856, che arrivano a −200 °C, oppure il DS18B20, che misura fino a −55 °C.

Perché il MAX6675 restituisce NAN?

La libreria restituisce NAN quando vede a 1 il bit di "termocoppia aperta" (D2) del chip. Di solito significa che la termocoppia non è inserita, la vite del morsetto è allentata o il filo è rotto. Serra bene i fili e controlla con il multimetro che tra i due capi della sonda ci sia una resistenza bassa.

Qual è la differenza tra MAX6675 e MAX31855?

Entrambi leggono una termocoppia K via SPI con risoluzione di 0,25 °C. Il MAX31855 usa dati a 14 bit, misura da −200 a +1350 °C, segnala separatamente circuito aperto, corto a GND e corto a VCC e invia anche la temperatura della giunzione fredda. Il MAX6675 è limitato a 0–1023,75 °C, ma costa meno ed è più diffuso; per misure su stufa, forno e saldatura è più che sufficiente.

Si può allungare il cavo della termocoppia?

Si può, ma non con un normale cavo di rame. Ogni punto in cui il rame incontra le leghe della termocoppia si comporta come una nuova termocoppia e introduce errori. Usa un cavo di estensione per termocoppie K, oppure tieni il modulo vicino alla sonda e allunga i fili di segnale SCK, CS e SO, senza superare comunque qualche metro di linea SPI.

Il MAX6675 funziona con ESP32 e a 3,3 V?

Sì. Il MAX6675 funziona tra 3,0 e 5,5 V; se su ESP32 o Raspberry Pi Pico alimenti il modulo dal pin 3V3, anche l'uscita SO è a 3,3 V e non serve un convertitore di livello. Alimentare il modulo a 5 V e collegarlo a una scheda a 3,3 V non è consigliato, perché la linea SO invierebbe 5 V.

Vedi tutti i progetti
Temperatura e umidità con DHT11
AR-55Intermedio

Temperatura e umidità con DHT11

Quanti gradi ci sono nella tua stanza, e l'aria è umida o secca? Il sensore DHT11 misura temperatura e umidità, e l'Arduino scrive i valori su uno schermo LCD a due righe, aggiornandoli ogni paio di…

4.7(47)
83
Uso del cicalino
AR-13Principiante

Uso del cicalino

Ti sei mai chiesto come fa un campanello o un allarme a suonare? L'Arduino fa suonare un piccolo cicalino a intervalli brevi: bip, pausa, bip, pausa.

4.7(92)
170
Misura di temperatura con NTC e display Lcd 2x16
AR-44Principiante
Premium

Misura di temperatura con NTC e display Lcd 2x16

Misura la temperatura dell'ambiente con un sensore che sembra una piccola perlina.

4.5(33)
44
Utilizzo dello schermo LCD con I2C
AR-32Principiante
Premium

Utilizzo dello schermo LCD con I2C

Regala al tuo Arduino uno schermo tutto suo e fagli scrivere il primo messaggio.

4.8(53)
70
Schermo LCD I2C per ESP32 (16x2)
ES-17Intermedio
Premium

Schermo LCD I2C per ESP32 (16x2)

In questo progetto colleghiamo un display LCD 16x2 a caratteri all'ESP32 tramite I2C per mostrare del testo. Con l'I2C bastano 2 pin dati (SDA e SCL) invece dei 6+ pin di un collegamento parallelo classico. Il codice scrive un messaggio fisso sulla prima riga e un contatore che sale ogni secondo sulla seconda. All'avvio uno scanner I2C stampa l'indirizzo del display sul Serial Monitor (di solito 0x27 o 0x3F).

4.9(23)
40
ESP32 DHT22 Temperatura e umidità (con display LCD)
ES-15Intermedio

ESP32 DHT22 Temperatura e umidità (con display LCD)

Si tratta di un progetto che misura la temperatura e l'umidità dell'ambiente tramite il sensore DHT22 e le visualizza in tempo reale su un display LCD I2C 16x2. I dati vengono letti dal sensore utilizzando il protocollo one-wire tramite la libreria Adafruit DHT. Questo progetto costituisce la base per stazioni meteorologiche IoT, sistemi di automazione domestica intelligente o sistemi di monitoraggio ambientale nelle serre. La comunicazione con il DHT22 avviene tramite il pin GPIO 4 dell'ESP32.

4.8(38)
57
Data Logger di Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Avanzato
Premium

Data Logger di Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)

Costruisci con l'ESP32 un registratore di temperatura e umidità con orario! Un sensore DHT22 legge temperatura e umidità una volta al minuto e ogni lettura viene salvata su una scheda microSD in formato CSV con l'ora reale del modulo RTC DS1307. Il display OLED mostra in tempo reale, a caratteri grandi, l'ultima temperatura, l'umidità, l'orario e il numero totale di registrazioni.

4.7(7)
12
Utilizzo del sensore di fiamma
AR-50Intermedio
Premium

Utilizzo del sensore di fiamma

Un piccolo guardiano che si accorge del fuoco prima di te, in cucina o in laboratorio.

4.6(33)
44