Sensore NPK Arduino: azoto, fosforo e potassio via RS485
Sensore NPK con Arduino: collegamento MAX485 e alimentazione 12 V, trama Modbus, tabella di azoto, fosforo e potassio, limiti di calibrazione e codice ESP32.
Con un sensore NPK e Arduino puoi tenere d'occhio azoto (N), fosforo (P) e potassio (K) del terreno in mg/kg; è una sonda da terreno industriale che comunica su una linea RS485 con il protocollo Modbus RTU. Per collegarlo ad Arduino metti in mezzo un MAX485, alimenti il sensore a 12 V e invii una trama di richiesta da 8 byte; in pochi millisecondi il sensore risponde con tutti e tre i valori. È uno dei sensori più cercati per seguire il fabbisogno di concime in serra, nell'orto e in piccoli appezzamenti.
In questa guida vedrai passo passo come collegare i fili del sensore al modulo MAX485 e ad Arduino, cosa significa ogni byte della trama Modbus, come si calcola il CRC, come trasformare la risposta in numeri e come monitorare un campo via Wi-Fi con un ESP32. Parleremo anche di un aspetto che quasi tutti i venditori tacciono: i limiti di misura dei sensori NPK economici e come calibrarne i valori.
Cos'è un sensore NPK per terreno e come funziona?
La maggior parte dei sensori NPK in commercio (JXBS-3001-NPK-RS e cloni) sono sonde con tre punte in acciaio inox, grado di protezione IP68 e corpo in resina epossidica. Quando le punte sono completamente interrate, il sensore misura le proprietà elettriche della soluzione del terreno e, con le formule del suo firmware, le converte in una stima di azoto, fosforo e potassio. Non ha un'uscita analogica: i valori vengono inviati solo in digitale tramite RS485 e solo su richiesta. Per questo si usa la porta seriale di Arduino e non i pin analogici. Nella sezione sulla calibrazione vedrai nel dettaglio perché questo sensore non è uno strumento da laboratorio.
| Caratteristica | Valore tipico |
|---|---|
| Valori misurati | Azoto (N), fosforo (P), potassio (K) |
| Campo di misura | 0–1999 mg/kg (mg/kg = ppm) |
| Risoluzione | 1 mg/kg |
| Precisione dichiarata | ±2 % FS (solo nelle condizioni di calibrazione del produttore) |
| Alimentazione | A seconda del modello 5–30 V o 9–24 V DC; 12 V va bene per entrambi |
| Comunicazione | RS485, Modbus RTU, 9600 baud, 8N1 (alcuni modelli 4800) |
| Indirizzo predefinito | 0x01 |
| Tempo di risposta | Meno di 1 secondo |
| Corpo e punte | IP68, acciaio inox 316 |
Perché servono RS485 e il MAX485?
RS485 è uno standard di comunicazione che trasporta i dati come differenza di tensione tra due fili (A e B). Questo metodo resiste molto bene ai disturbi e funziona anche con cavi di oltre 100 metri in campo; sulla stessa linea si possono collegare fino a 32 dispositivi. La porta seriale di Arduino invece lavora a livelli TTL (0 e 5 V). Il modulo MAX485 traduce tra i due mondi: converte i dati dal pin TX di Arduino nella differenza A/B e la differenza A/B che arriva dal sensore in un segnale adatto al pin RX. RS485 è half duplex, cioè in ogni momento si trasmette oppure si ascolta; i pin DE e RE del modulo scelgono la direzione. Le basi della comunicazione seriale sono nella guida alla comunicazione seriale UART.
Collegamento del sensore NPK: colori dei fili e MAX485
| Filo del sensore | Funzione | Collegato a |
|---|---|---|
| Marrone | Alimentazione + | + dell'alimentatore da 12 V |
| Nero | Alimentazione - | - dell'alimentatore da 12 V e GND di Arduino (in comune) |
| Giallo | RS485 A (+) | A del MAX485 |
| Blu | RS485 B (-) | B del MAX485 |
| Pin del MAX485 | Arduino Uno | ESP32 (MAX3485) | Raspberry Pi Pico (MAX3485) |
|---|---|---|---|
| VCC | 5V | 3V3 | 3V3(OUT) |
| GND | GND | GND | GND |
| RO (uscita del ricevitore) | D2 | GPIO 16 (RX2) | GP1 (UART0 RX) |
| DI (ingresso del trasmettitore) | D3 | GPIO 17 (TX2) | GP0 (UART0 TX) |
| DE e RE (uniti) | D7 | GPIO 4 | GP2 |
| A e B | Fili giallo e blu del sensore | Uguale | Uguale |
Alimenta il sensore con un alimentatore da 12 V. Arduino può funzionare via USB oppure dallo stesso alimentatore, abbassato a 5 V con un convertitore step-down LM2596. In ogni caso il negativo dell'alimentatore va collegato al GND di Arduino: anche se RS485 è differenziale, l'intervallo di tensione accettato dal ricevitore è riferito alla massa comune. Con cavi di pochi metri non serve la resistenza di terminazione; su linee oltre i 50 metri, 120 Ω alle due estremità evitano le riflessioni. Molti moduli MAX485 la hanno già montata. Sulle tratte lunghe usa un cavo a coppia intrecciata per A e B.
La trama di richiesta Modbus: cosa inviamo al sensore?
In Modbus RTU è sempre il master (Arduino) ad avviare lo scambio; il sensore risponde solo quando viene interrogato. Per leggere i valori si usa la funzione 03 (Read Holding Registers). Nei sensori NPK di tipo JXBS l'azoto si trova nel registro 0x001E, il fosforo in 0x001F e il potassio in 0x0020; essendo consecutivi, si leggono tutti e tre con una sola richiesta. Questa trama da 8 byte chiede proprio questo: 01 03 00 1E 00 03 65 CD.
| Byte | Valore (hex) | Significato |
|---|---|---|
| 1 | 01 | Indirizzo del sensore |
| 2 | 03 | Funzione: lettura registri |
| 3–4 | 00 1E | Registro iniziale (azoto) |
| 5–6 | 00 03 | Numero di registri da leggere (N, P, K) |
| 7–8 | 65 CD | CRC16, prima il byte basso |
La risposta del sensore è lunga 11 byte: indirizzo (01), funzione (03), numero di byte di dati (06), tre valori da due byte ciascuno e un CRC da due byte. Per esempio, nella risposta 01 03 06 00 20 00 0F 00 6E 11 5D l'azoto vale 0x0020 = 32 mg/kg, il fosforo 0x000F = 15 mg/kg e il potassio 0x006E = 110 mg/kg. In ogni valore arriva prima il byte alto: valore = byte alto × 256 + byte basso. Per il CRC è il contrario, prima il byte basso; questo piccolo dettaglio è la confusione più comune con Modbus.
| Registro | Valore | Unità | Trama per leggerlo da solo |
|---|---|---|---|
| 0x001E | Azoto (N) | mg/kg | 01 03 00 1E 00 01 E4 0C |
| 0x001F | Fosforo (P) | mg/kg | 01 03 00 1F 00 01 B5 CC |
| 0x0020 | Potassio (K) | mg/kg | 01 03 00 20 00 01 85 C0 |
| 0x001E–0x0020 | N, P e K insieme | mg/kg | 01 03 00 1E 00 03 65 CD |
Codice per Arduino Uno: leggere N, P e K
Il codice non richiede librerie aggiuntive; usa SoftwareSerial, incluso nell'Arduino IDE. Calcola il CRC a ogni richiesta, controlla indirizzo, funzione, lunghezza e CRC della risposta e scrive i valori validi nel Monitor seriale. Apri il Monitor seriale a 9600 baud; con il collegamento giusto vedrai N, P e K ogni due secondi.
1// NPK toprak sensörü (RS485 Modbus RTU) + MAX485 + Arduino Uno
2// NPK soil sensor (RS485 Modbus RTU) + MAX485 + Arduino Uno
3#include <SoftwareSerial.h>
4
5const uint8_t PIN_RO = 2; // MAX485 RO -> Arduino RX
6const uint8_t PIN_DI = 3; // MAX485 DI <- Arduino TX
7const uint8_t PIN_DE_RE = 7; // DE ve RE birleşik / DE and RE tied together
8
9const uint8_t SENSOR_ADDR = 0x01; // varsayılan adres / default address
10const uint16_t REG_N = 0x001E; // azot; fosfor 0x001F, potasyum 0x0020 / nitrogen; P 0x001F, K 0x0020
11
12SoftwareSerial rs485(PIN_RO, PIN_DI);
13
14// Modbus CRC16 (polinom 0xA001) / Modbus CRC16 (polynomial 0xA001)
15uint16_t crc16(const uint8_t *buf, uint8_t len) {
16 uint16_t crc = 0xFFFF;
17 for (uint8_t i = 0; i < len; i++) {
18 crc ^= buf[i];
19 for (uint8_t b = 0; b < 8; b++) {
20 if (crc & 1) crc = (crc >> 1) ^ 0xA001;
21 else crc >>= 1;
22 }
23 }
24 return crc;
25}
26
27// 03 fonksiyonuyla ardışık yazmaçları oku (en çok 8) / read up to 8 consecutive registers with function 03
28bool readRegisters(uint16_t start, uint8_t count, uint16_t *out) {
29 uint8_t req[8] = { SENSOR_ADDR, 0x03, (uint8_t)(start >> 8), (uint8_t)(start & 0xFF), 0x00, count, 0, 0 };
30 uint16_t crc = crc16(req, 6);
31 req[6] = crc & 0xFF; // CRC: önce düşük bayt / low byte first
32 req[7] = crc >> 8;
33
34 while (rs485.available()) rs485.read(); // eski baytları at / drop old bytes
35 digitalWrite(PIN_DE_RE, HIGH); // gönderme modu / transmit mode
36 rs485.write(req, 8);
37 digitalWrite(PIN_DE_RE, LOW); // alma modu / receive mode
38
39 uint8_t resp[21];
40 uint8_t need = 5 + 2 * count; // adres + fonksiyon + bayt sayısı + veri + CRC / addr + func + count + data + CRC
41 uint8_t got = 0;
42 unsigned long t0 = millis();
43 while (got < need && millis() - t0 < 500) { // 500 ms zaman aşımı / 500 ms timeout
44 if (rs485.available()) resp[got++] = rs485.read();
45 }
46 if (got < need || resp[0] != SENSOR_ADDR || resp[1] != 0x03 || resp[2] != 2 * count) return false;
47 uint16_t rxCrc = resp[need - 2] | ((uint16_t)resp[need - 1] << 8);
48 if (crc16(resp, need - 2) != rxCrc) return false; // bozuk yanıt / corrupted reply
49 for (uint8_t i = 0; i < count; i++) out[i] = ((uint16_t)resp[3 + 2 * i] << 8) | resp[4 + 2 * i];
50 return true;
51}
52
53void setup() {
54 Serial.begin(9600);
55 rs485.begin(9600); // sensörün varsayılan hızı / sensor default baud rate
56 pinMode(PIN_DE_RE, OUTPUT);
57 digitalWrite(PIN_DE_RE, LOW);
58 Serial.println(F("NPK sensoru hazir / NPK sensor ready"));
59}
60
61void loop() {
62 uint16_t npk[3];
63 if (readRegisters(REG_N, 3, npk)) {
64 Serial.print(F("N: ")); Serial.print(npk[0]);
65 Serial.print(F(" P: ")); Serial.print(npk[1]);
66 Serial.print(F(" K: ")); Serial.print(npk[2]);
67 Serial.println(F(" mg/kg"));
68 } else {
69 Serial.println(F("Yanit yok ya da CRC hatasi / no reply or CRC error"));
70 }
71 delay(2000);
72}| Parte | Cosa fa |
|---|---|
| crc16() | Calcola il CRC16 Modbus con il polinomio 0xA001 |
| DE/RE a HIGH, poi LOW | Mette il MAX485 in trasmissione e, inviata la trama, lo riporta in ascolto |
| need = 5 + 2 × count | Lunghezza attesa della risposta: 3 byte di intestazione, i dati e 2 byte di CRC |
| Timeout di 500 ms | Il programma non si blocca se il sensore non risponde |
| Controllo di CRC e indirizzo | Scarta le risposte rovinate dai disturbi o provenienti da un altro dispositivo |
Interpretare i valori: tabella NPK
Il sensore fornisce un numero in mg/kg, ma se quel numero sia buono o cattivo per le tue piante dipende dal tipo di terreno, dalla coltura e dal metodo di analisi del laboratorio. Gli intervalli qui sotto sono limiti indicativi che compaiono spesso nelle guide agronomiche e sono solo un punto di partenza. Non decidere quanto concime usare confrontando un sensore non calibrato con questa tabella; usala piuttosto per vedere in quale fascia cadono le tue misure già calibrate.
| Nutriente | Basso | Medio | Alto | Nota |
|---|---|---|---|---|
| Azoto (N nitrico) | Meno di 10 mg/kg | 10–25 mg/kg | Più di 25 mg/kg | Per il mais 25 mg/kg è una soglia molto usata; cambia in fretta con irrigazione e pioggia |
| Fosforo (P Olsen) | Meno di 10 mg/kg | 10–20 mg/kg | Più di 20 mg/kg | Si muove lentamente nel terreno e varia nell'arco di mesi |
| Potassio (K scambiabile) | Meno di 100 mg/kg | 100–200 mg/kg | Più di 200 mg/kg | Nei terreni argillosi sono normali valori più alti |
Limiti della calibrazione: questo sensore misura davvero l'NPK?
A essere onesti, i sensori NPK RS485 economici non misurano separatamente azoto, fosforo e potassio per via chimica. Non contengono alcun elemento iono-selettivo; ciò che misurano davvero è la conducibilità (EC) della soluzione del terreno, che poi suddividono in tre numeri con coefficienti fissi. Per questo i tre valori di solito salgono e scendono insieme, aumentano quando il terreno si bagna e il sensore segna NPK alto perfino immerso in acqua salata. Questo non lo rende inutile: le misure prese nello stesso campo, con la stessa umidità e alla stessa profondità mostrano in modo affidabile la variazione dopo una concimazione e la tendenza nel tempo. Ma come valore assoluto non sostituiscono un'analisi del terreno in laboratorio.
- Preleva campioni di terreno in 3–5 punti diversi del campo e falli analizzare in laboratorio per N, P e K.
- Misura con il sensore negli stessi punti e con la stessa umidità (per esempio un giorno dopo l'irrigazione), con le punte completamente interrate a 10–20 cm di profondità.
- Fai 3 letture in ogni punto e usa la media; una lettura singola può ingannarti per colpa di un sasso o di una sacca d'aria.
- Ricava una retta a due punti tra i risultati del laboratorio e le medie del sensore e aggiungila al codice come correzione.
- Ripeti la calibrazione se cambi tipo di terreno o di concime; una misura di controllo a inizio stagione è sufficiente.
1// İki noktalı düzeltme: laboratuvar sonucuyla sensör okumasını eşleştir
2// Two-point correction: match sensor readings to lab results
3float calibrate(uint16_t raw, float rawLow, float labLow, float rawHigh, float labHigh) {
4 return labLow + (raw - rawLow) * (labHigh - labLow) / (rawHigh - rawLow);
5}
6
7// Örnek: sensör 40 iken laboratuvar 18, sensör 120 iken 52 mg/kg dedi
8// Example: sensor 40 -> lab 18, sensor 120 -> lab 52 mg/kg (loop() içinde / inside loop())
9float nitrogen = calibrate(npk[0], 40, 18, 120, 52);Monitoraggio del campo con ESP32

Con un ESP32 puoi seguire le misure sullo smartphone via Wi-Fi. Poiché l'ESP32 lavora a 3,3 V, al posto del MAX485 a 5 V usa un MAX3485 o un modulo RS485 a direzione automatica. Se hai solo un MAX485, alimentalo a 5 V e porta la sua uscita RO a 3,3 V con un partitore di tensione. Il codice qui sotto fa una misura al minuto e mostra gli ultimi valori in una pagina web e all'indirizzo /json; questo JSON si passa facilmente a un foglio di calcolo o a un sistema domotico.
1// ESP32 + RS485 NPK sensörü: Wi-Fi ile tarla izleme / ESP32 + RS485 NPK sensor: field monitoring over Wi-Fi
2#include <WiFi.h>
3#include <WebServer.h>
4
5const char* WIFI_SSID = "AgAdi"; // Wi-Fi adın / your Wi-Fi name
6const char* WIFI_PASS = "Sifre123"; // Wi-Fi şifren / your Wi-Fi password
7
8const int PIN_RX = 16; // MAX3485 RO
9const int PIN_TX = 17; // MAX3485 DI
10const int PIN_DE_RE = 4; // DE + RE
11const uint8_t SENSOR_ADDR = 0x01;
12const uint16_t REG_N = 0x001E;
13const unsigned long READ_EVERY_MS = 60000; // dakikada bir ölç / measure once a minute
14
15HardwareSerial rs485(2); // UART2
16WebServer server(80);
17
18uint16_t lastN = 0, lastP = 0, lastK = 0;
19bool lastOk = false;
20uint32_t readCount = 0;
21unsigned long lastRead = 0;
22
23uint16_t crc16(const uint8_t *buf, uint8_t len) {
24 uint16_t crc = 0xFFFF;
25 for (uint8_t i = 0; i < len; i++) {
26 crc ^= buf[i];
27 for (uint8_t b = 0; b < 8; b++) crc = (crc & 1) ? (crc >> 1) ^ 0xA001 : crc >> 1;
28 }
29 return crc;
30}
31
32bool readRegisters(uint16_t start, uint8_t count, uint16_t *out) {
33 uint8_t req[8] = { SENSOR_ADDR, 0x03, (uint8_t)(start >> 8), (uint8_t)(start & 0xFF), 0x00, count, 0, 0 };
34 uint16_t crc = crc16(req, 6);
35 req[6] = crc & 0xFF;
36 req[7] = crc >> 8;
37 while (rs485.available()) rs485.read();
38 digitalWrite(PIN_DE_RE, HIGH);
39 rs485.write(req, 8);
40 rs485.flush(); // son bayt çıkana kadar bekle / wait until the last byte is out
41 digitalWrite(PIN_DE_RE, LOW);
42
43 uint8_t resp[21];
44 uint8_t need = 5 + 2 * count, got = 0;
45 unsigned long t0 = millis();
46 while (got < need && millis() - t0 < 500) {
47 if (rs485.available()) resp[got++] = rs485.read();
48 }
49 if (got < need || resp[0] != SENSOR_ADDR || resp[1] != 0x03 || resp[2] != 2 * count) return false;
50 if (crc16(resp, need - 2) != (resp[need - 2] | (resp[need - 1] << 8))) return false;
51 for (uint8_t i = 0; i < count; i++) out[i] = (resp[3 + 2 * i] << 8) | resp[4 + 2 * i];
52 return true;
53}
54
55void handleRoot() {
56 String html = "<!DOCTYPE html><html><head><meta name='viewport' content='width=device-width'>";
57 html += "<meta http-equiv='refresh' content='30'></head><body><h2>NPK (mg/kg)</h2>";
58 html += "<p>N: " + String(lastN) + "<br>P: " + String(lastP) + "<br>K: " + String(lastK) + "</p>";
59 html += "<p>" + String(lastOk ? "Sensor OK" : "Sensor yanit vermiyor / no reply");
60 html += " - olcum / readings: " + String(readCount) + "</p></body></html>";
61 server.send(200, "text/html", html);
62}
63
64void handleJson() { // başka sistemler için / for other systems
65 String json = "{\"n\":" + String(lastN) + ",\"p\":" + String(lastP) + ",\"k\":" + String(lastK);
66 json += ",\"ok\":" + String(lastOk ? "true" : "false") + "}";
67 server.send(200, "application/json", json);
68}
69
70void setup() {
71 Serial.begin(115200);
72 rs485.begin(9600, SERIAL_8N1, PIN_RX, PIN_TX);
73 pinMode(PIN_DE_RE, OUTPUT);
74 digitalWrite(PIN_DE_RE, LOW);
75 WiFi.mode(WIFI_STA);
76 WiFi.begin(WIFI_SSID, WIFI_PASS);
77 unsigned long t0 = millis();
78 while (WiFi.status() != WL_CONNECTED && millis() - t0 < 15000) delay(250);
79 Serial.println(WiFi.status() == WL_CONNECTED ? WiFi.localIP().toString() : String("Wi-Fi yok / no Wi-Fi"));
80 server.on("/", handleRoot);
81 server.on("/json", handleJson);
82 server.begin();
83 lastRead = millis() - READ_EVERY_MS; // ilk ölçüm hemen / first reading at once
84}
85
86void loop() {
87 server.handleClient();
88 if (millis() - lastRead >= READ_EVERY_MS) {
89 lastRead = millis();
90 uint16_t v[3];
91 lastOk = readRegisters(REG_N, 3, v);
92 if (lastOk) {
93 lastN = v[0]; lastP = v[1]; lastK = v[2];
94 readCount++;
95 Serial.printf("N=%u P=%u K=%u mg/kg\n", lastN, lastP, lastK);
96 } else {
97 Serial.println("Yanit yok / no reply");
98 }
99 }
100}Se in campo non c'è corrente, ti servono una batteria e un piccolo pannello solare. Poiché il sensore consuma anche quando non misura, accendi la linea a 12 V con un MOSFET o un relè solo durante la misura e metti l'ESP32 in deep sleep tra una lettura e l'altra. Così una stazione che misura ogni 30 minuti dura giorni con una piccola batteria al litio. Dopo aver alimentato il sensore, aspetta qualche secondo prima di misurare. Per i campi lontani senza Wi-Fi, un modulo LoRa offre chilometri di portata; la durata della batteria la stimi con il calcolatore di autonomia della batteria.
Codice MicroPython per Raspberry Pi Pico
Anche sul Pico la stessa trama esce dalla UART. In MicroPython la scrittura sulla UART lascia i dati in un buffer e ritorna subito, quindi il codice attende il tempo necessario perché la trama esca sulla linea (circa 8,3 ms per 8 byte a 9600 baud) prima di riportare il pin di direzione in ricezione. Alimenta il modulo MAX3485 dal pin 3V3(OUT) del Pico.
1# Raspberry Pi Pico + MAX3485 + NPK sensörü (MicroPython)
2# Raspberry Pi Pico + MAX3485 + NPK sensor (MicroPython)
3from machine import UART, Pin
4import time
5
6BAUD = 9600
7uart = UART(0, baudrate=BAUD, tx=Pin(0), rx=Pin(1))
8de_re = Pin(2, Pin.OUT, value=0) # 1 = gönder / transmit, 0 = dinle / receive
9
10def crc16(data):
11 crc = 0xFFFF
12 for b in data:
13 crc ^= b
14 for _ in range(8):
15 crc = (crc >> 1) ^ 0xA001 if crc & 1 else crc >> 1
16 return crc
17
18def read_registers(addr, start, count):
19 req = bytes([addr, 0x03, start >> 8, start & 0xFF, 0x00, count])
20 c = crc16(req)
21 req += bytes([c & 0xFF, c >> 8])
22 while uart.any():
23 uart.read() # eski baytları at / drop old bytes
24 de_re.value(1)
25 uart.write(req)
26 time.sleep_us(len(req) * 10 * 1000000 // BAUD + 500) # çerçeve hatta çıksın / let the frame leave
27 de_re.value(0)
28 need = 5 + 2 * count
29 resp = b""
30 t0 = time.ticks_ms()
31 while len(resp) < need and time.ticks_diff(time.ticks_ms(), t0) < 500:
32 if uart.any():
33 resp += uart.read(need - len(resp))
34 if len(resp) < need or resp[0] != addr or resp[1] != 0x03:
35 return None
36 if crc16(resp[:-2]) != resp[-2] | (resp[-1] << 8):
37 return None # CRC hatası / CRC error
38 return [resp[3 + 2 * i] << 8 | resp[4 + 2 * i] for i in range(count)]
39
40while True:
41 v = read_registers(0x01, 0x001E, 3)
42 if v:
43 print("N:", v[0], "P:", v[1], "K:", v[2], "mg/kg")
44 else:
45 print("Yanit yok / no reply")
46 time.sleep(2)Errori comuni e soluzioni
- Nessuna risposta: A e B invertiti, niente 12 V al sensore, masse non in comune o velocità sbagliata; scambia prima A e B, poi prova 4800 baud.
- Legge sempre 0: le punte sono in aria o in terra secchissima; interra completamente il sensore in terreno umido, senza sacche d'aria tra le punte.
- Errore di CRC: il cavo è lungo e disturbato, oppure DE/RE commuta troppo presto; usa una coppia intrecciata e assicurati che sull'ESP32 venga chiamato flush().
- Valori di 65535 o assurdamente grandi: stai leggendo il registro sbagliato; controlla la mappa dei registri nel manuale del tuo sensore.
- I valori schizzano dopo l'irrigazione: è normale, perché il sensore è sensibile alla conducibilità; misura sempre con un'umidità simile.
- Il programma si blocca durante la lettura: il ciclo di lettura non ha un timeout; aggiungine uno da 500 ms come nel codice.
Idee di progetto con il sensore NPK
- Serra intelligente: tieni d'occhio NPK, umidità e temperatura su un unico pannello; dettagli nel progetto della serra intelligente.
- Diario della concimazione: registra in un foglio di calcolo la variazione di NPK dopo ogni concimazione; ti aiuta il metodo ESP32 con Google Sheets.
- Controllo dell'acqua di irrigazione: confronta le letture del terreno con la conducibilità dell'acqua di irrigazione usando un sensore TDS.
- Irrigazione automatica: innaffia con una mini pompa dell'acqua quando l'umidità scende e decidi quando concimare in base alla tendenza dell'NPK.
- Stazione per l'orto scolastico: confronta i valori di diverse aiuole e trasformalo in un progetto per una fiera della scienza.
Il sensore NPK è anche un'ottima occasione per imparare la comunicazione industriale RS485 e il protocollo Modbus; la logica di trame e CRC vista qui è la stessa su centinaia di dispositivi, dai contatori di energia alle stazioni meteo. Non fidarti ciecamente dei numeri: calibra e segui le tendenze. Nell'app BlueGrays, il progetto Stazione di irrigazione intelligente ti mostra passo passo come costruire un circuito con sensore di umidità e pompa, a cui puoi aggiungere il sensore NPK.
Domande frequenti
Come si collega un sensore NPK ad Arduino?
Il sensore ha un'uscita RS485, quindi serve un modulo MAX485 in mezzo. I fili giallo (A) e blu (B) del sensore vanno su A e B del MAX485, i pin RO e DI del MAX485 su D2 e D3 di Arduino e DE e RE uniti su D7. Il sensore si alimenta a 12 V e il GND dell'alimentatore deve essere in comune con il GND di Arduino.
Con quale tensione funziona un sensore NPK?
A seconda del modello funziona a 5–30 V o 9–24 V DC; 12 V è la scelta sicura che va bene per entrambi i tipi. Anche sui modelli dichiarati a 5 V, i 12 V danno letture più stabili. Il modulo MAX485 invece si alimenta con la stessa tensione di Arduino, cioè 5 V.
Il sensore NPK è preciso?
I sensori NPK RS485 economici non misurano separatamente azoto, fosforo e potassio per via chimica: misurano la conducibilità e stimano i valori con delle formule. Per questo i valori assoluti non sostituiscono un'analisi di laboratorio, ma le misure fatte nello stesso campo con la stessa umidità mostrano bene variazioni e tendenze. Una calibrazione a due punti con i risultati di laboratorio migliora molto la precisione.
Perché il mio sensore NPK non risponde?
Le cause più comuni sono A e B invertiti, 12 V che non arrivano al sensore, masse non in comune e velocità sbagliata. Scambia prima A e B, poi prova 4800 baud invece di 9600. Sulle schede con porta seriale hardware, cambiare DE/RE senza chiamare flush() taglia anche la trama a metà.
Quali registri usa il sensore NPK?
Nei sensori tipo JXBS-3001 l'azoto è nel registro 0x001E, il fosforo in 0x001F e il potassio in 0x0020, letti con la funzione 03. Per leggerli tutti e tre insieme si invia la trama 01 03 00 1E 00 03 65 CD. Nei sensori 7 in 1 la mappa è diversa, quindi controlla il manuale del tuo sensore.
Si può usare il sensore NPK con ESP32?
Sì. Bastano la UART2 dell'ESP32 (GPIO 16 e 17) e un pin di direzione. Poiché l'ESP32 lavora a 3,3 V, la soluzione più sicura è un MAX3485 a 3,3 V o un modulo RS485 a direzione automatica al posto del MAX485. Così puoi inviare i valori via Wi-Fi allo smartphone o al cloud.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
Stazione di irrigazione intelligente
Un giardiniere che annaffia le tue piante da solo, così non si seccano mentre sei in vacanza.

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…

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.

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.

Server web asincrono ESP32 (con indicazione dell'IP sul display LCD)
In questo progetto trasformiamo l'ESP32 in un server web asincrono che potrete controllare dal vostro telefono o computer collegato alla stessa rete Wi-Fi. Grazie alla libreria ESPAsyncWebServer, il server è in grado di elaborare più richieste contemporaneamente (a differenza del classico WebServer.h, che si blocca su una singola richiesta).

Connessione Wi-Fi STA con ESP32 (con display LCD)
In questo progetto colleghiamo l'ESP32 alla rete Wi-Fi domestica in modalità Station (STA) in modo sicuro e tollerante agli errori. Separiamo SSID e password in un file secrets.h per impedire fughe su Git, impostiamo un meccanismo di riconnessione automatica e visualizziamo il livello del segnale RSSI e l'indirizzo IP su un display LCD I2C. Il LED interno funge da indicatore di stato.

Comunicazione unidirezionale tra 2 Arduino
Fai parlare due Arduino con un solo filo: premi il pulsante sull'uno e il LED dell'altro si accende, premi di nuovo e si spegne.
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

