Composants · 11 min de lecture

Capteur NPK Arduino : azote, phosphore et potassium en RS485

Capteur NPK avec Arduino : câblage MAX485 et alimentation 12 V, trame Modbus, tableau azote, phosphore, potassium, limites d'étalonnage et code ESP32.

Un capteur NPK relié à un Arduino te permet de suivre l'azote (N), le phosphore (P) et le potassium (K) du sol en mg/kg ; c'est une sonde de sol industrielle qui communique sur une ligne RS485 avec le protocole Modbus RTU. Pour le brancher à l'Arduino, tu intercales un MAX485, tu alimentes le capteur en 12 V et tu envoies une trame de requête de 8 octets ; en quelques millisecondes, le capteur renvoie les trois valeurs. C'est l'un des capteurs les plus recherchés pour suivre les besoins en engrais en serre, au potager et sur de petites parcelles.

Dans ce guide, tu verras étape par étape comment relier les fils du capteur au module MAX485 et à l'Arduino, ce que signifie chaque octet de la trame Modbus, comment se calcule le CRC, comment transformer la réponse en nombres et comment surveiller une parcelle en Wi-Fi avec un ESP32. Nous aborderons aussi un point que la plupart des vendeurs passent sous silence : les limites de mesure des capteurs NPK bon marché et la façon d'étalonner leurs valeurs.

Qu'est-ce qu'un capteur NPK de sol et comment fonctionne-t-il ?

La plupart des capteurs NPK du marché (JXBS-3001-NPK-RS et ses clones) sont des sondes à trois pointes en acier inoxydable, étanches IP68, avec un corps en époxy. Une fois les pointes entièrement enfoncées, le capteur mesure les propriétés électriques de la solution du sol et les convertit en estimations d'azote, de phosphore et de potassium grâce aux formules de son firmware. Il n'a pas de sortie analogique : les valeurs sont envoyées uniquement en numérique sur RS485, et seulement quand on les demande. C'est pourquoi on utilise le port série de l'Arduino et non ses broches analogiques. Tu verras en détail dans la partie étalonnage pourquoi ce capteur n'est pas un instrument de laboratoire.

CaractéristiqueValeur typique
Valeurs mesuréesAzote (N), phosphore (P), potassium (K)
Plage de mesure0–1999 mg/kg (mg/kg = ppm)
Résolution1 mg/kg
Précision annoncée±2 % PE (seulement dans les conditions d'étalonnage du fabricant)
AlimentationSelon le modèle, 5–30 V ou 9–24 V DC ; 12 V convient aux deux
CommunicationRS485, Modbus RTU, 9600 bauds, 8N1 (4800 sur certains modèles)
Adresse par défaut0x01
Temps de réponseMoins d'une seconde
Corps et pointesIP68, acier inoxydable 316

Pourquoi faut-il du RS485 et un MAX485 ?

Le RS485 est une norme de communication qui transporte les données sous forme de différence de tension entre deux fils (A et B). Cette méthode résiste très bien aux parasites et fonctionne même avec plus de 100 mètres de câble au champ ; jusqu'à 32 appareils peuvent partager une même ligne. Le port série de l'Arduino, lui, parle en niveaux TTL (0 et 5 V). Le module MAX485 fait la traduction entre les deux : il convertit les données de la broche TX de l'Arduino en différence A/B, et la différence A/B venant du capteur en signal compréhensible par la broche RX. Le RS485 est semi-duplex : à un instant donné, on parle ou on écoute ; les broches DE et RE du module choisissent le sens. Les bases de la liaison série sont dans le guide communication série UART.

Câblage du capteur NPK : couleurs des fils et MAX485

Fil du capteurFonctionSe relie à
MarronAlimentation ++ de l'alimentation 12 V
NoirAlimentation -- de l'alimentation 12 V et GND de l'Arduino (commun)
JauneRS485 A (+)A du MAX485
BleuRS485 B (-)B du MAX485
Broche du MAX485Arduino UnoESP32 (MAX3485)Raspberry Pi Pico (MAX3485)
VCC5V3V33V3(OUT)
GNDGNDGNDGND
RO (sortie du récepteur)D2GPIO 16 (RX2)GP1 (UART0 RX)
DI (entrée de l'émetteur)D3GPIO 17 (TX2)GP0 (UART0 TX)
DE et RE (reliées)D7GPIO 4GP2
A et BFils jaune et bleu du capteurIdemIdem
Les couleurs des fils peuvent varier selon le fabricant ; vérifie toujours l'étiquette ou la notice du capteur avant de brancher. Envoyer par erreur le 12 V sur le VCC du MAX485 ou sur ses bornes A/B le détruit instantanément. Inverser A et B, en revanche, n'abîme rien : le capteur ne répond simplement pas. Si tu n'obtiens aucune réponse, commence par intervertir ces deux fils.

Alimente le capteur avec un bloc secteur 12 V. L'Arduino peut fonctionner sur l'USB ou sur la même alimentation abaissée à 5 V par un convertisseur abaisseur LM2596. Dans tous les cas, le moins de l'alimentation doit être relié au GND de l'Arduino : même si le RS485 est différentiel, la plage de tension acceptée par le récepteur est limitée par rapport à la masse commune. Avec quelques mètres de câble, aucune résistance de terminaison n'est nécessaire ; au-delà de 50 mètres, une résistance de 120 Ω à chaque extrémité évite les réflexions. Beaucoup de modules MAX485 l'ont déjà soudée. Sur de longues distances, utilise une paire torsadée pour A et B.

La trame de requête Modbus : qu'envoie-t-on au capteur ?

En Modbus RTU, c'est toujours le maître (l'Arduino) qui lance l'échange ; le capteur ne répond que lorsqu'on l'interroge. Pour lire des valeurs, on utilise la fonction 03 (Read Holding Registers). Sur les capteurs NPK de type JXBS, l'azote se trouve dans le registre 0x001E, le phosphore dans 0x001F et le potassium dans 0x0020 ; comme ils se suivent, une seule requête suffit pour lire les trois. Cette trame de 8 octets demande exactement cela : 01 03 00 1E 00 03 65 CD.

OctetValeur (hex)Signification
101Adresse du capteur
203Fonction : lecture de registres
3–400 1ERegistre de départ (azote)
5–600 03Nombre de registres à lire (N, P, K)
7–865 CDCRC16, octet de poids faible en premier

La réponse du capteur fait 11 octets : adresse (01), fonction (03), nombre d'octets de données (06), trois valeurs de deux octets chacune et un CRC sur deux octets. Par exemple, dans la réponse 01 03 06 00 20 00 0F 00 6E 11 5D, l'azote vaut 0x0020 = 32 mg/kg, le phosphore 0x000F = 15 mg/kg et le potassium 0x006E = 110 mg/kg. Pour chaque valeur, l'octet de poids fort arrive en premier : valeur = octet fort × 256 + octet faible. Pour le CRC, c'est l'inverse, l'octet faible d'abord ; ce petit détail est la confusion la plus fréquente en Modbus.

RegistreValeurUnitéTrame de lecture seule
0x001EAzote (N)mg/kg01 03 00 1E 00 01 E4 0C
0x001FPhosphore (P)mg/kg01 03 00 1F 00 01 B5 CC
0x0020Potassium (K)mg/kg01 03 00 20 00 01 85 C0
0x001E–0x0020N, P et K ensemblemg/kg01 03 00 1E 00 03 65 CD
Sur les capteurs 7 en 1 (humidité, température, CE, pH, N, P, K), la carte des registres est différente et varie d'un fabricant à l'autre ; sur certains modèles, l'humidité est en 0x0000 et le NPK en 0x0004–0x0006. Vérifie le tableau de la notice de ton capteur et adapte REG_N dans le code. Si tu ne connais pas l'adresse ou la vitesse, une petite boucle qui essaie les adresses 1 à 5 à 4800 et 9600 bauds te fera gagner beaucoup de temps.

Code Arduino Uno : lire les valeurs N, P et K

Le code ne demande aucune bibliothèque supplémentaire ; il utilise SoftwareSerial, fourni avec l'Arduino IDE. Il calcule le CRC à chaque requête, vérifie l'adresse, la fonction, la longueur et le CRC de la réponse, puis affiche les valeurs valides dans le moniteur série. Ouvre le moniteur série à 9600 bauds ; si le câblage est bon, tu verras N, P et K toutes les deux secondes.

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}
PartieRôle
crc16()Calcule le CRC16 Modbus avec le polynôme 0xA001
DE/RE à HIGH, puis LOWMet le MAX485 en émission, puis le repasse en écoute une fois la trame partie
need = 5 + 2 × countLongueur attendue de la réponse : 3 octets d'en-tête, les données et 2 octets de CRC
Délai maximal de 500 msLe programme ne se bloque pas si le capteur reste muet
Contrôle du CRC et de l'adresseRejette les réponses abîmées par des parasites ou venant d'un autre appareil
L'erreur la plus fréquente consiste à passer DE/RE à LOW avant que le dernier octet de la trame soit parti ; le capteur reçoit alors une trame incomplète et ne répond jamais. SoftwareSerial ne rend la main qu'après avoir fini d'envoyer chaque octet, donc aucun souci sur l'Uno. Sur les cartes qui utilisent un port série matériel (Mega, ESP32), appelle toujours flush() avant de changer la broche de direction : cette fonction attend que le dernier octet soit vraiment sorti.

Interpréter les valeurs : tableau NPK

Le capteur donne un nombre en mg/kg, mais savoir s'il est bon ou mauvais pour tes plantes dépend du type de sol, de la culture et de la méthode d'analyse du laboratoire. Les plages ci-dessous sont des limites approximatives que l'on retrouve souvent dans les guides agronomiques, et seulement un point de départ. Ne décide pas de la dose d'engrais en comparant un capteur non étalonné à ce tableau ; sers-t'en plutôt pour voir dans quelle zone tombent tes mesures étalonnées.

ÉlémentFaibleMoyenÉlevéRemarque
Azote (N nitrique)Moins de 10 mg/kg10–25 mg/kgPlus de 25 mg/kgPour le maïs, 25 mg/kg est un seuil très utilisé ; varie vite avec l'arrosage et la pluie
Phosphore (P Olsen)Moins de 10 mg/kg10–20 mg/kgPlus de 20 mg/kgBouge lentement dans le sol et évolue sur plusieurs mois
Potassium (K échangeable)Moins de 100 mg/kg100–200 mg/kgPlus de 200 mg/kgDes valeurs plus élevées sont normales en sol argileux

Limites de l'étalonnage : ce capteur mesure-t-il vraiment le NPK ?

Pour être honnête, les capteurs NPK RS485 bon marché ne mesurent pas séparément l'azote, le phosphore et le potassium par voie chimique. Ils ne contiennent aucun élément sélectif d'ions ; ce qu'ils mesurent réellement, c'est la conductivité (CE) de la solution du sol, qu'ils répartissent en trois nombres avec des coefficients fixes. C'est pourquoi les trois valeurs montent et descendent souvent ensemble, augmentent quand le sol est mouillé, et que le capteur affiche un NPK élevé même plongé dans de l'eau salée. Cela ne le rend pas inutile : des mesures prises sur la même parcelle, à la même humidité et à la même profondeur montrent de façon fiable l'évolution après un apport d'engrais et la tendance dans le temps. Mais en valeur absolue, elles ne remplacent pas une analyse de sol en laboratoire.

  1. Prélève des échantillons de sol à 3–5 endroits différents de la parcelle et fais-les analyser en laboratoire pour N, P et K.
  2. Mesure aux mêmes endroits avec le capteur, à la même humidité (par exemple un jour après l'arrosage), pointes entièrement enfoncées à 10–20 cm de profondeur.
  3. Fais 3 lectures à chaque endroit et garde la moyenne ; une seule lecture peut te tromper à cause d'un caillou ou d'une poche d'air.
  4. Trace une droite à deux points entre les résultats du laboratoire et les moyennes du capteur, puis ajoute-la au code comme correction.
  5. Refais l'étalonnage si le type de sol ou d'engrais change ; une mesure de contrôle en début de saison suffit.
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);
C'est l'humidité du sol qui influence le plus les mesures. Si tu places à côté un capteur d'humidité du sol capacitif bon marché et que tu n'enregistres le NPK que lorsque l'humidité est dans une certaine plage, les résultats deviennent bien plus cohérents. Pour lisser les lectures qui sautent, utilise les méthodes de filtrage des données de capteur.

Surveillance de la parcelle avec un ESP32

Carte de développement ESP32
ESP32 : grâce à son Wi-Fi intégré, il transmet les valeurs NPK de la parcelle à ton téléphone ; il se relie au module RS485 par l'UART2.

Avec un ESP32, tu peux suivre les mesures sur ton téléphone en Wi-Fi. Comme l'ESP32 fonctionne en 3,3 V, utilise un MAX3485 ou un module RS485 à direction automatique à la place du MAX485 en 5 V. Si tu n'as qu'un MAX485, alimente-le en 5 V et ramène sa sortie RO à 3,3 V avec un pont diviseur. Le code ci-dessous fait une mesure par minute et affiche les dernières valeurs sur une page web et à l'adresse /json ; ce JSON se transfère facilement vers un tableur ou un système domotique.

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}

S'il n'y a pas d'électricité sur la parcelle, il faudra une batterie et un petit panneau solaire. Comme le capteur consomme même quand il ne mesure pas, n'allume la ligne 12 V qu'au moment de la mesure grâce à un MOSFET ou un relais, et mets l'ESP32 en deep sleep entre deux lectures. Ainsi, une station qui mesure toutes les 30 minutes tient plusieurs jours sur une petite batterie lithium. Après avoir alimenté le capteur, attends quelques secondes avant de mesurer. Pour les parcelles éloignées hors de portée du Wi-Fi, un module LoRa offre plusieurs kilomètres de portée ; l'autonomie de la batterie s'estime avec le calculateur d'autonomie de batterie.

Code MicroPython pour le Raspberry Pi Pico

Sur la Pico, la même trame part par l'UART. En MicroPython, une écriture UART dépose les données dans un tampon et rend la main tout de suite ; le code attend donc le temps nécessaire pour que la trame quitte la ligne (environ 8,3 ms pour 8 octets à 9600 bauds) avant de repasser la broche de direction en réception. Alimente le module MAX3485 par la broche 3V3(OUT) de la 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)

Erreurs fréquentes et solutions

  • Aucune réponse : A et B inversés, pas de 12 V sur le capteur, masses non communes ou mauvaise vitesse ; intervertis d'abord A et B, puis essaie 4800 bauds.
  • Toujours 0 : les pointes sont à l'air ou dans une terre complètement sèche ; enfonce entièrement le capteur dans un sol humide, sans poche d'air entre les pointes.
  • Erreur de CRC : le câble est long et parasité, ou DE/RE bascule trop tôt ; utilise une paire torsadée et vérifie que flush() est bien appelé sur l'ESP32.
  • Valeurs de 65535 ou absurdement grandes : tu lis le mauvais registre ; vérifie la carte des registres dans la notice de ton capteur.
  • Les valeurs s'envolent après l'arrosage : c'est normal, le capteur est sensible à la conductivité ; mesure toujours à une humidité comparable.
  • Le programme se fige pendant la lecture : la boucle de lecture n'a pas de délai maximal ; ajoute-en un de 500 ms comme dans le code.

Idées de projets avec le capteur NPK

  • Serre connectée : suis le NPK, l'humidité et la température sur un seul tableau de bord ; détails dans le projet de serre connectée.
  • Carnet de fertilisation : enregistre dans un tableur l'évolution du NPK après chaque apport ; la méthode ESP32 avec Google Sheets t'y aidera.
  • Contrôle de l'eau d'arrosage : compare les mesures du sol avec la conductivité de ton eau d'arrosage grâce à un capteur TDS.
  • Arrosage automatique : arrose avec une mini pompe à eau quand l'humidité baisse, et choisis le moment de fertiliser selon la tendance du NPK.
  • Station pour le jardin de l'école : compare les valeurs de plusieurs parcelles et transforme le tout en projet pour une fête de la science.

Le capteur NPK est aussi une excellente occasion d'apprendre la communication industrielle RS485 et le protocole Modbus ; la logique de trame et de CRC vue ici est la même sur des centaines d'appareils, des compteurs d'énergie aux stations météo. Ne fais pas aveuglément confiance aux chiffres : étalonne et suis les tendances. Dans l'application BlueGrays, le projet Station d'arrosage intelligente te montre pas à pas un circuit avec capteur d'humidité et pompe, auquel tu peux ajouter le capteur NPK.

Questions fréquentes

Comment brancher un capteur NPK sur un Arduino ?

Le capteur a une sortie RS485, il faut donc un module MAX485 entre les deux. Les fils jaune (A) et bleu (B) du capteur vont sur A et B du MAX485, les broches RO et DI du MAX485 sur D2 et D3 de l'Arduino, et DE et RE reliées sur D7. Le capteur est alimenté en 12 V et le GND de l'alimentation doit être commun avec celui de l'Arduino.

Quelle tension faut-il pour un capteur NPK ?

Selon le modèle, il fonctionne entre 5 et 30 V ou entre 9 et 24 V DC ; 12 V est le choix sûr qui convient aux deux types. Même sur les modèles annoncés en 5 V, le 12 V donne des mesures plus stables. Le module MAX485, lui, s'alimente à la même tension que l'Arduino, soit 5 V.

Un capteur NPK est-il précis ?

Les capteurs NPK RS485 bon marché ne mesurent pas séparément l'azote, le phosphore et le potassium par voie chimique : ils mesurent la conductivité et estiment les valeurs par des formules. Leurs valeurs absolues ne remplacent donc pas une analyse en laboratoire, mais des mesures faites sur la même parcelle à la même humidité montrent bien les évolutions et les tendances. Un étalonnage à deux points avec des résultats de laboratoire améliore nettement la précision.

Pourquoi mon capteur NPK ne répond-il pas ?

Les causes les plus courantes sont A et B inversés, l'absence de 12 V au capteur, des masses non communes et une mauvaise vitesse. Intervertis d'abord A et B, puis essaie 4800 bauds au lieu de 9600. Sur les cartes à port série matériel, changer DE/RE sans appeler flush() coupe aussi la trame en deux.

Quels registres utilise le capteur NPK ?

Sur les capteurs de type JXBS-3001, l'azote est dans le registre 0x001E, le phosphore dans 0x001F et le potassium dans 0x0020, lus avec la fonction 03. Pour lire les trois d'un coup, on envoie la trame 01 03 00 1E 00 03 65 CD. Sur les capteurs 7 en 1, la carte est différente : vérifie la notice de ton capteur.

Peut-on utiliser un capteur NPK avec un ESP32 ?

Oui. L'UART2 de l'ESP32 (GPIO 16 et 17) et une broche de direction suffisent. Comme l'ESP32 fonctionne en 3,3 V, le plus sûr est d'utiliser un MAX3485 en 3,3 V ou un module RS485 à direction automatique à la place du MAX485. Tu peux ensuite envoyer les valeurs en Wi-Fi vers ton téléphone ou le cloud.

Voir tous les projets
Station d'irrigation intelligente
AR-83Avancé
Premium

Station d'irrigation intelligente

Un jardinier qui arrose tes plantes tout seul pour qu'elles ne sèchent pas pendant tes vacances.

5.0(42)
57
Température et humidité avec DHT11
AR-55Intermédiaire

Température et humidité avec DHT11

Quelle température fait-il dans ta chambre, et l'air est-il humide ou sec ? Le capteur DHT11 mesure la température et l'humidité, et l'Arduino affiche les valeurs sur un écran LCD à deux lignes…

4.7(47)
83
Enregistreur de Température ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Avancé
Premium

Enregistreur de Température ESP32 (DHT22 + DS1307 RTC + microSD + OLED)

Construis avec l'ESP32 un enregistreur de température et d'humidité horodaté ! Un capteur DHT22 mesure la température et l'humidité une fois par minute, et chaque mesure est enregistrée sur une carte microSD au format CSV avec l'heure réelle du module RTC DS1307. L'écran OLED affiche en direct, en grands caractères, la dernière température, l'humidité, l'horodatage et le nombre d'enregistrements.

4.7(7)
12
ESP32 DHT22 Température et humidité (avec écran LCD)
ES-15Intermédiaire

ESP32 DHT22 Température et humidité (avec écran LCD)

Il s'agit d'un projet permettant de mesurer la température ambiante et le taux d'humidité à l'aide d'un capteur DHT22 et d'afficher ces données en temps réel sur un écran LCD I2C 16x2. Les données du capteur sont lues à l'aide du protocole one-wire grâce à la bibliothèque Adafruit DHT. Ce projet constitue la base des stations météo IoT, de la domotique ou des systèmes de surveillance de l'environnement dans les serres.

4.8(38)
57
Serveur Web asynchrone ESP32 (avec affichage de l'adresse IP sur l'écran LCD)
ES-27Avancé

Serveur Web asynchrone ESP32 (avec affichage de l'adresse IP sur l'écran LCD)

On transforme l'ESP32 en serveur web asynchrone que tu pilotes depuis ton téléphone ou ton ordinateur sur le même réseau Wi-Fi. Grâce à la bibliothèque ESPAsyncWebServer, le serveur traite plusieurs requêtes à la fois (il ne bloque pas sur une seule requête comme le WebServer.h classique). Ouvre l'adresse IP de l'ESP32 dans le navigateur et allume ou éteins la LED sur GPIO 5 avec les boutons ON/OFF (adresses /on et /off).

4.8(16)
26
Connexion Wi-Fi STA ESP32 (avec écran LCD)
ES-25Avancé

Connexion Wi-Fi STA ESP32 (avec écran LCD)

Dans ce projet, nous connectons l'ESP32 au réseau Wi-Fi domestique en mode Station (STA) de manière sécurisée et tolérante aux pannes. Nous isolons SSID/mot de passe dans un fichier secrets.h pour empêcher leur fuite sur Git, mettons en place une reconnexion automatique, et affichons le niveau RSSI et l'adresse IP sur un écran LCD I2C. La LED intégrée sert d'indicateur d'état.

4.4(21)
38
Communication unidirectionnelle entre 2 Arduino
AR-57Intermédiaire
Premium

Communication unidirectionnelle entre 2 Arduino

Tu fais discuter deux Arduino par un seul fil : appuie sur le bouton de l'un et la LED de l'autre s'allume, appuie encore et elle s'éteint.

4.4(37)
50