Sensor NPK Arduino: leer nitrógeno, fósforo y potasio por RS485
Sensor NPK con Arduino: conexión con MAX485 y fuente de 12 V, trama Modbus, tabla de nitrógeno, fósforo y potasio, límites de calibración y código ESP32.
El sensor NPK con Arduino te permite monitorear el nitrógeno (N), el fósforo (P) y el potasio (K) del suelo en mg/kg; es un sensor de suelo industrial que se comunica por una línea RS485 con el protocolo Modbus RTU. Para conectarlo al Arduino pones en medio un módulo MAX485, lo alimentas con una fuente de 12 V y le envías una trama de petición de 8 bytes; en unos milisegundos el sensor responde con los tres valores. Es uno de los sensores más buscados para vigilar la fertilización en invernaderos, huertos y parcelas pequeñas.
En esta guía verás paso a paso cómo conectar los cables del sensor al módulo MAX485 y al Arduino, qué significa cada byte de la trama Modbus, cómo se calcula el CRC, cómo convertir la respuesta en números y cómo monitorear tu cultivo por Wi-Fi con un ESP32. También tocaremos un tema que la mayoría de los vendedores no menciona: los límites de medición de los sensores NPK económicos y cómo calibrar sus valores.
¿Qué es el sensor NPK de suelo y cómo funciona?
La mayoría de los sensores NPK del mercado (JXBS-3001-NPK-RS y similares) son sondas con tres puntas de acero inoxidable, protección IP68 y cuerpo de epoxi. Cuando las puntas quedan bien enterradas, el sensor mide las propiedades eléctricas de la solución del suelo y, con las fórmulas de su firmware, las convierte en una estimación de nitrógeno, fósforo y potasio. No tiene salida analógica: los valores se envían solo de forma digital por RS485 y únicamente cuando se le preguntan. Por eso no se usan los pines analógicos del Arduino sino su puerto serie. En la sección de calibración verás con detalle por qué este sensor no es un equipo de laboratorio.
| Característica | Valor típico |
|---|---|
| Valores medidos | Nitrógeno (N), fósforo (P), potasio (K) |
| Rango de medición | 0–1999 mg/kg (mg/kg = ppm) |
| Resolución | 1 mg/kg |
| Precisión declarada | ±2 % FS (solo en las condiciones de calibración del fabricante) |
| Alimentación | Según el modelo, 5–30 V o 9–24 V DC; 12 V sirve para ambos |
| Comunicación | RS485, Modbus RTU, 9600 baudios, 8N1 (algunos modelos 4800) |
| Dirección por defecto | 0x01 |
| Tiempo de respuesta | Menos de 1 segundo |
| Cuerpo y puntas | IP68, acero inoxidable 316 |
¿Por qué hacen falta RS485 y el MAX485?
RS485 es un estándar de comunicación que transmite datos mediante la diferencia de voltaje entre dos hilos (A y B). Este método resiste muy bien el ruido y funciona incluso con cables de más de 100 metros en el campo; en una misma línea se pueden conectar hasta 32 equipos. El puerto serie del Arduino, en cambio, habla a nivel TTL (0 y 5 V). El MAX485 traduce entre los dos mundos: convierte lo que sale por el TX del Arduino en la diferencia A/B, y la diferencia A/B que llega del sensor en una señal apta para el RX. RS485 es semidúplex, es decir, en un momento dado se habla o se escucha; los pines DE y RE del módulo eligen el sentido. Lo básico de la comunicación serie está en la guía de comunicación serie UART.
Conexión del sensor NPK: colores de cables y MAX485
| Cable del sensor | Función | Se conecta a |
|---|---|---|
| Café (marrón) | Alimentación + | + de la fuente de 12 V |
| Negro | Alimentación - | - de la fuente de 12 V y GND del Arduino (común) |
| Amarillo | RS485 A (+) | A del MAX485 |
| Azul | 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 (salida del receptor) | D2 | GPIO 16 (RX2) | GP1 (UART0 RX) |
| DI (entrada del transmisor) | D3 | GPIO 17 (TX2) | GP0 (UART0 TX) |
| DE y RE (unidos) | D7 | GPIO 4 | GP2 |
| A y B | Cables amarillo y azul del sensor | Igual | Igual |
Alimenta el sensor con una fuente de 12 V. El Arduino puede ir por USB o tomar la misma fuente bajada a 5 V con un regulador reductor LM2596. Elijas lo que elijas, el negativo de la fuente debe unirse con el GND del Arduino: aunque RS485 sea diferencial, el rango de voltaje que acepta el receptor está limitado respecto a la tierra común. Con cables de pocos metros no hace falta resistencia de terminación; en líneas de más de 50 metros, poner 120 Ω en los dos extremos evita reflexiones. Muchos módulos MAX485 ya la traen soldada. En tramos largos usa cable de par trenzado para A y B, como el de red UTP.
Trama de petición Modbus: ¿qué le enviamos al sensor?
En Modbus RTU la conversación siempre la empieza el maestro (el Arduino); el sensor solo responde cuando se le pregunta. Para leer valores se usa la función 03 (Read Holding Registers). En los sensores NPK tipo JXBS, el nitrógeno está en el registro 0x001E, el fósforo en 0x001F y el potasio en 0x0020; como son consecutivos, se pueden leer juntos con una sola petición. Esta trama de 8 bytes pide exactamente eso: 01 03 00 1E 00 03 65 CD.
| Byte | Valor (hex) | Significado |
|---|---|---|
| 1 | 01 | Dirección del sensor |
| 2 | 03 | Función: leer registros |
| 3–4 | 00 1E | Registro inicial (nitrógeno) |
| 5–6 | 00 03 | Cantidad de registros a leer (N, P, K) |
| 7–8 | 65 CD | CRC16, primero el byte bajo |
La respuesta del sensor tiene 11 bytes: dirección (01), función (03), cantidad de bytes de datos (06), tres valores de dos bytes cada uno y dos bytes de CRC. Por ejemplo, en la respuesta 01 03 06 00 20 00 0F 00 6E 11 5D el nitrógeno es 0x0020 = 32 mg/kg, el fósforo 0x000F = 15 mg/kg y el potasio 0x006E = 110 mg/kg. En cada valor llega primero el byte alto: valor = byte alto × 256 + byte bajo. El CRC va al revés, primero el byte bajo; este detalle es lo que más se confunde en Modbus.
| Registro | Valor | Unidad | Trama para leerlo solo |
|---|---|---|---|
| 0x001E | Nitrógeno (N) | mg/kg | 01 03 00 1E 00 01 E4 0C |
| 0x001F | Fósforo (P) | mg/kg | 01 03 00 1F 00 01 B5 CC |
| 0x0020 | Potasio (K) | mg/kg | 01 03 00 20 00 01 85 C0 |
| 0x001E–0x0020 | N, P y K juntos | mg/kg | 01 03 00 1E 00 03 65 CD |
Código para Arduino Uno: leer los valores de N, P y K
El código no necesita librerías extra; usa SoftwareSerial, que viene con el Arduino IDE. Calcula el CRC en cada petición, revisa la dirección, la función, la longitud y el CRC de la respuesta, y escribe los valores válidos en el Monitor Serie. Abre el Monitor Serie a 9600 baudios; si todo está bien conectado verás N, P y K cada dos segundos.
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 | ¿Qué hace? |
|---|---|
| crc16() | Calcula el CRC16 de Modbus con el polinomio 0xA001 |
| DE/RE en HIGH y luego en LOW | Pone el MAX485 en modo transmisión y, al salir la trama, vuelve a escuchar |
| need = 5 + 2 × count | Largo esperado de la respuesta: 3 bytes de encabezado, los datos y 2 bytes de CRC |
| Tiempo límite de 500 ms | Si el sensor no responde, el programa no se queda colgado |
| Revisión de CRC y dirección | Descarta respuestas dañadas por ruido o que vienen de otro equipo |
Cómo interpretar los valores: tabla NPK
El sensor entrega un número en mg/kg, pero si ese número es bueno o malo para tu planta depende del tipo de suelo, del cultivo y del método que use el laboratorio. Los rangos de abajo son límites aproximados que aparecen seguido en guías agronómicas y solo sirven como punto de partida. No decidas cuánto fertilizante aplicar mirando esta tabla con un sensor sin calibrar; úsala más bien para ver en qué zona caen tus lecturas ya calibradas.
| Nutriente | Bajo | Medio | Alto | Nota |
|---|---|---|---|---|
| Nitrógeno (N-nitrato) | Menos de 10 mg/kg | 10–25 mg/kg | Más de 25 mg/kg | En maíz, 25 mg/kg es un umbral muy usado; cambia rápido con el riego y la lluvia |
| Fósforo (P Olsen) | Menos de 10 mg/kg | 10–20 mg/kg | Más de 20 mg/kg | Se mueve lento en el suelo y cambia en meses |
| Potasio (K intercambiable) | Menos de 100 mg/kg | 100–200 mg/kg | Más de 200 mg/kg | En suelos arcillosos es normal ver valores más altos |
Límites de calibración: ¿de verdad este sensor mide NPK?
Siendo honestos, los sensores NPK RS485 económicos no miden el nitrógeno, el fósforo y el potasio por separado de forma química. No llevan ningún elemento selectivo de iones; lo que realmente miden es la conductividad de la solución del suelo (CE) y la reparten en tres números con coeficientes fijos. Por eso los tres valores suelen subir y bajar juntos, aumentan cuando el suelo se moja y el sensor marca NPK alto incluso si lo metes en agua con sal. Eso no lo vuelve inútil: las mediciones tomadas en la misma parcela, con la misma humedad y a la misma profundidad muestran de forma confiable el cambio después de fertilizar y la tendencia en el tiempo. Pero como valor absoluto no reemplaza un análisis de suelo en laboratorio.
- Toma muestras de suelo en 3 a 5 puntos distintos de la parcela y manda a hacer un análisis de N, P y K en un laboratorio.
- En los mismos puntos y con la misma humedad (por ejemplo, un día después del riego), mide con el sensor; entierra las puntas por completo a 10–20 cm de profundidad.
- Toma 3 lecturas en cada punto y usa el promedio; una sola lectura puede engañarte por una piedra o un hueco de aire.
- Con los resultados del laboratorio y los promedios del sensor saca una recta de dos puntos y agrégala al código como corrección.
- Repite la calibración si cambias de tipo de suelo o de fertilizante; una medición de control al inicio de cada temporada es suficiente.
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);Monitoreo de la parcela con ESP32

Con un ESP32 puedes ver las mediciones en tu celular por Wi-Fi. Como el ESP32 trabaja a 3,3 V, en lugar del MAX485 de 5 V usa un MAX3485 o un módulo RS485 de dirección automática que maneja solo el sentido. Si solo tienes un MAX485, puedes alimentarlo con 5 V y bajar su salida RO a 3,3 V con un divisor de voltaje. El siguiente código mide una vez por minuto y muestra los últimos valores en una página web y en la dirección /json; ese JSON es fácil de pasar a una hoja de cálculo o a un sistema de domótica.
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}Si en el campo no hay luz eléctrica, tendrás que alimentar el sistema con una batería y un panel solar pequeño. Como el sensor consume corriente aunque no esté midiendo, enciende la línea de 12 V con un MOSFET o un relé solo durante la medición y pon el ESP32 en modo deep sleep entre lecturas. Así, una estación que mide cada 30 minutos aguanta días con una batería de litio pequeña. Después de darle energía al sensor, espera unos segundos antes de medir. Para parcelas lejanas donde no llega el Wi-Fi, un módulo LoRa ofrece kilómetros de alcance; y la duración de la batería la puedes estimar con la calculadora de duración de batería.
Código MicroPython para Raspberry Pi Pico
En la Pico, la misma trama se envía por la UART. En MicroPython la escritura en la UART deja los datos en un búfer y regresa enseguida, así que el código espera el tiempo que tarda la trama en salir por la línea (unos 8,3 ms para 8 bytes a 9600 baudios) antes de pasar el pin de dirección a modo recepción. Alimenta el módulo MAX3485 desde el pin 3V3(OUT) de la 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)Errores comunes y soluciones
- No hay ninguna respuesta: A y B están invertidos, no llegan 12 V al sensor, los GND no son comunes o la velocidad está mal; primero intercambia A y B y luego prueba con 4800 baudios.
- Siempre marca 0: las puntas están al aire o en tierra completamente seca; entierra el sensor por completo en suelo húmedo, sin huecos de aire entre las puntas.
- Error de CRC: el cable es largo y tiene ruido, o DE/RE cambia demasiado pronto; usa par trenzado y asegúrate de llamar a flush() en el ESP32.
- Valores de 65535 o absurdamente grandes: estás leyendo el registro equivocado; revisa el mapa de registros en el manual de tu sensor.
- Los valores se disparan después del riego: es normal, porque el sensor es sensible a la conductividad; toma las lecturas siempre con una humedad parecida.
- El programa se congela al leer: el bucle de lectura no tiene tiempo límite; agrega uno de 500 ms como en el código.
Ideas de proyectos con el sensor NPK
- Invernadero inteligente: vigila NPK, humedad y temperatura en un solo panel; los detalles están en el proyecto de invernadero inteligente.
- Bitácora de fertilización: guarda en una hoja de cálculo el cambio de NPK después de cada fertilización; te sirve el método de ESP32 con Google Sheets.
- Control del agua de riego: compara las lecturas del suelo con la conductividad del agua de riego usando un sensor TDS.
- Riego automático: cuando baje la humedad, riega con una mini bomba de agua y decide cuándo fertilizar según la tendencia de NPK.
- Estación para el huerto escolar: compara los valores de distintas parcelas y conviértelo en un proyecto para la feria de ciencias.
El sensor NPK también es una gran oportunidad para aprender comunicación industrial RS485 y el protocolo Modbus; la lógica de tramas y CRC que viste aquí es la misma en cientos de equipos, desde medidores de energía hasta estaciones meteorológicas. No confíes ciegamente en los valores: calibra y sigue las tendencias. En la app BlueGrays, el proyecto Estación de Riego Inteligente te muestra paso a paso cómo montar un circuito con sensor de humedad y bomba, al que puedes sumar el sensor NPK.
Preguntas frecuentes
¿Cómo se conecta el sensor NPK al Arduino?
Como el sensor tiene salida RS485, necesitas un módulo MAX485 en medio. Los cables amarillo (A) y azul (B) del sensor van a A y B del MAX485; los pines RO y DI del MAX485 van a D2 y D3 del Arduino, y DE y RE unidos van a D7. El sensor se alimenta con 12 V y el GND de la fuente debe ser común con el GND del Arduino.
¿Con cuántos voltios funciona el sensor NPK?
Según el modelo funciona con 5–30 V o 9–24 V DC; 12 V es la opción segura que sirve para los dos tipos. Incluso en los modelos que dicen funcionar con 5 V, 12 V da lecturas más estables. El módulo MAX485, en cambio, se alimenta con el mismo voltaje que el Arduino, es decir, 5 V.
¿El sensor NPK mide con precisión?
Los sensores NPK RS485 económicos no miden el nitrógeno, el fósforo y el potasio por separado de forma química; miden la conductividad y los estiman con fórmulas. Por eso sus valores absolutos no reemplazan un análisis de laboratorio, pero las lecturas hechas en la misma parcela y con la misma humedad muestran bien los cambios y la tendencia. Una calibración de dos puntos con resultados de laboratorio mejora mucho la precisión.
¿Por qué mi sensor NPK no responde?
Las causas más comunes son A y B invertidos, que no lleguen 12 V al sensor, GND no común y una velocidad equivocada. Primero intercambia A y B y luego prueba 4800 baudios en lugar de 9600. En placas con puerto serie por hardware, cambiar el pin DE/RE sin llamar a flush() también corta la trama a la mitad.
¿Qué registros usa el sensor NPK?
En los sensores tipo JXBS-3001, el nitrógeno está en el registro 0x001E, el fósforo en 0x001F y el potasio en 0x0020, y se leen con la función 03. Para leer los tres juntos se envía la trama 01 03 00 1E 00 03 65 CD. En los sensores 7 en 1 el mapa es distinto, así que revisa el manual de tu sensor.
¿Se puede usar el sensor NPK con ESP32?
Sí. Basta con la UART2 del ESP32 (GPIO 16 y 17) y un pin de dirección. Como el ESP32 trabaja a 3,3 V, lo más seguro es usar un MAX3485 de 3,3 V o un módulo RS485 de dirección automática en lugar del MAX485. Así puedes mandar los valores por Wi-Fi a tu celular o a la nube.
Proyectos para hacer después de leer esto
Ver todos los proyectos
Estación de riego inteligente
Un jardinero que riega solo tus plantas para que no se sequen mientras estás de vacaciones.

Temperatura y humedad con DHT11
¿Qué temperatura hace en tu habitación, y el aire está húmedo o seco? El sensor DHT11 mide la temperatura y la humedad, y el Arduino escribe los valores en una pantalla LCD de dos líneas…

Registrador de Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
¡Monta con el ESP32 un registrador de temperatura y humedad con hora! Un sensor DHT22 lee la temperatura y la humedad una vez por minuto, y cada lectura se guarda en una tarjeta microSD en formato CSV con la hora real del módulo RTC DS1307. La pantalla OLED muestra en vivo y con letra grande la última temperatura, la humedad, la marca de tiempo y el total de registros.

ESP32 DHT22 Temperatura y humedad (con pantalla LCD)
Se trata de un proyecto que mide la temperatura y la humedad ambientales mediante el sensor DHT22 y las muestra en tiempo real en una pantalla LCD I2C 16x2. Los datos del sensor se leen mediante el protocolo de un solo cable (one-wire) utilizando la biblioteca DHT de Adafruit. Este proyecto constituye la base para estaciones meteorológicas IoT, sistemas de automatización doméstica inteligente o sistemas de monitorización ambiental en invernaderos.

Servidor web asíncrono ESP32 (con indicación de IP en la pantalla LCD)
En este proyecto, convertimos el ESP32 en un servidor web asíncrono que puedes controlar desde tu teléfono o tu ordenador, siempre que estén conectados a la misma red Wi-Fi. Gracias a la biblioteca ESPAsyncWebServer, el servidor puede procesar varias solicitudes al mismo tiempo (a diferencia del clásico WebServer.h, que se bloquea con una sola solicitud).

Conexión Wi-Fi STA con ESP32 (con pantalla LCD)
En este proyecto, conectamos el ESP32 a la red Wi-Fi doméstica en modo Station (STA) de forma segura y tolerante a fallos. Separamos el SSID y la contraseña en el archivo secrets.h para evitar que se filtren a Git, configuramos un mecanismo de reconexión automática y mostramos el nivel de señal RSSI y la dirección IP en una pantalla LCD I2C. El LED interno actúa como indicador de estado.

Comunicación unidireccional entre 2 Arduino
Haces que dos Arduino hablen por un solo cable: pulsas el botón de uno y se enciende el LED del otro, vuelves a pulsar y se apaga.
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

