Componentes · 11 min de leitura

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ísticaValor típico
Valores medidosNitrogênio (N), fósforo (P), potássio (K)
Faixa0–1999 mg/kg (mg/kg = ppm)
Resolução1 mg/kg
Precisão declarada±2% FS (só nas condições de calibração do próprio fabricante)
Alimentação5–30 V ou 9–24 V DC, conforme o modelo; 12 V serve para os dois
InterfaceRS485, Modbus RTU, 9600 baud, 8N1 (4800 em alguns modelos)
Endereço padrão0x01
Tempo de respostaMenos de 1 segundo
Corpo e hastesIP68, 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 sensorFunçãoVai ligado em
MarromAlimentação ++ da fonte de 12 V
PretoAlimentação -- da fonte de 12 V e GND do Arduino (comum)
AmareloRS485 A (+)MAX485 A
AzulRS485 B (-)MAX485 B
Pino do MAX485Arduino UnoESP32 (MAX3485)Raspberry Pi Pico (MAX3485)
VCC5V3V33V3(OUT)
GNDGNDGNDGND
RO (saída do receptor)D2GPIO 16 (RX2)GP1 (UART0 RX)
DI (entrada do driver)D3GPIO 17 (TX2)GP0 (UART0 TX)
DE e RE (unidos)D7GPIO 4GP2
A e BFios amarelo e azul do sensorIgualIgual
As cores dos fios podem variar de um fabricante para outro, então confira sempre a etiqueta ou o manual do sensor antes de ligar. Colocar 12 V por engano no VCC do MAX485 ou nos terminais A/B destrói o módulo na hora. Já trocar A e B não estraga nada; o sensor simplesmente não responde. Se não vier resposta, inverter esses dois fios é a primeira coisa a tentar.

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.

ByteValor (hex)Significado
101Endereço do sensor
203Função: ler registradores
3–400 1ERegistrador inicial (nitrogênio)
5–600 03Número de registradores a ler (N, P, K)
7–865 CDSoma 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.

RegistradorValorUnidadeQuadro para ler só ele
0x001ENitrogênio (N)mg/kg01 03 00 1E 00 01 E4 0C
0x001FFósforo (P)mg/kg01 03 00 1F 00 01 B5 CC
0x0020Potássio (K)mg/kg01 03 00 20 00 01 85 C0
0x001E–0x0020N, P e K juntosmg/kg01 03 00 1E 00 03 65 CD
Nos sensores 7 em 1 (umidade, temperatura, EC, pH, N, P, K), o mapa de registradores é outro e varia de fabricante para fabricante; em alguns modelos a umidade fica em 0x0000 e o NPK em 0x0004–0x0006. Confira a tabela do manual do seu sensor e mude REG_N no código de acordo com ela. Se você não sabe o endereço nem a taxa de baud, um pequeno laço que testa os endereços de 1 a 5 em 4800 e 9600 baud poupa muito tempo.

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.

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}
TrechoO que faz
crc16()Calcula o CRC16 do Modbus com o polinômio 0xA001
DE/RE em HIGH, depois em LOWColoca o MAX485 em modo de transmissão e volta a escutar assim que o quadro sai
need = 5 + 2 × countTamanho esperado da resposta: 3 bytes de cabeçalho, os dados e 2 bytes de CRC
Tempo limite de 500 msO programa não trava se o sensor ficar em silêncio
Verificação de CRC e de endereçoDescarta respostas corrompidas por ruído ou vindas de outro dispositivo
O erro mais comum é levar DE/RE para LOW antes de o último byte do quadro ter saído; o sensor recebe então um quadro incompleto e nunca responde. A SoftwareSerial só retorna depois que cada byte foi totalmente enviado, então no Uno não há problema. Em placas que usam uma porta serial de hardware (Mega, ESP32), chame sempre flush() antes de mudar o pino de direção; ele espera até que o último byte tenha saído de verdade.

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.

NutrienteBaixoMédioAltoObservação
Nitrogênio (N-nitrato)Abaixo de 10 mg/kg10–25 mg/kgAcima de 25 mg/kg25 mg/kg é um limiar muito usado para o milho; muda depressa com irrigação e chuva
Fósforo (P Olsen)Abaixo de 10 mg/kg10–20 mg/kgAcima de 20 mg/kgMove-se devagar no solo e muda ao longo de meses
Potássio (K trocável)Abaixo de 100 mg/kg100–200 mg/kgAcima de 200 mg/kgValores 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.

  1. Colete amostras de solo em 3–5 pontos diferentes da lavoura e mande um laboratório analisá-las quanto a N, P e K.
  2. 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.
  3. 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.
  4. 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.
  5. Refaça a calibração quando o tipo de solo ou o adubo mudar; uma conferência no começo de cada safra é suficiente.
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);
A umidade do solo afeta as leituras mais do que qualquer outra coisa. Se você colocar ao lado um sensor de umidade do solo capacitivo barato e registrar o NPK só quando a umidade estiver dentro de uma faixa definida, os resultados ficam muito mais consistentes. Para suavizar leituras que saltam, use as técnicas de filtragem de dados de sensores.

Monitoramento da lavoura com um ESP32

Placa de desenvolvimento ESP32
ESP32: o Wi-Fi integrado leva os valores de NPK da lavoura até o seu celular; ele se conecta ao módulo RS485 pela UART2.

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.

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}

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.

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)

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.

Ver todos os projetos
Estação de irrigação inteligente
AR-83Avançado
Premium

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.

5.0(42)
57
Temperatura e umidade com DHT11
AR-55Intermediário

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…

4.7(47)
83
Registrador de temperatura com ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Avançado
Premium

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.

4.7(7)
12
Temperatura e umidade com ESP32 e DHT22 (com display LCD)
ES-15Intermediário

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.

4.8(38)
57
Servidor web assíncrono com ESP32 (IP no LCD)
ES-27Avançado

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.

4.8(16)
26
Conexão Wi-Fi STA com ESP32 e display LCD
ES-25Avançado

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.

4.4(21)
38
Comunicação unidirecional entre 2 Arduinos
AR-57Intermediário
Premium

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.

4.4(37)
50