Sensor NPK com Arduino: leia nitrogênio, fósforo e potássio (RS485)
Sensor NPK com Arduino: ligação do MAX485 e alimentação de 12 V, o quadro de requisição Modbus, tabela de valores de N-P-K, limites da calibração e código para monitorar a lavoura com ESP32.
Um sensor NPK com Arduino permite acompanhar o nitrogênio (N), o fósforo (P) e o potássio (K) do solo em mg/kg; é uma sonda de solo industrial que se comunica por uma linha RS485 usando Modbus RTU. Para ligá-lo a um Arduino, você acrescenta um transceptor MAX485, alimenta o sensor com 12 V e envia um quadro de requisição de 8 bytes; em poucos milissegundos o sensor responde com os três valores. É um dos sensores mais procurados para acompanhar a necessidade de adubo em estufas, hortas e pequenas lavouras.
Neste guia você vai ver passo a passo como ligar o sensor a um módulo MAX485 e a um Arduino, o que significa cada byte do quadro Modbus, como o CRC é calculado, como transformar a resposta em números e como monitorar uma lavoura pelo Wi-Fi com um ESP32. Também vamos tratar de algo que a maioria dos vendedores deixa de fora: os limites de medição dos sensores NPK baratos e como você deve calibrar as leituras deles.
O que é um sensor de solo NPK e como ele funciona?
A maioria dos sensores NPK do mercado (o JXBS-3001-NPK-RS e seus clones) são sondas com três hastes de aço inoxidável, grau de proteção IP68 e corpo de epóxi. Com as hastes totalmente enterradas, o sensor mede as propriedades elétricas da solução do solo e as converte em estimativas de nitrogênio, fósforo e potássio com fórmulas gravadas no firmware. Não há saída analógica: os valores só são enviados de forma digital pela RS485, e só quando solicitados. É por isso que você usa a porta serial do Arduino, e não os pinos analógicos. Na seção sobre calibração você vai ver em detalhes por que esse sensor não é um instrumento de laboratório.
| Característica | Valor típico |
|---|---|
| Valores medidos | Nitrogênio (N), fósforo (P), potássio (K) |
| Faixa | 0–1999 mg/kg (mg/kg = ppm) |
| Resolução | 1 mg/kg |
| Precisão declarada | ±2% FS (só nas condições de calibração do próprio fabricante) |
| Alimentação | 5–30 V ou 9–24 V DC, conforme o modelo; 12 V serve para os dois |
| Interface | RS485, Modbus RTU, 9600 baud, 8N1 (4800 em alguns modelos) |
| Endereço padrão | 0x01 |
| Tempo de resposta | Menos de 1 segundo |
| Corpo e hastes | IP68, aço inoxidável 316 |
Por que você precisa da RS485 e de um MAX485?
A RS485 é um padrão de comunicação que transporta os dados como a diferença de tensão entre dois fios (A e B). Isso a torna muito resistente a ruído, e ela funciona até com cabos de mais de 100 metros no meio da lavoura; até 32 dispositivos podem compartilhar a mesma linha. Já a porta serial do Arduino fala em níveis TTL (0 e 5 V). O módulo MAX485 faz a tradução entre os dois: transforma os dados do pino TX do Arduino na diferença A/B, e a diferença A/B que vem do sensor em um sinal que o pino RX entende. A RS485 é half-duplex, ou seja, a cada instante um dispositivo ou fala ou escuta; os pinos DE e RE do módulo escolhem o sentido. O básico da comunicação serial está no guia comunicação serial UART.
Ligação do sensor NPK: cores dos fios e o MAX485
| Fio do sensor | Função | Vai ligado em |
|---|---|---|
| Marrom | Alimentação + | + da fonte de 12 V |
| Preto | Alimentação - | - da fonte de 12 V e GND do Arduino (comum) |
| Amarelo | RS485 A (+) | MAX485 A |
| Azul | RS485 B (-) | MAX485 B |
| Pino do MAX485 | Arduino Uno | ESP32 (MAX3485) | Raspberry Pi Pico (MAX3485) |
|---|---|---|---|
| VCC | 5V | 3V3 | 3V3(OUT) |
| GND | GND | GND | GND |
| RO (saída do receptor) | D2 | GPIO 16 (RX2) | GP1 (UART0 RX) |
| DI (entrada do driver) | D3 | GPIO 17 (TX2) | GP0 (UART0 TX) |
| DE e RE (unidos) | D7 | GPIO 4 | GP2 |
| A e B | Fios amarelo e azul do sensor | Igual | Igual |
Alimente o sensor com uma fonte de 12 V. O Arduino pode funcionar pelo USB ou pela mesma fonte, com a tensão reduzida para 5 V por um conversor buck LM2596. Em qualquer dos casos, o negativo da fonte precisa estar unido ao GND do Arduino: embora a RS485 seja diferencial, a faixa de tensão que o receptor aceita é limitada em relação ao terra comum. Cabos de poucos metros dispensam resistor de terminação; em linhas com mais de 50 metros, um resistor de 120 Ω em cada ponta evita reflexões. Muitos módulos MAX485 já vêm com um montado. Em trechos longos, use cabo de par trançado, como o Cat5, para A e B.
O quadro de requisição Modbus: o que enviamos ao sensor?
No Modbus RTU, quem começa a conversa é sempre o mestre (o Arduino); o sensor só responde quando é perguntado. Para ler valores, você usa a função 03 (Read Holding Registers). Nos sensores NPK do tipo JXBS, o nitrogênio fica no registrador 0x001E, o fósforo no 0x001F e o potássio no 0x0020; como são consecutivos, os três podem ser lidos com uma única requisição. Este quadro de 8 bytes pede exatamente isso: 01 03 00 1E 00 03 65 CD.
| Byte | Valor (hex) | Significado |
|---|---|---|
| 1 | 01 | Endereço do sensor |
| 2 | 03 | Função: ler registradores |
| 3–4 | 00 1E | Registrador inicial (nitrogênio) |
| 5–6 | 00 03 | Número de registradores a ler (N, P, K) |
| 7–8 | 65 CD | Soma de verificação CRC16, byte baixo primeiro |
A resposta do sensor tem 11 bytes: endereço (01), função (03), número de bytes de dados (06), três valores de dois bytes cada e um CRC de dois bytes. Por exemplo, na resposta 01 03 06 00 20 00 0F 00 6E 11 5D, o nitrogênio é 0x0020 = 32 mg/kg, o fósforo é 0x000F = 15 mg/kg e o potássio é 0x006E = 110 mg/kg. Em cada valor, o byte alto vem primeiro: valor = byte alto × 256 + byte baixo. No CRC é o contrário, o byte baixo vem primeiro; esse pequeno detalhe é a confusão mais comum no Modbus.
| Registrador | Valor | Unidade | Quadro para ler só ele |
|---|---|---|---|
| 0x001E | Nitrogênio (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 | Potássio (K) | mg/kg | 01 03 00 20 00 01 85 C0 |
| 0x001E–0x0020 | N, P e K juntos | mg/kg | 01 03 00 1E 00 03 65 CD |
Código para Arduino Uno: lendo N, P e K
O código não precisa de nenhuma biblioteca extra; ele usa a SoftwareSerial, que já vem com a Arduino IDE. Ele calcula o CRC de cada requisição, confere o endereço, a função, o tamanho e o CRC da resposta e imprime os valores válidos no Monitor Serial. Abra o Monitor Serial em 9600 baud; com a ligação correta, você vai ver N, P e K a cada dois 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}| Trecho | O que faz |
|---|---|
| crc16() | Calcula o CRC16 do Modbus com o polinômio 0xA001 |
| DE/RE em HIGH, depois em LOW | Coloca o MAX485 em modo de transmissão e volta a escutar assim que o quadro sai |
| need = 5 + 2 × count | Tamanho esperado da resposta: 3 bytes de cabeçalho, os dados e 2 bytes de CRC |
| Tempo limite de 500 ms | O programa não trava se o sensor ficar em silêncio |
| Verificação de CRC e de endereço | Descarta respostas corrompidas por ruído ou vindas de outro dispositivo |
Como interpretar as leituras: tabela de valores de NPK
O sensor entrega um número em mg/kg, mas se esse número é bom ou ruim para as suas plantas depende do tipo de solo, da cultura e do método de laboratório usado. As faixas abaixo são limites aproximados que aparecem com frequência em guias de agronomia e servem só como ponto de partida. Não decida quanto adubo aplicar comparando um sensor sem calibração com esta tabela; use-a para ver em que zona caem as suas leituras calibradas.
| Nutriente | Baixo | Médio | Alto | Observação |
|---|---|---|---|---|
| Nitrogênio (N-nitrato) | Abaixo de 10 mg/kg | 10–25 mg/kg | Acima de 25 mg/kg | 25 mg/kg é um limiar muito usado para o milho; muda depressa com irrigação e chuva |
| Fósforo (P Olsen) | Abaixo de 10 mg/kg | 10–20 mg/kg | Acima de 20 mg/kg | Move-se devagar no solo e muda ao longo de meses |
| Potássio (K trocável) | Abaixo de 100 mg/kg | 100–200 mg/kg | Acima de 200 mg/kg | Valores mais altos são normais em solos argilosos |
Limites da calibração: esse sensor mede NPK de verdade?
Sendo honesto, os sensores NPK RS485 baratos não medem nitrogênio, fósforo e potássio separadamente, por via química. Eles não têm nenhum elemento seletivo de íons; o que medem de fato é a condutividade (EC) da solução do solo, que dividem em três números com coeficientes fixos. É por isso que os três valores costumam subir e descer juntos, aumentam quando o solo fica molhado e indicam NPK alto até quando o sensor é mergulhado em água salgada. Isso não torna o sensor inútil: leituras feitas na mesma lavoura, com a mesma umidade e na mesma profundidade, mostram de forma confiável a mudança depois da adubação e a tendência ao longo do tempo. Mas, como valores absolutos, elas não substituem uma análise de solo em laboratório.
- Colete amostras de solo em 3–5 pontos diferentes da lavoura e mande um laboratório analisá-las quanto a N, P e K.
- Meça os mesmos pontos com o sensor, na mesma umidade (por exemplo, um dia depois da irrigação), com as hastes totalmente enterradas a 10–20 cm (4–8 pol) de profundidade.
- Faça 3 leituras em cada ponto e use a média; uma leitura isolada pode enganar por causa de uma pedra ou de um bolsão de ar.
- Ajuste uma reta de dois pontos entre os resultados do laboratório e as médias do sensor e acrescente-a ao código como correção.
- Refaça a calibração quando o tipo de solo ou o adubo mudar; uma conferência no começo de cada safra é 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);Monitoramento da lavoura com um ESP32

Com um ESP32 você acompanha as leituras no celular pelo Wi-Fi. Como o ESP32 trabalha em 3,3 V, use um MAX3485 ou um módulo RS485 com direção automática, que cuida sozinho do pino de direção, no lugar do MAX485 de 5 V. Se você só tiver um MAX485, alimente-o com 5 V e baixe a saída RO para 3,3 V com um divisor de tensão. O código abaixo faz uma leitura por minuto e mostra os últimos valores em uma página web e em /json; esse JSON é fácil de levar para uma planilha ou para um sistema de automação residencial.
1// ESP32 + RS485 NPK sensörü: Wi-Fi ile tarla izleme / ESP32 + RS485 NPK sensor: field monitoring over Wi-Fi
2#include <WiFi.h>
3#include <WebServer.h>
4
5const char* WIFI_SSID = "AgAdi"; // Wi-Fi adın / your Wi-Fi name
6const char* WIFI_PASS = "Sifre123"; // Wi-Fi şifren / your Wi-Fi password
7
8const int PIN_RX = 16; // MAX3485 RO
9const int PIN_TX = 17; // MAX3485 DI
10const int PIN_DE_RE = 4; // DE + RE
11const uint8_t SENSOR_ADDR = 0x01;
12const uint16_t REG_N = 0x001E;
13const unsigned long READ_EVERY_MS = 60000; // dakikada bir ölç / measure once a minute
14
15HardwareSerial rs485(2); // UART2
16WebServer server(80);
17
18uint16_t lastN = 0, lastP = 0, lastK = 0;
19bool lastOk = false;
20uint32_t readCount = 0;
21unsigned long lastRead = 0;
22
23uint16_t crc16(const uint8_t *buf, uint8_t len) {
24 uint16_t crc = 0xFFFF;
25 for (uint8_t i = 0; i < len; i++) {
26 crc ^= buf[i];
27 for (uint8_t b = 0; b < 8; b++) crc = (crc & 1) ? (crc >> 1) ^ 0xA001 : crc >> 1;
28 }
29 return crc;
30}
31
32bool readRegisters(uint16_t start, uint8_t count, uint16_t *out) {
33 uint8_t req[8] = { SENSOR_ADDR, 0x03, (uint8_t)(start >> 8), (uint8_t)(start & 0xFF), 0x00, count, 0, 0 };
34 uint16_t crc = crc16(req, 6);
35 req[6] = crc & 0xFF;
36 req[7] = crc >> 8;
37 while (rs485.available()) rs485.read();
38 digitalWrite(PIN_DE_RE, HIGH);
39 rs485.write(req, 8);
40 rs485.flush(); // son bayt çıkana kadar bekle / wait until the last byte is out
41 digitalWrite(PIN_DE_RE, LOW);
42
43 uint8_t resp[21];
44 uint8_t need = 5 + 2 * count, got = 0;
45 unsigned long t0 = millis();
46 while (got < need && millis() - t0 < 500) {
47 if (rs485.available()) resp[got++] = rs485.read();
48 }
49 if (got < need || resp[0] != SENSOR_ADDR || resp[1] != 0x03 || resp[2] != 2 * count) return false;
50 if (crc16(resp, need - 2) != (resp[need - 2] | (resp[need - 1] << 8))) return false;
51 for (uint8_t i = 0; i < count; i++) out[i] = (resp[3 + 2 * i] << 8) | resp[4 + 2 * i];
52 return true;
53}
54
55void handleRoot() {
56 String html = "<!DOCTYPE html><html><head><meta name='viewport' content='width=device-width'>";
57 html += "<meta http-equiv='refresh' content='30'></head><body><h2>NPK (mg/kg)</h2>";
58 html += "<p>N: " + String(lastN) + "<br>P: " + String(lastP) + "<br>K: " + String(lastK) + "</p>";
59 html += "<p>" + String(lastOk ? "Sensor OK" : "Sensor yanit vermiyor / no reply");
60 html += " - olcum / readings: " + String(readCount) + "</p></body></html>";
61 server.send(200, "text/html", html);
62}
63
64void handleJson() { // başka sistemler için / for other systems
65 String json = "{\"n\":" + String(lastN) + ",\"p\":" + String(lastP) + ",\"k\":" + String(lastK);
66 json += ",\"ok\":" + String(lastOk ? "true" : "false") + "}";
67 server.send(200, "application/json", json);
68}
69
70void setup() {
71 Serial.begin(115200);
72 rs485.begin(9600, SERIAL_8N1, PIN_RX, PIN_TX);
73 pinMode(PIN_DE_RE, OUTPUT);
74 digitalWrite(PIN_DE_RE, LOW);
75 WiFi.mode(WIFI_STA);
76 WiFi.begin(WIFI_SSID, WIFI_PASS);
77 unsigned long t0 = millis();
78 while (WiFi.status() != WL_CONNECTED && millis() - t0 < 15000) delay(250);
79 Serial.println(WiFi.status() == WL_CONNECTED ? WiFi.localIP().toString() : String("Wi-Fi yok / no Wi-Fi"));
80 server.on("/", handleRoot);
81 server.on("/json", handleJson);
82 server.begin();
83 lastRead = millis() - READ_EVERY_MS; // ilk ölçüm hemen / first reading at once
84}
85
86void loop() {
87 server.handleClient();
88 if (millis() - lastRead >= READ_EVERY_MS) {
89 lastRead = millis();
90 uint16_t v[3];
91 lastOk = readRegisters(REG_N, 3, v);
92 if (lastOk) {
93 lastN = v[0]; lastP = v[1]; lastK = v[2];
94 readCount++;
95 Serial.printf("N=%u P=%u K=%u mg/kg\n", lastN, lastP, lastK);
96 } else {
97 Serial.println("Yanit yok / no reply");
98 }
99 }
100}Se não houver energia na lavoura, você vai precisar de uma bateria e de um pequeno painel solar. Como o sensor consome corrente mesmo quando não está medindo, ligue a linha de 12 V com um MOSFET ou um relé só durante a leitura e coloque o ESP32 em deep sleep entre as leituras. Assim, uma estação que mede a cada 30 minutos funciona por dias com uma pequena bateria de lítio. Depois de energizar o sensor, espere alguns segundos antes de medir. Para lavouras distantes, fora do alcance do Wi-Fi, um módulo LoRa oferece quilômetros de alcance, e você pode estimar a autonomia da bateria com a calculadora de autonomia da bateria.
Código MicroPython para o Raspberry Pi Pico
No Pico, o mesmo quadro é enviado pela UART. No MicroPython, uma escrita na UART joga os dados em um buffer e retorna na hora, então o código espera o tempo de que o quadro precisa para sair pela linha (cerca de 8,3 ms para 8 bytes em 9600 baud) antes de mudar o pino de direção para recepção. Alimente o módulo MAX3485 pelo pino 3V3(OUT) do 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)Erros comuns e como resolver
- Nenhuma resposta: A e B estão trocados, o sensor não está recebendo 12 V, os terras não são comuns ou a taxa de baud está errada; primeiro inverta A e B, depois tente 4800 baud.
- Lê sempre 0: as hastes estão no ar ou em solo completamente seco; enterre o sensor por inteiro em solo úmido, sem bolsões de ar entre as hastes.
- Erro de CRC: o cabo é longo e ruidoso, ou DE/RE muda cedo demais; use par trançado e confira se flush() é chamado no ESP32.
- Valores de 65535 ou absurdamente altos: você está lendo o registrador errado; confira o mapa de registradores no manual do seu sensor.
- Os valores saltam depois da irrigação: é normal, porque o sensor responde à condutividade; faça as leituras sempre com umidade parecida.
- O programa trava durante a leitura: o laço de leitura não tem tempo limite; acrescente um tempo limite de 500 ms, como no código.
Ideias de projetos com o sensor NPK
- Estufa inteligente: acompanhe NPK, umidade e temperatura em um único painel; os detalhes estão no projeto de estufa inteligente.
- Diário de adubação: registre em uma planilha a mudança de NPK depois de cada adubação; o método do ESP32 com Google Sheets vem a calhar.
- Conferência da água de irrigação: compare as leituras do solo com a condutividade da sua água de irrigação usando um sensor TDS.
- Rega automática: regue com uma minibomba de água quando a umidade cair e programe a adubação pela tendência do NPK.
- Estação da horta da escola: compare os valores de canteiros diferentes e transforme isso em um projeto de feira de ciências.
O sensor NPK também é um ótimo jeito de aprender a comunicação industrial RS485 e o protocolo Modbus; a lógica de quadro e de CRC que você viu aqui é a mesma em centenas de dispositivos, de medidores de energia a estações meteorológicas. Não confie cegamente nos números: calibre e acompanhe as tendências. No app BlueGrays, o projeto de estação de irrigação inteligente mostra passo a passo como montar um circuito com sensor de umidade e bomba, que você pode ampliar com o sensor NPK.
Perguntas frequentes
Como ligar um sensor NPK ao Arduino?
O sensor tem saída RS485, então você precisa de um módulo MAX485 no meio do caminho. Os fios amarelo (A) e azul (B) do sensor vão para A e B do MAX485, os pinos RO e DI do MAX485 vão para D2 e D3 do Arduino, e os pinos DE e RE, unidos, vão para D7. O sensor é alimentado com 12 V, e o GND da fonte precisa ser comum com o GND do Arduino.
De que tensão um sensor NPK precisa?
Conforme o modelo, ele funciona com 5–30 V ou 9–24 V DC; 12 V é a escolha segura, que serve para os dois tipos. Mesmo nos modelos especificados para 5 V, 12 V dá leituras mais estáveis. Já o módulo MAX485 é alimentado com a mesma tensão do Arduino, ou seja, 5 V.
Os sensores NPK são precisos?
Os sensores NPK RS485 baratos não medem nitrogênio, fósforo e potássio separadamente, por via química; eles medem a condutividade e estimam os valores com fórmulas. Por isso, os valores absolutos não substituem uma análise de laboratório, mas leituras feitas na mesma lavoura, com a mesma umidade, mostram bem as mudanças e as tendências. Uma calibração de dois pontos com base nos resultados do laboratório melhora bastante a precisão.
Por que meu sensor NPK não responde?
As causas mais comuns são os fios A e B trocados, a falta de 12 V no sensor, terras que não são comuns e a taxa de baud errada. Primeiro inverta A e B, depois tente 4800 baud no lugar de 9600. Em placas com porta serial de hardware, mudar DE/RE sem chamar flush() também corta o quadro pela metade.
Quais registradores o sensor NPK usa?
Nos sensores do tipo JXBS-3001, o nitrogênio fica no registrador 0x001E, o fósforo no 0x001F e o potássio no 0x0020, lidos com a função 03. Para ler os três de uma vez, envie o quadro 01 03 00 1E 00 03 65 CD. Nos sensores 7 em 1 o mapa é diferente, então confira o manual do seu sensor.
Posso usar um sensor NPK com um ESP32?
Sim. A UART2 do ESP32 (GPIO 16 e 17) mais um pino de direção é tudo de que você precisa. Como o ESP32 trabalha em 3,3 V, a escolha mais segura é um MAX3485 de 3,3 V ou um módulo RS485 com direção automática no lugar do MAX485. Depois é só enviar os valores pelo Wi-Fi para o celular ou para a nuvem.
Projetos para montar depois desta leitura
Ver todos os projetos
Estação de irrigação inteligente
Um jardineiro que rega suas plantas sozinho para que elas não sequem enquanto você está de férias.

Temperatura e umidade com DHT11
Qual é a temperatura do seu quarto? O ar está úmido ou seco? O sensor DHT11 mede a temperatura e a umidade, e o Arduino mostra os valores em um display LCD de duas linhas, atualizando a cada poucos…

Registrador de temperatura com ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
Monte um registrador de temperatura com data e hora usando ESP32. O DHT22 mede a temperatura e a umidade a cada minuto, o DS1307 RTC fornece a hora real e cada leitura é gravada em CSV no cartão microSD. O OLED mostra em letras grandes a temperatura atual, além da umidade, da data e hora e do total de registros. Abra o arquivo /temp_log.csv no Excel, no Google Sheets ou com pandas para acompanhar uma estufa ou a temperatura de casa.

Temperatura e umidade com ESP32 e DHT22 (com display LCD)
Este projeto mede a temperatura e a umidade do ambiente com um sensor DHT22 e exibe os dados em tempo real em um LCD I2C 16x2. Os dados são lidos do sensor pelo protocolo de um fio (one-wire) com a biblioteca Adafruit DHT. Este projeto serve de base para estações meteorológicas IoT, automação residencial ou sistemas de monitoramento ambiental em estufas. A comunicação com o DHT22 é feita pelo pino GPIO 4 do ESP32.

Servidor web assíncrono com ESP32 (IP no LCD)
Neste projeto, transformamos o ESP32 em um servidor web assíncrono que você pode controlar pelo celular ou computador na mesma rede Wi-Fi. Com a biblioteca ESPAsyncWebServer, o servidor processa várias requisições ao mesmo tempo (ao contrário do WebServer.h tradicional, que bloqueia a execução ao processar uma requisição). Você poderá abrir o endereço IP do ESP32 no navegador e clicar nos botões ON/OFF (as rotas /on e /off) para ligar e desligar o LED conectado ao GPIO 5.

Conexão Wi-Fi STA com ESP32 e display LCD
Neste projeto, conectamos o ESP32 à rede Wi-Fi de casa no modo estação (STA), de forma segura e tolerante a falhas. Guardamos o SSID e a senha em um arquivo secrets.h separado para evitar que sejam expostos no Git, configuramos um mecanismo de reconexão automática e exibimos o nível de sinal RSSI e o endereço IP em um display LCD I2C. O LED integrado funciona como indicador de status. É um gerenciador de conexão pronto para uso em produção.

Comunicação unidirecional entre 2 Arduinos
Faça dois Arduinos conversarem por um único fio: ao pressionar o botão de um, o LED do outro acende; ao pressionar de novo, ele apaga.
Mais artigos
- Sensor de umidade do solo: irrigação automática de plantas com Arduino
- O que é UART? Guia de ligação TX/RX, baud rate e comunicação serial com Arduino
- Projeto de estufa inteligente com Arduino: sensores, irrigação, ventoinha e código
- Sensor TDS com Arduino: medir ppm, calibrar e monitorar a qualidade da água
App BlueGrays
Monte este circuito passo a passo pelo celular
Esquema do circuito, código e lista de componentes em uma só tela. Mais de 500 projetos com Arduino, ESP32 e Pico prontos para montar.
Escaneie com seu celular
Aponte a câmera para o código para abrir a loja de aplicativos do seu celular.
ou abrir a loja

