Bauteile · 9 Min. Lesezeit

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.

MerkmalTypischer Wert
MesswerteStickstoff (N), Phosphor (P), Kalium (K)
Messbereich0–1999 mg/kg (mg/kg = ppm)
Auflösung1 mg/kg
Angegebene Genauigkeit±2 % FS (nur unter den Kalibrierbedingungen des Herstellers)
VersorgungJe nach Modell 5–30 V oder 9–24 V DC; 12 V passt für beide
SchnittstelleRS485, Modbus RTU, 9600 Baud, 8N1 (manche Modelle 4800)
Standardadresse0x01
AntwortzeitUnter 1 Sekunde
Gehäuse und SpitzenIP68, 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 SensorsFunktionAnschluss
BraunVersorgung ++ des 12-V-Netzteils
SchwarzVersorgung -- des 12-V-Netzteils und GND des Arduino (gemeinsam)
GelbRS485 A (+)A am MAX485
BlauRS485 B (-)B am MAX485
MAX485-PinArduino UnoESP32 (MAX3485)Raspberry Pi Pico (MAX3485)
VCC5V3V33V3(OUT)
GNDGNDGNDGND
RO (Empfängerausgang)D2GPIO 16 (RX2)GP1 (UART0 RX)
DI (Sendereingang)D3GPIO 17 (TX2)GP0 (UART0 TX)
DE und RE (verbunden)D7GPIO 4GP2
A und BGelbe und blaue Ader des SensorsGleichGleich
Die Aderfarben können je nach Hersteller abweichen; prüfe vor dem Anschließen immer das Etikett oder das Datenblatt des Sensors. Legst du die 12 V versehentlich an VCC oder an A/B des MAX485, ist das Modul sofort zerstört. Vertauschte A- und B-Adern schaden dagegen nichts, der Sensor antwortet nur nicht. Bekommst du keine Antwort, tausche als Erstes diese beiden Adern.

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.

ByteWert (hex)Bedeutung
101Adresse des Sensors
203Funktion: Register lesen
3–400 1EStartregister (Stickstoff)
5–600 03Anzahl der Register (N, P, K)
7–865 CDCRC16-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.

RegisterWertEinheitFrame für Einzelabfrage
0x001EStickstoff (N)mg/kg01 03 00 1E 00 01 E4 0C
0x001FPhosphor (P)mg/kg01 03 00 1F 00 01 B5 CC
0x0020Kalium (K)mg/kg01 03 00 20 00 01 85 C0
0x001E–0x0020N, P und K zusammenmg/kg01 03 00 1E 00 03 65 CD
Bei 7-in-1-Sensoren (Feuchte, Temperatur, EC, pH, N, P, K) ist die Registerbelegung anders und unterscheidet sich je nach Hersteller; bei manchen Modellen liegt die Feuchte bei 0x0000 und NPK bei 0x0004–0x0006. Prüfe die Tabelle im Datenblatt deines Sensors und passe REG_N im Code an. Kennst du Adresse oder Baudrate nicht, spart dir eine kleine Schleife, die die Adressen 1 bis 5 mit 4800 und 9600 Baud durchprobiert, viel Zeit.

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.

C++ (Arduino IDE)
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}
TeilWas es tut
crc16()Berechnet die Modbus-CRC16 mit dem Polynom 0xA001
DE/RE auf HIGH, dann LOWSchaltet den MAX485 auf Senden und nach dem Frame zurück auf Empfangen
need = 5 + 2 × countErwartete Antwortlänge: 3 Byte Kopf, die Daten und 2 Byte CRC
Timeout von 500 msDas Programm hängt nicht, wenn der Sensor schweigt
Prüfung von CRC und AdresseVerwirft durch Störungen beschädigte Antworten oder solche anderer Geräte
Der häufigste Fehler: DE/RE wird auf LOW gesetzt, bevor das letzte Byte des Frames gesendet ist; der Sensor erhält dann einen unvollständigen Frame und antwortet nie. SoftwareSerial kehrt erst zurück, wenn jedes Byte komplett gesendet ist, beim Uno gibt es also kein Problem. Bei Boards mit Hardware-UART (Mega, ESP32) rufst du vor dem Umschalten des Richtungspins immer flush() auf; diese Funktion wartet, bis das letzte Byte wirklich draußen ist.

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ährstoffNiedrigMittelHochHinweis
Stickstoff (Nitrat-N)Unter 10 mg/kg10–25 mg/kgÜber 25 mg/kgBei Mais ist 25 mg/kg eine häufig genutzte Schwelle; ändert sich schnell durch Bewässerung und Regen
Phosphor (Olsen-P)Unter 10 mg/kg10–20 mg/kgÜber 20 mg/kgBewegt sich langsam im Boden und ändert sich über Monate
Kalium (austauschbares K)Unter 100 mg/kg100–200 mg/kgÜber 200 mg/kgIn 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.

  1. Nimm an 3–5 verschiedenen Stellen des Feldes Bodenproben und lass sie im Labor auf N, P und K untersuchen.
  2. 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.
  3. Nimm an jeder Stelle 3 Messungen und verwende den Mittelwert; eine einzelne Messung kann wegen eines Steins oder eines Lufteinschlusses täuschen.
  4. Bilde aus Laborwerten und Sensormittelwerten eine Zwei-Punkt-Gerade und füge sie als Korrektur in den Code ein.
  5. Wiederhole die Kalibrierung, wenn sich Bodenart oder Dünger ändern; eine Kontrollmessung zu Beginn jeder Saison reicht.
C++ (Arduino IDE)
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);
Am stärksten beeinflusst die Bodenfeuchte die Messwerte. Setzt du einen günstigen kapazitiven Bodenfeuchtesensor daneben und speicherst die NPK-Werte nur, wenn die Feuchte in einem bestimmten Bereich liegt, werden die Ergebnisse deutlich konsistenter. Um springende Werte zu glätten, nutze die Methoden aus dem Artikel Sensordaten filtern.

Feldüberwachung mit dem ESP32

ESP32-Entwicklungsboard
ESP32: Dank integriertem WLAN bringt er die NPK-Werte vom Feld aufs Handy; mit dem RS485-Modul ist er über UART2 verbunden.

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.

C++ (Arduino IDE)
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.

MicroPython
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.

Alle Projekte ansehen
Intelligente Bewässerungsstation
AR-83Fortgeschritten
Premium

Intelligente Bewässerungsstation

Ein Gärtner, der deine Pflanzen von selbst gießt, damit sie im Urlaub nicht vertrocknen.

5.0(42)
57
Temperatur und Luftfeuchtigkeit mit DHT11
AR-55Mittel

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…

4.7(47)
83
ESP32 Temperatur-Datenlogger (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Fortgeschritten
Premium

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.

4.7(7)
12
ESP32 DHT22 Temperatur und Luftfeuchtigkeit (mit LCD-Display)
ES-15Mittel

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.

4.8(38)
57
ESP32 Async-Webserver (mit IP-Anzeige auf dem LCD)
ES-27Fortgeschritten

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.

4.8(16)
26
ESP32-WLAN-STA-Verbindung (mit LCD-Display)
ES-25Fortgeschritten

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.

4.4(21)
38
Einweg-Kommunikation zwischen 2 Arduinos
AR-57Mittel
Premium

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.

4.4(37)
50