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.

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ística | Valor típico (modelo vertical pequeno) |
|---|---|
| Elemento sensor | Chave reed + ímã em anel dentro da boia |
| Saída | Contato seco (aberto / fechado), 2 fios, sem polaridade |
| Tipo de contato | NA ou NF (muda ao inverter a boia) |
| Potência máx. de chaveamento | 10 W |
| Tensão máx. de chaveamento | 100 V DC |
| Corrente máx. de chaveamento | 0,5 A |
| Resistência de contato | 100 mΩ ou menos |
| Material do corpo e da boia | PP (polipropileno) |
| Temperatura de operação | −10 … +85 °C |
| Montagem | Corpo 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.
| Montagem | Sem água (boia embaixo) | Com água (boia em cima) | Pino com INPUT_PULLUP |
|---|---|---|---|
| NA (normalmente aberto) | Contato aberto | Contato fechado | HIGH no seco, LOW na água |
| NF (normalmente fechado) | Contato fechado | Contato aberto | LOW no seco, HIGH na água |
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ção | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Boia superior (reservatório cheio) | D2 | GPIO 27 | GP2 |
| Boia inferior (reservatório vazio) | D3 | GPIO 26 | GP3 |
| Outros fios das boias | GND | GND | GND |
| IN do módulo relé | D7 | GPIO 23 | GP15 |
| Buzzer ativo (+) | D8 | GPIO 25 | GP16 |
| VCC do módulo relé | 5V | VIN (5 V) | VBUS (5 V) |
Passo a passo: lendo a boia pela primeira vez
- 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.
- 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.
- Carregue o código abaixo; ele configura o pino como INPUT_PULLUP, então não precisa de resistor extra.
- Abra o Monitor Serial a 9600 baud.
- 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.
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.
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ódigo | Funçã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?.
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.
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
| Sensor | Saída | Prós | Contras |
|---|---|---|---|
| Chave boia | Digital, ponto único | Barata, não precisa de biblioteca, nenhum metal toca a água, vida longa | Só informa o limite; sujeira e algas podem travar a boia |
| Sensor de nível de água com sondas condutivas | Analógica | Muito barato, dá um valor gradual conforme a área molhada | Corrói rápido por eletrólise, não serve para ficar submerso o tempo todo |
| Sensor sem contato XKC-Y25 | Digital, ponto único | Cola por fora do reservatório, sem precisar furar | Não funciona através de paredes grossas ou metálicas, mais caro |
| Ultrassônico (HC-SR04, JSN-SR04T) | Distância contínua | Mede o nível em centímetros, não toca o líquido | Sofre 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
| Sintoma | Causa provável | Solução |
|---|---|---|
| O pino muda aleatoriamente o tempo todo | INPUT_PULLUP esquecido, pino flutuando | Configure o pinMode como INPUT_PULLUP ou adicione um pull-up externo de 10 kΩ |
| O estado está sempre invertido | O sensor funciona como NF ou foi montado de cabeça para baixo | Inverta a boia ou mude o valor de WET_LEVEL no código |
| A bomba fica ligando e desligando no limite | Uma única boia e tempo de filtro curto | Monte uma histerese com duas boias e aumente o tempo de filtro para 1–2 segundos |
| A boia não responde de jeito nenhum | Chave reed soldada por sobrecarga ou tubo de vidro quebrado | Faça um teste de continuidade com o multímetro e sempre chaveie a carga com um relé |
| A boia fica presa em cima | Acúmulo de sujeira, calcário ou algas | Limpe o corpo e a boia regularmente e coloque um filtro na entrada de água |
| O Arduino reinicia quando a bomba liga | A bomba é alimentada pela mesma fonte e a tensão cai | Use uma fonte separada para a bomba e faça a ligação do GND corretamente |
| O ESP32 não inicializa ou trava na partida | A boia está ligada a um pino de strapping | Use pinos seguros, como GPIO 26 e 27 |
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.
Projetos para montar depois desta leitura
Ver todos os projetos
Controle de LED com botão (momentâneo)
É como uma campainha: a luz fica acesa enquanto você pressiona o botão e apaga quando você solta.

Controle de LED com botão no ESP32 (momentâneo)
O LED acende enquanto o botão está pressionado e apaga ao soltá-lo. Mostra como usar o pino de entrada digital e o resistor pull-up interno do ESP32. O modo INPUT_PULLUP dispensa um resistor externo.

Uso do buzzer
Já se perguntou como uma campainha ou um alarme produz som? O Arduino faz um pequeno buzzer emitir bipes em intervalos curtos: bipe, pausa, bipe, pausa.

Leitura de uma chave reed
Você já teve curiosidade sobre a chave magnética dos alarmes de portas e janelas?

Sensor de porta com chave reed
Saiba se a porta está aberta ou fechada só de olhar uma luz. Você fixa um pequeno ímã na porta e uma chave sensível ao ímã no batente; quando a porta está fechada, os dois ficam lado a lado e o LED…

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.

Acender uma lâmpada de 220V com botão de pressão
Enquanto você mantém o botão pressionado, uma lâmpada de 220 volts fica acesa e apaga assim que você solta.
Mais artigos
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

