Componentes · 12 min de leitura

Chave boia com Arduino: guia de controle de bomba e nível do reservatório

Como ligar uma chave boia ao Arduino? Funcionamento do reed, montagem NA/NF, leitura com pull-up e código para Uno, ESP32 e Pico que desliga a bomba quando o reservatório enche.

A chave boia (float switch) é o jeito mais simples e confiável de saber, com um Arduino, se uma caixa d'água, um aquário ou um reservatório de irrigação está cheio ou vazio. Dentro dela há uma boia com um ímã e uma chave reed dentro de um tubo de vidro; quando o nível da água empurra a boia para cima, o contato fecha, e quando a água baixa, ele abre. Do ponto de vista eletrônico, o sensor é apenas um botão apertado pela água: você liga um dos dois fios ao GND e o outro a um pino digital, e lê o pino com INPUT_PULLUP.

Neste guia você vai ver o que há dentro da boia, a diferença entre a montagem NA e NF, como filtrar por software a trepidação causada pela água ondulando e vai montar, passo a passo, um circuito com duas boias que desliga a bomba automaticamente quando o reservatório fica cheio. Além de códigos funcionais para Arduino Uno, ESP32 e Raspberry Pi Pico, você vai descobrir quando uma boia é melhor que os sensores de nível com sondas condutivas, sem contato e ultrassônicos.

Sensor de nível de água tipo boia (chave boia)
Sensor de nível vertical tipo boia: boia com ímã, corpo com chave reed por dentro, parte rosqueada para fixação e dois fios.

O que é um sensor de nível tipo boia e como ele funciona?

Dentro do corpo plástico oco no centro do sensor há um pequeno tubo de vidro cheio de gás inerte. Dentro do tubo ficam duas lâminas metálicas ferromagnéticas bem próximas uma da outra; essa é a chave reed. A boia, que desliza livremente ao longo do corpo, tem um ímã em forma de anel. Conforme a água sobe, a boia flutua e desliza pelo corpo; quando o ímã chega à altura da chave reed, o campo magnético magnetiza as duas lâminas, elas se atraem e o circuito fecha. Quando o ímã se afasta, a elasticidade das lâminas as separa e o circuito abre de novo.

Esse projeto tem duas grandes vantagens. Primeiro, o contato elétrico fica todo dentro de um tubo de vidro selado; nenhum metal toca a água, então você não tem a corrosão por eletrólise nem a sujeira que afetam os sensores com sondas condutivas. Segundo, a saída é puramente digital: aberta ou fechada. Não precisa de leitura analógica, calibração nem biblioteca. Por outro lado, a boia conhece um único ponto; ela não diz se a água está com 12 cm ou 18 cm de profundidade, só responde “o nível está acima ou abaixo desta linha?”. O mesmo princípio é usado em sensores de porta e janela; veja os detalhes no artigo Relé reed.

CaracterísticaValor típico (modelo vertical pequeno)
Elemento sensorChave reed + ímã em anel dentro da boia
SaídaContato seco (aberto / fechado), 2 fios, sem polaridade
Tipo de contatoNA ou NF (muda ao inverter a boia)
Potência máx. de chaveamento10 W
Tensão máx. de chaveamento100 V DC
Corrente máx. de chaveamento0,5 A
Resistência de contato100 mΩ ou menos
Material do corpo e da boiaPP (polipropileno)
Temperatura de operação−10 … +85 °C
MontagemCorpo rosqueado, com porca e vedação, no fundo ou na tampa do reservatório

Montagem NA e NF: invertendo a boia

A maioria dos sensores sai da caixa funcionando como NA (normalmente aberto): sem água, a boia fica apoiada no anel de batente de baixo e o contato está aberto; quando a água levanta a boia, o contato fecha. O ímã dentro da boia não fica exatamente no meio, mas perto de uma das pontas. Por isso, se você tirar o anel de retenção (anel elástico) da ponta do corpo e recolocar a boia de cabeça para baixo, a posição do ímã em relação à chave reed muda e o sensor passa a ser NF (normalmente fechado): fechado sem água, aberto quando a água chega. Tem mais um detalhe: montar o sensor apontando para cima a partir do fundo do reservatório ou pendurado para baixo a partir da tampa também muda a posição de repouso da boia. Então, seja qual for o modelo que você comprar, antes de instalar coloque o multímetro no modo de continuidade (bipe), suba e desça a boia com a mão e veja o comportamento real.

MontagemSem água (boia embaixo)Com água (boia em cima)Pino com INPUT_PULLUP
NA (normalmente aberto)Contato abertoContato fechadoHIGH no seco, LOW na água
NF (normalmente fechado)Contato fechadoContato abertoLOW no seco, HIGH na água
Em funções de segurança, como um alarme de transbordamento, prefira a montagem NF. Num circuito NF o contato fica normalmente fechado e o pino lê LOW; o pino vai para HIGH se a água subir, mas também se o fio romper ou o conector se soltar. Assim, uma falha também é detectada como alarme, e a bomba não continua funcionando como se nada tivesse acontecido quando o sensor para de funcionar silenciosamente.

Ligação: pinos do Arduino Uno, ESP32 e Pico

Não há polaridade entre os dois fios de uma chave boia. Basta ligar um fio ao GND, o outro a um pino digital e ativar o resistor de pull-up interno do pino; não precisa de resistor externo. Com o contato aberto, o pull-up puxa o pino para 5 V (3,3 V no ESP32 e no Pico) e ele lê HIGH; quando o contato fecha, o pino fica ligado direto ao GND e lê LOW. O pull-up interno do Uno fica entre 20–50 kΩ; a corrente que circula com o contato fechado é minúscula, 5 V / 30 kΩ ≈ 0,17 mA, e não sobrecarrega a chave reed em nada. Os detalhes da lógica de pull-up estão no artigo Resistores de pull-up e pull-down. A tabela abaixo mostra os pinos usados em todos os códigos mais adiante neste artigo:

LigaçãoArduino UnoESP32Raspberry Pi Pico
Boia superior (reservatório cheio)D2GPIO 27GP2
Boia inferior (reservatório vazio)D3GPIO 26GP3
Outros fios das boiasGNDGNDGND
IN do módulo reléD7GPIO 23GP15
Buzzer ativo (+)D8GPIO 25GP16
VCC do módulo relé5VVIN (5 V)VBUS (5 V)
Nunca ligue uma bomba ou uma válvula solenoide diretamente nos fios da boia. A chave reed dos modelos pequenos consegue chavear no máximo cerca de 10 W e 0,5 A (os valores variam conforme o produto, então confira a etiqueta); a corrente de partida do motor e o arco que se forma quando o contato fecha logo soldam as lâminas dentro do tubo de vidro, e o sensor passa a indicar “cheio” ou “vazio” o tempo todo. A boia deve apenas enviar um sinal ao microcontrolador, e um relé ou MOSFET deve chavear a carga. E jamais passe a tensão da rede de 220 V pela chave boia.

Passo a passo: lendo a boia pela primeira vez

  1. Coloque o multímetro em continuidade, encoste as pontas de prova nos dois fios da boia e deslize a boia para cima e para baixo com a mão para descobrir se ela funciona como NA ou NF.
  2. Ligue um fio ao pino GND do Arduino e o outro ao pino D2. Se os fios forem finos, solde as pontas num jumper ou use um borne com parafuso.
  3. Carregue o código abaixo; ele configura o pino como INPUT_PULLUP, então não precisa de resistor extra.
  4. Abra o Monitor Serial a 9600 baud.
  5. Empurre a boia para cima com o dedo: numa montagem NA, o LED integrado no D13 deve acender e a tela deve mostrar “Level HIGH”. Ao soltar, o LED deve apagar e a mensagem “Level LOW” deve aparecer.
C++ (Arduino IDE)
1const int FLOAT_PIN = 2;                 // şamandıra kablosu / float switch wire
2const int LED_PIN = 13;                  // dahili LED / built-in LED
3const unsigned long DEBOUNCE_MS = 300;   // dalga filtresi / ripple filter
4
5int stableState;
6int lastReading;
7unsigned long lastChange = 0;
8
9void setup() {
10  Serial.begin(9600);
11  pinMode(FLOAT_PIN, INPUT_PULLUP);      // dahili pull-up / internal pull-up
12  pinMode(LED_PIN, OUTPUT);
13  delay(10);
14  stableState = digitalRead(FLOAT_PIN);
15  lastReading = stableState;
16  digitalWrite(LED_PIN, stableState == LOW ? HIGH : LOW);
17}
18
19void loop() {
20  int reading = digitalRead(FLOAT_PIN);
21  if (reading != lastReading) {          // değişim var, sayacı sıfırla / change, reset timer
22    lastReading = reading;
23    lastChange = millis();
24  }
25  if (millis() - lastChange >= DEBOUNCE_MS && reading != stableState) {
26    stableState = reading;               // 300 ms sabit kaldı / stable for 300 ms
27    if (stableState == LOW) {            // NO: kontak kapalı = su var / NO: closed = water
28      Serial.println(F("Seviye YUKSEK: su var / Level HIGH: water present"));
29      digitalWrite(LED_PIN, HIGH);
30    } else {
31      Serial.println(F("Seviye DUSUK: su yok / Level LOW: no water"));
32      digitalWrite(LED_PIN, LOW);
33    }
34  }
35}

A parte mais importante do código é o debounce (filtragem da trepidação). A água num reservatório nunca está totalmente parada: enquanto a bomba funciona, uma torneira é aberta ou o reservatório é enchido, a superfície ondula e a boia pode abrir e fechar várias vezes por segundo no ponto de limite. O código zera um temporizador toda vez que o valor do pino muda e só aceita o novo valor se ele ficar sem mudar por 300 ms. É a mesma ideia do debounce de botões, só que com um tempo maior. Num reservatório muito agitado, você pode aumentar o tempo para 1–2 segundos. Como a temporização é feita com millis(), o loop nunca fica esperando; veja o porquê no artigo millis ou delay.

O circuito que desliga a bomba quando o reservatório enche

Dá para controlar uma bomba com uma única boia, mas há um problema: quando o nível da água está bem no limite, a bomba liga e desliga a cada poucos segundos. Isso desgasta tanto a bomba quanto o relé. A solução é a histerese, ou seja, dois limites separados. Você monta uma boia na parte de baixo do reservatório e outra na parte de cima. Quando a água desce abaixo da boia inferior, a bomba liga, e quando chega à boia superior, ela desliga; na faixa entre as duas, a bomba mantém o estado atual. Se houver 15 cm entre as duas boias e a bomba fornecer 3 litros por minuto, num reservatório com base de 30×40 cm (1200 cm²) essa faixa equivale a 18 litros e a bomba funciona sem parar por cerca de 6 minutos a cada vez. O código também faz duas verificações de segurança: se a boia superior indica água mas a inferior indica seco, isso é fisicamente impossível, então há uma falha de fio ou de sensor; e se a bomba funcionar por mais tempo que o esperado, a fonte de água pode ter secado ou uma mangueira pode ter se soltado. Nos dois casos a bomba para e o buzzer toca.

  • 2 chaves boia: Para os limites inferior e superior; na montagem NA, as duas dão LOW na água.
  • Módulo relé de 1 canal: Chaveia a alimentação da bomba. A maioria dos módulos aciona quando o pino IN vai para LOW (ativo em LOW); você ajusta isso no código com a constante RELAY_ACTIVE_LOW. Detalhes no artigo Módulo relé.
  • Bomba e fonte de alimentação separada: Para uma bomba pequena, como uma mini bomba submersível de 6 V, use 4 pilhas AA ou uma fonte de 6 V; não puxe a corrente da bomba do pino 5V do Arduino. Para escolher a bomba, dê uma olhada no artigo Mini bomba d'água.
  • GND comum: Se você usar um módulo relé, os GNDs do Arduino e do módulo são unidos, enquanto o circuito da bomba fica separado pelo contato do relé. Se usar um MOSFET, o negativo da fonte da bomba também precisa ser ligado ao GND do Arduino, e um diodo 1N4007 deve ser colocado em paralelo com a bomba, invertido.
  • Buzzer ativo: Bipa de forma intermitente para avisar você quando há uma falha.
C++ (Arduino IDE)
1// İki şamandıra ile otomatik depo doldurma / Automatic tank filling with two floats
2const int FLOAT_PINS[2] = {2, 3};      // 0: üst şamandıra / upper float, 1: alt şamandıra / lower float
3const int RELAY_PIN  = 7;              // röle modülü IN / relay module IN
4const int BUZZER_PIN = 8;              // aktif buzzer / active buzzer
5const bool RELAY_ACTIVE_LOW = true;    // çoğu modül LOW ile çeker / most modules trigger on LOW
6const unsigned long STABLE_MS  = 500;                   // filtre süresi / filter time
7const unsigned long MAX_RUN_MS = 10UL * 60UL * 1000UL;  // en uzun çalışma: 10 dk / max run: 10 min
8
9bool wet[2];                 // true = şamandıra suda / true = float in water
10int lastRaw[2];
11unsigned long lastChange[2];
12bool pumpOn = false;
13bool fault = false;
14unsigned long pumpStart = 0;
15
16void updateSensor(int i) {
17  int raw = digitalRead(FLOAT_PINS[i]);
18  if (raw != lastRaw[i]) {             // değer değişti, sayacı sıfırla / value changed, reset timer
19    lastRaw[i] = raw;
20    lastChange[i] = millis();
21  }
22  if (millis() - lastChange[i] >= STABLE_MS) {
23    wet[i] = (raw == LOW);             // NO montaj: suda LOW / NO mount: LOW when wet
24  }
25}
26
27void setPump(bool on) {
28  pumpOn = on;
29  if (on) pumpStart = millis();
30  digitalWrite(RELAY_PIN, (on != RELAY_ACTIVE_LOW) ? HIGH : LOW);
31}
32
33void stopWithFault(const __FlashStringHelper *msg) {
34  setPump(false);
35  fault = true;                        // reset atılana kadar kilitli / latched until reset
36  Serial.println(msg);
37}
38
39void setup() {
40  Serial.begin(9600);
41  digitalWrite(RELAY_PIN, RELAY_ACTIVE_LOW ? HIGH : LOW);  // önce kapalı seviye / off level first
42  pinMode(RELAY_PIN, OUTPUT);
43  pinMode(BUZZER_PIN, OUTPUT);
44  for (int i = 0; i < 2; i++) {
45    pinMode(FLOAT_PINS[i], INPUT_PULLUP);
46  }
47  delay(10);                           // pull-up otursun / let pull-ups settle
48  for (int i = 0; i < 2; i++) {
49    lastRaw[i] = digitalRead(FLOAT_PINS[i]);
50    wet[i] = (lastRaw[i] == LOW);
51    lastChange[i] = millis();
52  }
53  Serial.println(F("Depo kontrolu basladi / Tank control started"));
54}
55
56void loop() {
57  updateSensor(0);
58  updateSensor(1);
59
60  if (!fault && wet[0] && !wet[1]) {   // üst suda, alt kuru: imkansız / upper wet, lower dry: impossible
61    stopWithFault(F("HATA: sensor tutarsiz / ERROR: sensors inconsistent"));
62  }
63  if (!fault && pumpOn && millis() - pumpStart > MAX_RUN_MS) {
64    stopWithFault(F("HATA: pompa cok uzun calisti / ERROR: pump ran too long"));
65  }
66
67  if (!fault) {
68    if (!pumpOn && !wet[1]) {          // su alt eşiğin altında / water below lower level
69      setPump(true);
70      Serial.println(F("Pompa ACIK / Pump ON"));
71    } else if (pumpOn && wet[0]) {     // depo dolu / tank full
72      setPump(false);
73      Serial.println(F("Depo dolu, pompa KAPALI / Tank full, pump OFF"));
74    }
75  }
76
77  // Arızada yarım saniyede bir bip / beep every half second on fault
78  digitalWrite(BUZZER_PIN, (fault && (millis() / 500) % 2) ? HIGH : LOW);
79}
Parte do códigoFunção
updateSensor(i) (leitura de cada boia)Lê cada boia separadamente; atualiza o estado wet[i] quando o valor fica estável por 500 ms.
wet[0] / wet[1] (estado das boias)Se a boia superior e a inferior estão na água (true = na água).
!pumpOn && !wet[1] (ligar a bomba)A água desceu abaixo do limite inferior: liga a bomba.
pumpOn && wet[0] (desligar a bomba)A água chegou ao limite superior: desliga a bomba.
wet[0] && !wet[1] (leitura inconsistente)Superior molhada, inferior seca: uma leitura inconsistente, ou seja, falha de fio ou de sensor.
MAX_RUN_MS (tempo máximo)Se a bomba funcionar por mais de 10 minutos, a proteção contra funcionamento a seco entra em ação.
stopWithFault() (parada por falha)Para a bomba e trava a falha; para limpar, resolva o problema e reinicie a placa.
RELAY_ACTIVE_LOW (lógica do relé)Define o nível de saída conforme o módulo relé aciona com LOW ou HIGH.

Lendo a boia e controlando a bomba com o ESP32

No ESP32 o código é quase o mesmo; só mudam os pinos e a velocidade serial. Esta versão tem uma constante WET_LEVEL para cada boia: se você montar um sensor como NF, basta mudar o valor correspondente para HIGH e o resto da lógica continua igual. O código também envia o estado do nível para a porta serial a cada 5 segundos; depois você pode transformar essa linha num código que manda uma notificação para o seu celular via Wi-Fi. Atenção ao escolher os pinos: os GPIO 34, 35, 36 e 39 do ESP32 são só de entrada e não têm resistores de pull-up internos; se ligar uma boia nesses pinos, você precisa adicionar um pull-up externo de 10 kΩ. Também é melhor evitar pinos de strapping como GPIO 0, 2, 12 e 15; se a boia estiver fechada na hora de ligar, a placa pode entrar em modo de programação ou nem inicializar. O código compila tanto com o core ESP32 do Arduino 2.x quanto com o 3.x. Se você está começando com o ESP32, dê uma olhada primeiro no artigo O que é o ESP32?.

C++ (Arduino IDE)
1// ESP32: iki şamandıra + röle + buzzer / two floats + relay + buzzer
2const int FLOAT_PINS[2] = {27, 26};    // 0: üst / upper, 1: alt / lower
3const int WET_LEVEL[2]  = {LOW, LOW};  // NO: suda LOW, NC ise HIGH yap / NO: LOW when wet, set HIGH for NC
4const int RELAY_PIN  = 23;             // röle modülü IN / relay module IN
5const int BUZZER_PIN = 25;             // aktif buzzer / active buzzer
6const bool RELAY_ACTIVE_LOW = true;
7const unsigned long STABLE_MS  = 500;
8const unsigned long MAX_RUN_MS = 10UL * 60UL * 1000UL;
9
10bool wet[2];
11int lastRaw[2];
12unsigned long lastChange[2];
13bool pumpOn = false;
14bool fault = false;
15unsigned long pumpStart = 0;
16unsigned long lastReport = 0;
17
18void updateSensor(int i) {
19  int raw = digitalRead(FLOAT_PINS[i]);
20  if (raw != lastRaw[i]) {
21    lastRaw[i] = raw;
22    lastChange[i] = millis();
23  }
24  if (millis() - lastChange[i] >= STABLE_MS) {
25    wet[i] = (raw == WET_LEVEL[i]);
26  }
27}
28
29void setPump(bool on) {
30  pumpOn = on;
31  if (on) pumpStart = millis();
32  digitalWrite(RELAY_PIN, (on != RELAY_ACTIVE_LOW) ? HIGH : LOW);
33}
34
35void stopWithFault(const char *msg) {
36  setPump(false);
37  fault = true;
38  Serial.println(msg);
39}
40
41void setup() {
42  Serial.begin(115200);
43  pinMode(RELAY_PIN, OUTPUT);
44  setPump(false);                      // röleyi hemen kapat / switch relay off immediately
45  pinMode(BUZZER_PIN, OUTPUT);
46  digitalWrite(BUZZER_PIN, LOW);
47  for (int i = 0; i < 2; i++) {
48    pinMode(FLOAT_PINS[i], INPUT_PULLUP);
49  }
50  delay(10);
51  for (int i = 0; i < 2; i++) {
52    lastRaw[i] = digitalRead(FLOAT_PINS[i]);
53    wet[i] = (lastRaw[i] == WET_LEVEL[i]);
54    lastChange[i] = millis();
55  }
56  Serial.println("Depo kontrolu basladi / Tank control started");
57}
58
59void loop() {
60  updateSensor(0);
61  updateSensor(1);
62
63  if (!fault && wet[0] && !wet[1]) {   // üst suda, alt kuru / upper wet, lower dry
64    stopWithFault("HATA: sensor tutarsiz / ERROR: sensors inconsistent");
65  }
66  if (!fault && pumpOn && millis() - pumpStart > MAX_RUN_MS) {
67    stopWithFault("HATA: pompa cok uzun calisti / ERROR: pump ran too long");
68  }
69
70  if (!fault) {
71    if (!pumpOn && !wet[1]) {
72      setPump(true);
73      Serial.println("Pompa ACIK / Pump ON");
74    } else if (pumpOn && wet[0]) {
75      setPump(false);
76      Serial.println("Depo dolu, pompa KAPALI / Tank full, pump OFF");
77    }
78  }
79
80  digitalWrite(BUZZER_PIN, (fault && (millis() / 500) % 2) ? HIGH : LOW);
81
82  if (millis() - lastReport >= 5000) {   // 5 sn'de bir durum raporu / status report every 5 s
83    lastReport = millis();
84    Serial.printf("Ust/Upper: %d  Alt/Lower: %d  Pompa/Pump: %d  Ariza/Fault: %d\n",
85                  (int)wet[0], (int)wet[1], (int)pumpOn, (int)fault);
86  }
87}

Código MicroPython com o Raspberry Pi Pico

No Pico, montamos a mesma lógica com MicroPython. O parâmetro Pin.PULL_UP ativa o resistor de pull-up interno e pode ser usado em todos os pinos GP do Pico. A temporização usa time.ticks_ms() e time.ticks_diff(); o ticks_diff calcula a diferença corretamente mesmo quando o contador dá a volta. Como as saídas do Pico são de 3,3 V, cuidado ao escolher o relé: alguns módulos com optoacoplador alimentados com 5 V podem não desligar totalmente com um nível HIGH de 3,3 V. Usar um módulo relé com acionamento em 3,3 V ou um MOSFET de nível lógico é mais seguro. Se você salvar o código como main.py, o Pico o executa automaticamente toda vez que é ligado. Se você é novo no MicroPython, o artigo O que é o Raspberry Pi Pico? explica a instalação.

MicroPython
1from machine import Pin
2import time
3
4FLOAT_PINS = (2, 3)          # 0: üst şamandıra / upper float, 1: alt / lower
5WET_LEVEL = (0, 0)           # NO: suda 0, NC ise 1 / NO: 0 when wet, 1 for NC
6STABLE_MS = 500              # filtre süresi / filter time
7MAX_RUN_MS = 10 * 60 * 1000  # en uzun çalışma: 10 dk / max run: 10 min
8RELAY_ACTIVE_LOW = True      # röle LOW ile çekiyorsa / relay triggers on LOW
9
10relay = Pin(15, Pin.OUT, value=1 if RELAY_ACTIVE_LOW else 0)   # başlangıçta kapalı / off at start
11buzzer = Pin(16, Pin.OUT, value=0)
12sensors = [Pin(p, Pin.IN, Pin.PULL_UP) for p in FLOAT_PINS]
13time.sleep_ms(10)
14
15last_raw = [s.value() for s in sensors]
16wet = [last_raw[i] == WET_LEVEL[i] for i in range(2)]
17last_change = [time.ticks_ms(), time.ticks_ms()]
18pump_on = False
19fault = False
20pump_start = 0
21
22
23def set_pump(on):
24    global pump_on, pump_start
25    pump_on = on
26    if on:
27        pump_start = time.ticks_ms()
28    relay.value(0 if on == RELAY_ACTIVE_LOW else 1)
29
30
31def update(i):
32    raw = sensors[i].value()
33    now = time.ticks_ms()
34    if raw != last_raw[i]:                       # değer değişti / value changed
35        last_raw[i] = raw
36        last_change[i] = now
37    if time.ticks_diff(now, last_change[i]) >= STABLE_MS:
38        wet[i] = raw == WET_LEVEL[i]
39
40
41def stop_with_fault(msg):
42    global fault
43    set_pump(False)
44    fault = True
45    print(msg)
46
47
48print("Depo kontrolu basladi / Tank control started")
49while True:
50    update(0)
51    update(1)
52    if not fault and wet[0] and not wet[1]:      # üst suda, alt kuru / upper wet, lower dry
53        stop_with_fault("HATA: sensor tutarsiz / ERROR: sensors inconsistent")
54    if not fault and pump_on and time.ticks_diff(time.ticks_ms(), pump_start) > MAX_RUN_MS:
55        stop_with_fault("HATA: pompa cok uzun calisti / ERROR: pump ran too long")
56    if not fault:
57        if not pump_on and not wet[1]:           # su alt eşiğin altında / water below lower level
58            set_pump(True)
59            print("Pompa ACIK / Pump ON")
60        elif pump_on and wet[0]:                 # depo dolu / tank full
61            set_pump(False)
62            print("Depo dolu, pompa KAPALI / Tank full, pump OFF")
63    buzzer.value(1 if fault and (time.ticks_ms() // 500) % 2 else 0)
64    time.sleep_ms(10)

Como a boia se diferencia de outros sensores de nível de água

SensorSaídaPrósContras
Chave boiaDigital, ponto únicoBarata, não precisa de biblioteca, nenhum metal toca a água, vida longaSó informa o limite; sujeira e algas podem travar a boia
Sensor de nível de água com sondas condutivasAnalógicaMuito barato, dá um valor gradual conforme a área molhadaCorrói rápido por eletrólise, não serve para ficar submerso o tempo todo
Sensor sem contato XKC-Y25Digital, ponto únicoCola por fora do reservatório, sem precisar furarNão funciona através de paredes grossas ou metálicas, mais caro
Ultrassônico (HC-SR04, JSN-SR04T)Distância contínuaMede o nível em centímetros, não toca o líquidoSofre com espuma e vapor, tem zona cega; o HC-SR04 não é à prova d'água

A regra prática é simples: se você quer uma resposta confiável para “o reservatório está cheio ou vazio?”, a boia é a melhor escolha. Se quer mostrar o nível de enchimento em porcentagem, use um sensor ultrassônico; os detalhes estão no artigo Comparação de sensores de distância. Se não dá para furar o reservatório, o sensor sem contato XKC-Y25 resolve. Pense nos módulos com sondas só para experimentos ou medições de curta duração; o artigo Sensor de nível de água explica formas de aumentar a vida útil desse módulo. Em sistemas sérios, os dois costumam ser usados juntos: o sensor ultrassônico mostra o nível, enquanto a boia fica de reserva como proteção contra transbordamento.

Ideias de projetos com chave boia

  • Enchimento automático do reservatório: Encha sozinha a caixa d'água do telhado ou do jardim com duas boias e uma bomba.
  • Vaso inteligente e estação de irrigação: Deixe um sensor de umidade do solo decidir quando regar, enquanto a boia protege a bomba de funcionar a seco quando o reservatório de água esvaziar.
  • Reposição automática do aquário: Reponha aos poucos a água evaporada a partir de um reservatório separado; uma segunda boia montada como NF no alto funciona como proteção contra transbordamento.
  • Alarme de dreno do desumidificador e do ar-condicionado: Faça um buzzer tocar quando a bandeja de água encher, ou corte a alimentação do aparelho com um relé.
  • Monitoramento do reservatório da estufa: Envie o nível do reservatório para o seu celular com um ESP32 no seu projeto de estufa inteligente.
  • Alerta de alagamento no porão: Faça uma boia montada perto do piso enviar uma mensagem com um bot do Telegram quando a água acumular.

Erros comuns e como corrigi-los

SintomaCausa provávelSolução
O pino muda aleatoriamente o tempo todoINPUT_PULLUP esquecido, pino flutuandoConfigure o pinMode como INPUT_PULLUP ou adicione um pull-up externo de 10 kΩ
O estado está sempre invertidoO sensor funciona como NF ou foi montado de cabeça para baixoInverta a boia ou mude o valor de WET_LEVEL no código
A bomba fica ligando e desligando no limiteUma única boia e tempo de filtro curtoMonte uma histerese com duas boias e aumente o tempo de filtro para 1–2 segundos
A boia não responde de jeito nenhumChave reed soldada por sobrecarga ou tubo de vidro quebradoFaça um teste de continuidade com o multímetro e sempre chaveie a carga com um relé
A boia fica presa em cimaAcúmulo de sujeira, calcário ou algasLimpe o corpo e a boia regularmente e coloque um filtro na entrada de água
O Arduino reinicia quando a bomba ligaA bomba é alimentada pela mesma fonte e a tensão caiUse uma fonte separada para a bomba e faça a ligação do GND corretamente
O ESP32 não inicializa ou trava na partidaA boia está ligada a um pino de strappingUse pinos seguros, como GPIO 26 e 27
Se os fios da boia passarem de alguns metros, adicione um resistor de pull-up externo de 10 kΩ bem ao lado do pino e um capacitor de 100 nF entre o pino e o GND. A constante de tempo desse filtro RC é 10 kΩ × 100 nF = 1 ms; ele filtra o ruído elétrico sem deixar a resposta da boia perceptivelmente mais lenta. Você pode testar outros valores com a calculadora de constante de tempo RC. Isole também as emendas dos fios com espaguete termorretrátil para protegê-las da umidade.

Apesar do projeto barato e simples, a chave boia, combinada com montagem correta, leitura com pull-up, filtro por software e histerese, é a base de uma automação que funciona sem problemas por anos. Você vai encontrar a mesma lógica da chave reed em sensores de porta e o mesmo controle de bomba em sistemas de irrigação. No app BlueGrays você pode seguir passo a passo os projetos de leitura de relé reed, sensor de porta e estação de irrigação inteligente, com esquemas do circuito e códigos prontos, e adaptar o circuito deste artigo ao seu próprio projeto.

Perguntas frequentes

Como funciona uma chave boia?

Dentro da boia há um ímã em forma de anel e, dentro do corpo, uma chave reed num tubo de vidro. Conforme o nível da água sobe, a boia desliza pelo corpo e, quando o ímã chega à altura da chave reed, o contato fecha ou abre. Assim, o sensor se comporta como uma chave acionada pela água e fornece um sinal digital pelos seus dois fios.

A chave boia é NA ou NF?

O mesmo sensor pode ser usado das duas formas. Se você tirar o anel de retenção da ponta do corpo e recolocar a boia de cabeça para baixo, um sensor NA (normalmente aberto) vira NF (normalmente fechado). Como a direção de montagem também afeta o comportamento, o jeito mais seguro é fazer um teste de continuidade com o multímetro antes de instalar.

Preciso de resistor para uma chave boia?

No Arduino, no ESP32 e no Pico, se você ativar o resistor de pull-up interno do pino (INPUT_PULLUP ou Pin.PULL_UP), não precisa de resistor extra. Se o cabo tiver mais de alguns metros ou o ambiente tiver ruído, um pull-up externo de 10 kΩ e um capacitor de 100 nF deixam a leitura mais estável. Os pinos 34–39 do ESP32 não têm pull-up interno, então nesses pinos o resistor externo é obrigatório.

A chave boia pode acionar uma bomba diretamente?

A chave reed das boias pequenas de hobby geralmente consegue chavear no máximo 10 W e 0,5 A; a corrente de partida de uma bomba passa facilmente desse limite e solda os contatos. O certo é ligar a boia ao microcontrolador e acionar a bomba por meio de um módulo relé ou de um MOSFET. Assim você também pode adicionar, por software, proteção contra funcionamento a seco e contra tempo excessivo de funcionamento.

A chave boia funciona com o ESP32 e o Raspberry Pi Pico?

Sim. Como o sensor é só uma chave, a tensão de alimentação não importa e ele funciona sem problemas com placas de 3,3 V. Basta ligar um fio ao GND e o outro a um GPIO com o pull-up ativado. No ESP32, evite os pinos de strapping e os pinos 34–39, que não têm pull-up interno.

Dá para medir o nível de água em porcentagem com uma chave boia?

Uma única boia detecta apenas um limite. Você pode fazer um indicador aproximado de porcentagem montando três ou quatro boias em alturas diferentes no reservatório, mas para uma medição contínua e com precisão de centímetros um sensor de distância ultrassônico é mais adequado. Uma boa solução é usar o sensor ultrassônico como medidor de nível e a boia como proteção reserva contra transbordamento.

Ver todos os projetos