NPK Sensor Arduino: Stickstoff, Phosphor und Kalium per RS485
NPK Sensor am Arduino: Anschluss mit MAX485 und 12 V, Modbus-Anfrage, Wertetabelle für Stickstoff, Phosphor und Kalium, Kalibriergrenzen und ESP32-Code.
Mit einem NPK Sensor am Arduino überwachst du Stickstoff (N), Phosphor (P) und Kalium (K) im Boden in mg/kg; es handelt sich um einen industriellen Bodensensor, der über eine RS485-Leitung per Modbus RTU kommuniziert. Für den Anschluss setzt du einen MAX485-Wandler dazwischen, versorgst den Sensor mit 12 V und schickst einen 8-Byte-Anfrageframe; nach wenigen Millisekunden antwortet der Sensor mit allen drei Werten. Er gehört zu den gefragtesten Sensoren, um den Düngebedarf im Gewächshaus, im Garten und auf kleinen Feldern zu verfolgen.
In dieser Anleitung siehst du Schritt für Schritt, wie du die Adern des Sensors an das MAX485-Modul und den Arduino anschließt, was jedes Byte des Modbus-Frames bedeutet, wie die CRC berechnet wird, wie du die Antwort in Zahlen umwandelst und wie du ein Feld mit dem ESP32 per WLAN überwachst. Außerdem geht es um etwas, das die meisten Händler verschweigen: die Messgrenzen günstiger NPK-Sensoren und wie du ihre Werte kalibrieren solltest.
Was ist ein NPK-Bodensensor und wie funktioniert er?
Die meisten NPK-Sensoren auf dem Markt (JXBS-3001-NPK-RS und Nachbauten) sind Sonden mit drei Edelstahlspitzen, Schutzart IP68 und Epoxidgehäuse. Stecken die Spitzen vollständig im Boden, misst der Sensor die elektrischen Eigenschaften der Bodenlösung und rechnet sie mit Formeln in seiner Firmware in Schätzwerte für Stickstoff, Phosphor und Kalium um. Einen Analogausgang gibt es nicht: Die Werte werden nur digital über RS485 gesendet und nur auf Anfrage. Deshalb nutzt du nicht die Analogpins des Arduino, sondern die serielle Schnittstelle. Warum dieser Sensor kein Laborgerät ist, erfährst du ausführlich im Abschnitt zur Kalibrierung.
| Merkmal | Typischer Wert |
|---|---|
| Messwerte | Stickstoff (N), Phosphor (P), Kalium (K) |
| Messbereich | 0–1999 mg/kg (mg/kg = ppm) |
| Auflösung | 1 mg/kg |
| Angegebene Genauigkeit | ±2 % FS (nur unter den Kalibrierbedingungen des Herstellers) |
| Versorgung | Je nach Modell 5–30 V oder 9–24 V DC; 12 V passt für beide |
| Schnittstelle | RS485, Modbus RTU, 9600 Baud, 8N1 (manche Modelle 4800) |
| Standardadresse | 0x01 |
| Antwortzeit | Unter 1 Sekunde |
| Gehäuse und Spitzen | IP68, Edelstahl 316 |
Warum RS485 und ein MAX485?
RS485 ist ein Übertragungsstandard, der Daten als Spannungsdifferenz zwischen zwei Adern (A und B) überträgt. Das macht ihn sehr störfest, und er funktioniert auf dem Feld auch mit Kabeln über 100 Meter; an einer Leitung können bis zu 32 Geräte hängen. Die serielle Schnittstelle des Arduino arbeitet dagegen mit TTL-Pegeln (0 und 5 V). Das Modul MAX485 übersetzt zwischen beiden Welten: Es wandelt die Daten vom TX-Pin des Arduino in die A/B-Differenz um und die A/B-Differenz vom Sensor in ein Signal für den RX-Pin. RS485 ist halbduplex, es wird also entweder gesendet oder empfangen; die Pins DE und RE des Moduls wählen die Richtung. Die Grundlagen der seriellen Kommunikation findest du im Artikel serielle Kommunikation per UART.
NPK Sensor anschließen: Aderfarben und MAX485
| Ader des Sensors | Funktion | Anschluss |
|---|---|---|
| Braun | Versorgung + | + des 12-V-Netzteils |
| Schwarz | Versorgung - | - des 12-V-Netzteils und GND des Arduino (gemeinsam) |
| Gelb | RS485 A (+) | A am MAX485 |
| Blau | RS485 B (-) | B am MAX485 |
| MAX485-Pin | Arduino Uno | ESP32 (MAX3485) | Raspberry Pi Pico (MAX3485) |
|---|---|---|---|
| VCC | 5V | 3V3 | 3V3(OUT) |
| GND | GND | GND | GND |
| RO (Empfängerausgang) | D2 | GPIO 16 (RX2) | GP1 (UART0 RX) |
| DI (Sendereingang) | D3 | GPIO 17 (TX2) | GP0 (UART0 TX) |
| DE und RE (verbunden) | D7 | GPIO 4 | GP2 |
| A und B | Gelbe und blaue Ader des Sensors | Gleich | Gleich |
Versorge den Sensor mit einem 12-V-Netzteil. Der Arduino kann über USB laufen oder aus demselben Netzteil über einen LM2596-Abwärtswandler mit 5 V versorgt werden. Egal wie: Der Minuspol des Netzteils muss mit GND des Arduino verbunden sein, denn auch wenn RS485 differenziell arbeitet, ist der zulässige Spannungsbereich des Empfängers auf die gemeinsame Masse bezogen. Bei Kabeln von wenigen Metern brauchst du keinen Abschlusswiderstand; bei Leitungen über 50 Meter verhindern 120 Ω an beiden Enden Reflexionen. Viele MAX485-Module haben ihn bereits bestückt. Für lange Strecken nimm verdrilltes Kabel (Twisted Pair) für A und B.
Der Modbus-Anfrageframe: Was schicken wir an den Sensor?
Bei Modbus RTU beginnt immer der Master (der Arduino) das Gespräch; der Sensor antwortet nur, wenn er gefragt wird. Zum Lesen dient die Funktion 03 (Read Holding Registers). Bei NPK-Sensoren vom Typ JXBS liegt Stickstoff im Register 0x001E, Phosphor in 0x001F und Kalium in 0x0020; da sie aufeinanderfolgen, lassen sich alle drei mit einer einzigen Anfrage lesen. Genau das fragt dieser 8-Byte-Frame ab: 01 03 00 1E 00 03 65 CD.
| Byte | Wert (hex) | Bedeutung |
|---|---|---|
| 1 | 01 | Adresse des Sensors |
| 2 | 03 | Funktion: Register lesen |
| 3–4 | 00 1E | Startregister (Stickstoff) |
| 5–6 | 00 03 | Anzahl der Register (N, P, K) |
| 7–8 | 65 CD | CRC16-Prüfsumme, niederwertiges Byte zuerst |
Die Antwort des Sensors ist 11 Byte lang: Adresse (01), Funktion (03), Anzahl der Datenbytes (06), drei Werte zu je zwei Byte und eine zwei Byte lange CRC. In der Antwort 01 03 06 00 20 00 0F 00 6E 11 5D bedeutet das zum Beispiel: Stickstoff 0x0020 = 32 mg/kg, Phosphor 0x000F = 15 mg/kg und Kalium 0x006E = 110 mg/kg. Bei jedem Wert kommt das höherwertige Byte zuerst: Wert = High-Byte × 256 + Low-Byte. Bei der CRC ist es umgekehrt, das Low-Byte kommt zuerst; dieses Detail wird bei Modbus am häufigsten verwechselt.
| Register | Wert | Einheit | Frame für Einzelabfrage |
|---|---|---|---|
| 0x001E | Stickstoff (N) | mg/kg | 01 03 00 1E 00 01 E4 0C |
| 0x001F | Phosphor (P) | mg/kg | 01 03 00 1F 00 01 B5 CC |
| 0x0020 | Kalium (K) | mg/kg | 01 03 00 20 00 01 85 C0 |
| 0x001E–0x0020 | N, P und K zusammen | mg/kg | 01 03 00 1E 00 03 65 CD |
Arduino-Uno-Code: N, P und K auslesen
Der Code braucht keine zusätzliche Bibliothek; er nutzt SoftwareSerial, das mit der Arduino IDE kommt. Er berechnet bei jeder Anfrage die CRC, prüft Adresse, Funktion, Länge und CRC der Antwort und gibt gültige Werte im Seriellen Monitor aus. Öffne den Seriellen Monitor mit 9600 Baud; bei korrekter Verdrahtung siehst du alle zwei Sekunden N, P und K.
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}| Teil | Was es tut |
|---|---|
| crc16() | Berechnet die Modbus-CRC16 mit dem Polynom 0xA001 |
| DE/RE auf HIGH, dann LOW | Schaltet den MAX485 auf Senden und nach dem Frame zurück auf Empfangen |
| need = 5 + 2 × count | Erwartete Antwortlänge: 3 Byte Kopf, die Daten und 2 Byte CRC |
| Timeout von 500 ms | Das Programm hängt nicht, wenn der Sensor schweigt |
| Prüfung von CRC und Adresse | Verwirft durch Störungen beschädigte Antworten oder solche anderer Geräte |
Werte einordnen: NPK-Wertetabelle
Der Sensor liefert eine Zahl in mg/kg, doch ob sie für deine Pflanzen gut oder schlecht ist, hängt von der Bodenart, der Kultur und der Analysemethode des Labors ab. Die Bereiche unten sind grobe Grenzen, wie sie oft in Ratgebern zur Düngung stehen, und nur ein Ausgangspunkt. Entscheide nicht anhand eines unkalibrierten Sensors und dieser Tabelle über die Düngermenge; nutze sie eher, um zu sehen, in welchem Bereich deine kalibrierten Messwerte liegen.
| Nährstoff | Niedrig | Mittel | Hoch | Hinweis |
|---|---|---|---|---|
| Stickstoff (Nitrat-N) | Unter 10 mg/kg | 10–25 mg/kg | Über 25 mg/kg | Bei Mais ist 25 mg/kg eine häufig genutzte Schwelle; ändert sich schnell durch Bewässerung und Regen |
| Phosphor (Olsen-P) | Unter 10 mg/kg | 10–20 mg/kg | Über 20 mg/kg | Bewegt sich langsam im Boden und ändert sich über Monate |
| Kalium (austauschbares K) | Unter 100 mg/kg | 100–200 mg/kg | Über 200 mg/kg | In Tonböden sind höhere Werte normal |
Grenzen der Kalibrierung: Misst der Sensor wirklich NPK?
Ehrlich gesagt messen günstige RS485-NPK-Sensoren Stickstoff, Phosphor und Kalium nicht getrennt auf chemischem Weg. Sie enthalten kein ionenselektives Element; tatsächlich messen sie die Leitfähigkeit (EC) der Bodenlösung und verteilen diesen Wert mit festen Faktoren auf drei Zahlen. Deshalb steigen und fallen die drei Werte meist gemeinsam, sie nehmen zu, wenn der Boden nass wird, und der Sensor zeigt sogar in Salzwasser hohe NPK-Werte. Nutzlos ist er dadurch nicht: Messungen auf demselben Feld, bei gleicher Feuchte und in gleicher Tiefe zeigen zuverlässig die Veränderung nach dem Düngen und den Trend über die Zeit. Als absoluter Wert ersetzen sie aber keine Bodenanalyse im Labor.
- Nimm an 3–5 verschiedenen Stellen des Feldes Bodenproben und lass sie im Labor auf N, P und K untersuchen.
- Miss an denselben Stellen bei gleicher Feuchte (zum Beispiel einen Tag nach dem Gießen) mit dem Sensor; stecke die Spitzen dabei vollständig 10–20 cm tief in den Boden.
- Nimm an jeder Stelle 3 Messungen und verwende den Mittelwert; eine einzelne Messung kann wegen eines Steins oder eines Lufteinschlusses täuschen.
- Bilde aus Laborwerten und Sensormittelwerten eine Zwei-Punkt-Gerade und füge sie als Korrektur in den Code ein.
- Wiederhole die Kalibrierung, wenn sich Bodenart oder Dünger ändern; eine Kontrollmessung zu Beginn jeder Saison reicht.
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);Feldüberwachung mit dem ESP32

Mit einem ESP32 verfolgst du die Messwerte per WLAN auf dem Handy. Da der ESP32 mit 3,3 V arbeitet, nimm statt des 5-V-MAX485 einen MAX3485 oder ein RS485-Modul mit automatischer Richtungsumschaltung. Hast du nur einen MAX485, versorge ihn mit 5 V und teile seinen RO-Ausgang mit einem Spannungsteiler auf 3,3 V herunter. Der folgende Code misst einmal pro Minute und zeigt die letzten Werte auf einer Webseite und unter /json an; dieses JSON lässt sich leicht in eine Tabelle oder eine Hausautomation übernehmen.
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}Gibt es auf dem Feld keinen Strom, brauchst du einen Akku und ein kleines Solarmodul. Da der Sensor auch ohne Messung Strom zieht, schalte die 12-V-Leitung mit einem MOSFET oder Relais nur während der Messung ein und lege den ESP32 zwischen den Messungen in den Deep Sleep. So läuft eine Station, die alle 30 Minuten misst, mit einem kleinen Lithium-Akku tagelang. Warte nach dem Einschalten des Sensors ein paar Sekunden, bevor du misst. Für entfernte Felder ohne WLAN bietet ein LoRa-Modul mehrere Kilometer Reichweite; die Akkulaufzeit schätzt du mit dem Akkulaufzeit-Rechner ab.
MicroPython-Code für den Raspberry Pi Pico
Auch beim Pico geht derselbe Frame über die UART hinaus. In MicroPython legt ein UART-Schreibbefehl die Daten in einen Puffer und kehrt sofort zurück; deshalb wartet der Code die Zeit ab, die der Frame auf der Leitung braucht (bei 9600 Baud etwa 8,3 ms für 8 Byte), bevor er den Richtungspin auf Empfang schaltet. Versorge das MAX3485-Modul aus dem Pin 3V3(OUT) des 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)Häufige Fehler und Lösungen
- Gar keine Antwort: A und B vertauscht, keine 12 V am Sensor, keine gemeinsame Masse oder falsche Baudrate; tausche zuerst A und B, dann probiere 4800 Baud.
- Es wird immer 0 gelesen: Die Spitzen stecken in der Luft oder in knochentrockener Erde; stecke den Sensor vollständig in feuchten Boden, ohne Luftspalte zwischen den Spitzen.
- CRC-Fehler: Das Kabel ist lang und gestört, oder DE/RE schaltet zu früh um; nimm verdrilltes Kabel und achte darauf, dass beim ESP32 flush() aufgerufen wird.
- Werte von 65535 oder unsinnig groß: Es wird das falsche Register gelesen; prüfe die Registerbelegung im Datenblatt deines Sensors.
- Werte schießen nach dem Gießen hoch: Das ist normal, denn der Sensor reagiert auf Leitfähigkeit; miss immer bei ähnlicher Feuchte.
- Das Programm friert beim Lesen ein: Die Leseschleife hat kein Timeout; ergänze wie im Code ein Timeout von 500 ms.
Projektideen mit dem NPK Sensor
- Smartes Gewächshaus: Behalte NPK, Feuchte und Temperatur auf einem Dashboard im Blick; Details im Projekt smartes Gewächshaus.
- Düngetagebuch: Speichere die NPK-Änderung nach jeder Düngung in einer Tabelle; dabei hilft die Methode ESP32 mit Google Sheets.
- Gießwasser prüfen: Vergleiche die Bodenwerte mit der Leitfähigkeit deines Gießwassers, gemessen mit einem TDS-Sensor.
- Automatische Bewässerung: Gieße mit einer Mini-Wasserpumpe, wenn die Feuchte sinkt, und plane das Düngen anhand des NPK-Trends.
- Station für den Schulgarten: Vergleiche die Werte verschiedener Beete und mach daraus ein Projekt für Jugend forscht oder den Technikunterricht.
Der NPK Sensor ist auch eine großartige Gelegenheit, industrielle RS485-Kommunikation und das Modbus-Protokoll zu lernen; die Frame- und CRC-Logik, die du hier kennengelernt hast, ist bei Hunderten Geräten gleich, vom Stromzähler bis zur Wetterstation. Vertrau den Zahlen nicht blind, sondern kalibriere und verfolge die Trends. In der BlueGrays-App zeigt dir das Projekt Intelligente Bewässerungsstation Schritt für Schritt eine Schaltung mit Feuchtesensor und Pumpe, die du um den NPK Sensor erweitern kannst.
Häufige Fragen
Wie schließe ich einen NPK Sensor an den Arduino an?
Der Sensor hat einen RS485-Ausgang, daher brauchst du ein MAX485-Modul dazwischen. Die gelbe (A) und die blaue (B) Ader des Sensors kommen an A und B des MAX485, dessen Pins RO und DI an D2 und D3 des Arduino und die verbundenen Pins DE und RE an D7. Der Sensor wird mit 12 V versorgt, und GND des Netzteils muss mit GND des Arduino verbunden sein.
Mit welcher Spannung läuft ein NPK Sensor?
Je nach Modell mit 5–30 V oder 9–24 V DC; 12 V ist die sichere Wahl, die zu beiden Typen passt. Selbst bei Modellen, die 5 V angeben, liefert 12 V stabilere Werte. Das MAX485-Modul wird dagegen mit derselben Spannung wie der Arduino versorgt, also mit 5 V.
Wie genau misst ein NPK Sensor?
Günstige RS485-NPK-Sensoren messen Stickstoff, Phosphor und Kalium nicht getrennt auf chemischem Weg, sondern messen die Leitfähigkeit und schätzen die Werte per Formel. Ihre absoluten Werte ersetzen daher keine Laboranalyse, doch Messungen auf demselben Feld bei gleicher Feuchte zeigen Veränderungen und Trends gut. Eine Zwei-Punkt-Kalibrierung mit Laborwerten verbessert die Genauigkeit deutlich.
Warum antwortet mein NPK Sensor nicht?
Die häufigsten Ursachen sind vertauschte A- und B-Adern, fehlende 12 V am Sensor, keine gemeinsame Masse und eine falsche Baudrate. Tausche zuerst A und B und probiere dann 4800 statt 9600 Baud. Bei Boards mit Hardware-UART schneidet ein Umschalten von DE/RE ohne flush() außerdem den Frame ab.
Welche Register nutzt der NPK Sensor?
Bei Sensoren vom Typ JXBS-3001 liegt Stickstoff im Register 0x001E, Phosphor in 0x001F und Kalium in 0x0020; gelesen wird mit Funktion 03. Um alle drei auf einmal zu lesen, sendest du den Frame 01 03 00 1E 00 03 65 CD. Bei 7-in-1-Sensoren ist die Belegung anders, schau also ins Datenblatt deines Sensors.
Kann ich den NPK Sensor mit dem ESP32 nutzen?
Ja. Die UART2 des ESP32 (GPIO 16 und 17) und ein Richtungspin genügen. Da der ESP32 mit 3,3 V arbeitet, ist ein MAX3485 für 3,3 V oder ein RS485-Modul mit automatischer Richtungsumschaltung die sicherste Wahl statt des MAX485. So schickst du die Werte per WLAN aufs Handy oder in die Cloud.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
Intelligente Bewässerungsstation
Ein Gärtner, der deine Pflanzen von selbst gießt, damit sie im Urlaub nicht vertrocknen.

Temperatur und Luftfeuchtigkeit mit DHT11
Wie warm ist dein Zimmer, und ist die Luft feucht oder trocken? Der DHT11-Sensor misst Temperatur und Luftfeuchtigkeit, und der Arduino schreibt die Werte auf ein zweizeiliges LCD und aktualisiert…

ESP32 Temperatur-Datenlogger (DHT22 + DS1307 RTC + microSD + OLED)
Bau mit dem ESP32 einen zeitgesteuerten Temperatur- und Feuchtigkeitslogger! Ein DHT22 misst einmal pro Minute Temperatur und Luftfeuchtigkeit; jeder Wert landet mit einem Zeitstempel des RTC-Moduls DS1307 im CSV-Format auf einer microSD-Karte. Das OLED zeigt live und in großer Schrift die letzte Temperatur, die Luftfeuchtigkeit, den Zeitstempel und die Zahl der Einträge.

ESP32 DHT22 Temperatur und Luftfeuchtigkeit (mit LCD-Display)
Bei diesem Projekt werden die Umgebungstemperatur und die Luftfeuchtigkeit mit einem DHT22-Sensor gemessen und in Echtzeit auf einem 16x2 I2C-LCD angezeigt. Mithilfe der Adafruit-DHT-Bibliothek werden die Daten über das One-Wire-Protokoll vom Sensor ausgelesen. Dieses Projekt bildet die Grundlage für IoT-Wetterstationen, Smart-Home-Automatisierung oder Umgebungsüberwachungssysteme in Gewächshäusern. Die Kommunikation mit dem DHT22 erfolgt über den GPIO-4-Pin des ESP32.

ESP32 Async-Webserver (mit IP-Anzeige auf dem LCD)
Wir machen den ESP32 zu einem asynchronen Webserver, den du per Handy oder Computer im selben WLAN steuerst. Dank der Bibliothek ESPAsyncWebServer verarbeitet der Server mehrere Anfragen gleichzeitig (er blockiert nicht wie das klassische WebServer.h bei einer einzigen Anfrage). Öffne im Browser die IP-Adresse des ESP32 und schalte mit den Tasten ON/OFF (Adressen /on und /off) die LED an GPIO 5 ein und aus.

ESP32-WLAN-STA-Verbindung (mit LCD-Display)
In diesem Projekt verbinden wir den ESP32 im Station-Modus (STA) sicher und fehlertolerant mit dem heimischen WLAN. Wir lagern SSID und Passwort in eine separate secrets.h-Datei aus, um Leaks zu Git zu verhindern, richten einen Auto-Reconnect-Mechanismus ein und zeigen RSSI-Signalpegel und IP-Adresse auf einem I2C-LCD-Display an. Die interne LED dient als Statusanzeige. Ein Verbindungsmanager auf Produktionsniveau.

Einweg-Kommunikation zwischen 2 Arduinos
Du bringst zwei Arduinos über ein einziges Kabel zum Reden: Drückst du den Knopf am einen, geht die LED am anderen an, drückst du noch einmal, geht sie aus.
Weitere Artikel
BlueGrays-App
Diese Schaltung Schritt für Schritt auf dem Handy nachbauen
Schaltplan, Code und Teileliste auf einem Bildschirm. Über 500 Arduino-, ESP32- und Pico-Projekte zum Nachbauen.
Mit dem Handy scannen
Richte die Kamera auf den Code, dann öffnet sich der App-Store deines Handys.
oder im Store öffnen

