Componentes · 14 min de leitura

Relé SSR com Arduino: relé de estado sólido e controle de aquecedor

Como usar um relé SSR com Arduino? Relé mecânico vs SSR, tipos AC/DC, passagem por zero, dimensionamento do dissipador, acionamento com ESP32 em 3,3 V, código para Pico e dicas sobre SSR falsificado.

Um relé SSR (relé de estado sólido, em inglês Solid State Relay) é uma chave eletrônica que permite que um microcontrolador como o Arduino ligue e desligue um aquecedor de 230 V, uma lâmpada, uma resistência de forno ou uma chaleira elétrica com um pequeno sinal de 3–32 V, sem nenhuma peça móvel. Em um relé clássico, uma bobina puxa e solta um contato metálico; no SSR, quem faz esse trabalho é um semicondutor acionado por luz. Por isso ele não faz clique, seus contatos não se desgastam, não gera faíscas e dura anos mesmo sendo chaveado várias vezes por minuto. Em projetos de aquecimento que exigem chaveamento frequente, como termostatos, chocadeiras, panelas sous-vide e fornos, a dupla SSR e Arduino é praticamente o padrão.

Mas o SSR não é uma caixa mágica: cerca de 1–1,6 V caem sobre ele, o que significa muito calor em correntes altas; mesmo desligado, ele deixa passar alguns miliampères de fuga; um SSR com saída AC não consegue desligar uma carga DC; e boa parte dos SSRs baratos do mercado são cópias que não aguentam a corrente impressa na etiqueta. Neste post você vai aprender passo a passo o que há dentro de um SSR, como ele difere de um relé mecânico, o que significam os códigos DA, DD e AA da etiqueta, o que é passagem por zero, como dimensionar um dissipador, como controlar um aquecedor com segurança usando Arduino, ESP32 e Raspberry Pi Pico, e como reconhecer um SSR falsificado.

O que é um SSR (relé de estado sólido) e como ele funciona?

Dentro de um SSR existem dois mundos separados. No lado da entrada há um LED infravermelho com um circuito limitador de corrente; ele acende quando você aplica tensão nos terminais 3 e 4. No lado da saída há um circuito de disparo sensível à luz e o elemento de potência que realmente conduz a carga: nos modelos com saída AC, um triac ou dois tiristores (SCRs) em antiparalelo; nos modelos com saída DC, um MOSFET. Como só a luz passa entre entrada e saída, os dois lados ficam eletricamente isolados; o princípio é o mesmo de um optoacoplador, e normalmente oferece 2500 V ou mais de isolação. Assim, o GND do Arduino nunca toca a rede elétrica. Nos modelos AC, o triac se desliga sozinho no instante em que a corrente passa por zero; quando você retira o sinal de entrada, a carga desliga em no máximo meio ciclo (10 ms em 50 Hz).

CaracterísticaValor típico (classe SSR-25DA)
Tensão de entrada (controle)3–32 V DC
Corrente de entradaCerca de 5–15 mA
Tensão de saída (carga)24–380 V AC
Corrente nominal de saída25 A (só com um dissipador adequado)
Queda de tensão quando ligado1,0–1,6 V
Corrente de fuga quando desligadoAlguns mA (1–10 mA, conforme o modelo)
Isolação2500 V AC ou mais
Tempo de ligar / desligar≤ 10 ms (por causa da passagem por zero)
Terminais1–2: carga, 3 (+) e 4 (−): entrada de controle

A diferença entre um SSR e um relé mecânico

Relé mecânico usado em projetos com Arduino
Um relé mecânico clássico: a bobina puxa fisicamente os contatos metálicos. No SSR, um semicondutor sem peças móveis faz o mesmo trabalho.
CaracterísticaRelé mecânicoSSR (relé de estado sólido)
Elemento de chaveamentoBobina + contato metálicoTriac, tiristor ou MOSFET
SomFaz cliqueSilencioso
Vida útilCerca de 100.000 chaveamentos com cargaChaveamentos praticamente ilimitados
Faíscas e ruídoForma arco quando o contato abreMuito baixo nos modelos com passagem por zero
Perda quando ligadoMuito baixa (contato na casa dos miliohms)Queda de 1–1,6 V, esquenta
Fuga quando desligadoNenhuma, separação totalAlguns mA de corrente de fuga
AC e DCChaveia os doisSó AC ou só DC, conforme o tipo
Corrente de controle70–90 mA para a bobina (via módulo)5–15 mA, pode ligar direto em um pino
Modo de falhaO contato pode grudar ou ficar abertoGeralmente entra em curto, ou seja, fica sempre ligado
PreçoBaratoMais caro, e ainda precisa de dissipador
Uma regra simples: escolha um SSR se a carga for chaveada com frequência (termostato, aquecimento proporcional ao tempo, dezenas de vezes por minuto) e for resistiva. Um relé mecânico faz mais sentido se a carga liga e desliga só algumas vezes por dia, se você aciona cargas AC e DC na mesma placa ou se precisa de separação total quando desligado. Para detalhes do lado mecânico, veja O que é um módulo relé?.

Tipos DA e AA: o que significam DA, DD e AA na etiqueta do SSR?

O código de duas letras na etiqueta do SSR indica primeiro o tipo de entrada e depois o tipo de saída. D significa DC e A significa AC. Ou seja, um SSR-25DA não é um “relé DC”; é um relé controlado por DC que chaveia uma carga AC, e é o tipo mais usado em projetos com Arduino. O SSR-25DD é controlado por DC e chaveia uma carga DC (por exemplo, uma manta aquecedora de 12 V ou uma bomba). O SSR-25AA precisa de tensão da rede também na entrada; não é usado diretamente com um microcontrolador e é escolhido principalmente quando um termostato ou uma chave aciona uma carga grande. Se bater a dúvida, o post sobre a diferença entre corrente AC e DC ajuda a revisar o básico.

Código da etiquetaEntrada (controle)Saída (carga)Uso típico
DA (ex.: SSR-25DA)3–32 V DC24–380 V ACAquecedor, lâmpada ou forno de 230 V com Arduino
DD (ex.: SSR-25DD)3–32 V DC5–60 V DC (varia conforme o modelo)Manta aquecedora de 12/24 V, bomba, fita de LED
AA (ex.: SSR-25AA)90–250 V AC24–380 V ACAcionar uma carga AC grande com chave ou termostato
Módulo G3MB-202P5 V DC100–240 V AC, máx. 2 ACargas AC pequenas: lâmpada, ventilador pequeno
Não dá para chavear uma carga DC com um SSR de saída AC. O triac só desliga quando a corrente cai a zero; em DC a corrente nunca chega a zero, então, depois que a carga liga, ela nunca mais desliga. Tentar acionar uma fita de LED de 12 V ou um motor CC com um SSR-DA ou um G3MB-202P é o erro mais comum. Para cargas DC, use um SSR tipo DD ou um MOSFET; nos tipos DD, preste atenção também à polaridade + e − dos terminais de saída.

O que é passagem por zero (zero-cross) e por que ela importa?

A tensão da rede é uma senoide de 50 Hz e passa por zero a cada 10 ms. Quando você dá o sinal de ligar a um SSR com passagem por zero, ele não liga a saída imediatamente; espera o primeiro instante em que a tensão se aproxima de zero. Assim, o aquecedor ou a lâmpada incandescente liga perto do zero, e não no pico de tensão de cerca de 325 V; a corrente de partida, o ruído eletromagnético e o zumbido diminuem bastante. Isso é perfeito para cargas resistivas. O preço: com um SSR de passagem por zero você não consegue dimerizar uma lâmpada por controle de ângulo de fase; para isso são necessários modelos “random turn-on”, que ligam na hora. Pelo mesmo motivo, o sinal analogWrite de 490 Hz do Arduino não faz sentido para um SSR, porque o sinal muda várias vezes a cada meio ciclo e o resultado fica aleatório (veja o post sobre PWM para entender por que a frequência importa). O jeito certo de ajustar a potência de um aquecedor é o controle proporcional ao tempo: por exemplo, mantê-lo ligado por 1,2 s e desligado por 0,8 s em uma janela de 2 segundos para obter 60% de potência. Como 2 segundos equivalem a 200 meios ciclos, esse método tem resolução de cerca de 0,5%.

Necessidade de dissipador: quanto um SSR esquenta?

O contato de um relé mecânico tem resistência quase nula, mas o triac de um SSR derruba cerca de 1,2–1,6 V enquanto conduz. A potência dissipada é aproximadamente P = Vqueda × I. Um aquecedor de 2000 W consome I = 2000 / 230 ≈ 8,7 A em 230 V; supondo uma queda de 1,3 V no SSR, P ≈ 1,3 × 8,7 ≈ 11 W de calor são liberados. Isso basta para esquentar a ponta de um ferro de solda pequeno, e o corpo de um SSR sem dissipador chega a temperaturas perigosas em poucos minutos. Como o invólucro plástico sozinho só aguenta algo em torno de 2–3 W, o limite prático sem dissipador é de cerca de 2 A. Parafuse o SSR em um dissipador de alumínio com uma camada fina de pasta térmica, garanta que a base metálica não passe de 80 °C e escolha uma corrente nominal com folga: a corrente nominal do SSR deve ser pelo menos 2 vezes a corrente da carga em cargas resistivas, e 3–4 vezes em cargas indutivas, como motores e transformadores. Para os cálculos de potência e corrente, você pode usar a calculadora da lei de Ohm e o post sobre cálculo de potência elétrica.

Corrente da carga (230 V)Carga de exemploCalor no SSR (≈1,3 V)Recomendação de refrigeração
0,5 ALâmpada incandescente de 100 W≈ 0,7 WNão precisa de dissipador
2 AAquecedor de 450 W≈ 2,6 WNo limite; recomenda-se um dissipador pequeno
4,3 AAquecedor de 1000 W≈ 5,6 WDissipador médio (≈ 5 °C/W ou melhor)
8,7 AAquecedor de 2000 W≈ 11 WDissipador grande (≈ 2,5 °C/W) e SSR de pelo menos 25 A
13 AAquecedor de 3000 W≈ 17 WDissipador com ventoinha e SSR de 40 A de marca original

Ligação do SSR: Arduino Uno, ESP32 e Raspberry Pi Pico

LigaçãoArduino UnoESP32Raspberry Pi Pico
Pino de controleD8GPIO 26GP15
Entrada + do SSR (3)Direto no D85V/VIN (via transistor)VBUS (via transistor)
Entrada − do SSR (4)GNDColetor do NPNColetor do NPN
Base do NPN (BC547 / 2N2222)-1 kΩ para o GPIO 26, 10 kΩ para o GND1 kΩ para o GP15, 10 kΩ para o GND
Emissor do NPN-GNDGND
Dados do DS18B20D2GPIO 4GP16
DS18B20 VCC5V3V33V3(OUT)
Pull-up de 4,7 kΩDados – 5VDados – 3V3Dados – 3V3

Como os pinos do Arduino Uno fornecem 5 V e entregam até 20 mA com folga, você pode ligar a entrada de um SSR-DA diretamente entre o D8 e o GND; a entrada tem um limitador de corrente embutido, então não precisa de resistor extra. Já o ESP32 e o Pico trabalham com 3,3 V. Mesmo que a etiqueta diga “3–32 V DC”, 3,3 V está muito perto do limite inferior dessa faixa; quando o pino cai para 3,1 V sob carga, ou com um SSR copiado que precisa de uma tensão de entrada maior, o relé às vezes dispara e às vezes não. Além disso, os pinos do Pico vêm configurados por padrão para apenas cerca de 4 mA. Por isso, nas placas de 3,3 V, o jeito mais confiável é acionar o SSR a partir de 5 V por meio de um transistor NPN: o GPIO vai até a base do transistor por um resistor de 1 kΩ, o terminal + do SSR vai para 5 V, o terminal − para o coletor e o emissor para o GND. Quando o GPIO vai para HIGH, o transistor conduz e o SSR enxerga cerca de 4,8 V. Um resistor de 10 kΩ entre a base e o GND impede que o aquecedor ligue sozinho quando o pino fica flutuando enquanto a placa liga ou reinicia. Todos os GNDs precisam ser comuns; você descobre o motivo no post sobre GND comum.

  1. Primeiro desconecte totalmente a rede elétrica: tire o plugue da tomada ou desligue o disjuntor, e confirme que não há tensão nos bornes.
  2. Parafuse o SSR no dissipador com uma camada fina de pasta térmica; ligue o dissipador e a caixa metálica ao aterramento de proteção (fio verde-amarelo).
  3. Ligue o lado de controle: conecte os terminais 3 (+) e 4 (−) ao Arduino ou ao transistor conforme a tabela acima, carregue o código sem a rede conectada e veja o LED do SSR piscar.
  4. No lado da carga, ligue a fase (fio marrom) ao terminal 1 do SSR e o terminal 2 ao aquecedor; o neutro (azul) vai direto para o aquecedor. Coloque na linha de fase um fusível adequado à corrente da carga.
  5. Escolha a bitola do cabo conforme a corrente: pelo menos 1,5 mm² até 10 A, 2,5 mm² para 16 A; coloque terminais tubulares (ponteiras) nos cabos flexíveis e aperte bem os parafusos.
  6. Ligue em série com o aquecedor um fusível térmico ou um termostato bimetálico que funcione independentemente do Arduino; ele é a última linha de defesa se o SSR falhar em curto.
  7. Coloque toda a parte da rede elétrica em uma caixa isolante com tampa; não energize antes de fechar a caixa nem sem uma linha de alimentação protegida por dispositivo DR (diferencial residual).
230 V pode matar. Embora a entrada do SSR seja isolada, os terminais de saída e os bornes nunca devem ser tocados com o circuito em funcionamento; além disso, o SSR não oferece separação total nem quando está desligado: por causa da corrente de fuga, pode haver tensão perigosa nos terminais da carga. Sempre tire o plugue da tomada antes de fazer manutenção. Se você nunca trabalhou com tensão da rede, peça para alguém experiente conferir essa parte, ou pratique primeiro com uma carga DC de 12 V e um SSR tipo DD.

Controle de aquecedor com Arduino: termostato proporcional ao tempo

O programa abaixo mede a temperatura com um sensor DS18B20 e ajusta a potência do aquecedor usando janelas de tempo de 2 segundos. O alvo é 40 °C e a banda proporcional é de 5 °C: a 35 °C ou menos o aquecedor funciona a 100%, a 37,5 °C a 50% e a 40 °C a 0%. Isso reduz o grande sobressinal (overshoot) dos termostatos simples liga-desliga. O código não usa delay(); a medição e a temporização das janelas são feitas com millis(), e a conversão do sensor, que leva cerca de 750 ms, termina em segundo plano sem espera. Se o sensor se desconectar (-127 °C) ou a temperatura passar do limite de segurança de 70 °C, o aquecedor é desligado na hora. Para detalhes da ligação do sensor, veja o post sobre o sensor de temperatura DS18B20; para compilar o código, instale as bibliotecas OneWire e DallasTemperature pelo Gerenciador de Bibliotecas.

C++ (Arduino IDE)
1#include <OneWire.h>
2#include <DallasTemperature.h>
3
4const uint8_t SSR_PIN = 8;              // SSR giriş + (3) / SSR input + (3)
5const uint8_t ONE_WIRE_PIN = 2;         // DS18B20 veri / DS18B20 data
6const float HEDEF_C = 40.0;             // hedef sıcaklık / target temperature
7const float BANT_C = 5.0;               // oransal bant / proportional band
8const float EMNIYET_C = 70.0;           // üst güvenlik sınırı / safety cutoff
9const unsigned long PENCERE_MS = 2000;  // zaman penceresi / time window
10
11OneWire oneWire(ONE_WIRE_PIN);
12DallasTemperature sensors(&oneWire);
13
14unsigned long pencereBasi = 0;
15unsigned long sonOlcum = 0;
16unsigned long acikSure = 0;             // pencere içindeki açık süre / on-time in window
17
18void setup() {
19  pinMode(SSR_PIN, OUTPUT);
20  digitalWrite(SSR_PIN, LOW);           // açılışta ısıtıcı kapalı / heater off at start
21  Serial.begin(9600);
22  sensors.begin();
23  sensors.setWaitForConversion(false);  // bloklamadan ölç / non-blocking conversion
24  sensors.requestTemperatures();        // ilk ölçümü başlat / start first conversion
25}
26
27void loop() {
28  unsigned long simdi = millis();
29
30  if (simdi - sonOlcum >= 1000) {       // saniyede bir ölç / measure once per second
31    sonOlcum = simdi;
32    float t = sensors.getTempCByIndex(0);
33    sensors.requestTemperatures();      // sonraki ölçümü başlat / start next conversion
34
35    float oran = 0.0;                   // güç oranı 0..1 / power ratio 0..1
36    if (t != DEVICE_DISCONNECTED_C && t < EMNIYET_C) {
37      oran = constrain((HEDEF_C - t) / BANT_C, 0.0, 1.0);
38    }
39    acikSure = (unsigned long)(oran * PENCERE_MS);
40
41    Serial.print(F("Sicaklik / Temp: "));
42    Serial.print(t, 1);
43    Serial.print(F(" C  Guc / Power: %"));
44    Serial.println(oran * 100.0, 0);
45  }
46
47  if (simdi - pencereBasi >= PENCERE_MS) {
48    pencereBasi += PENCERE_MS;          // yeni pencere / new window
49  }
50  digitalWrite(SSR_PIN, (simdi - pencereBasi < acikSure) ? HIGH : LOW);
51}

SSR com ESP32: acionamento em 3,3 V e termostato com histerese

No ESP32 vamos ver outro método: controle liga-desliga com histerese. O aquecedor liga quando a temperatura cai abaixo de 39 °C e desliga acima de 41 °C; a zona morta de 2 °C impede que o SSR fique ligando e desligando o tempo todo por causa de pequenas oscilações do sensor. O SSR é acionado a partir de 5 V por um transistor NPN ligado ao GPIO 26, como na tabela. Escolhemos o GPIO 26 de propósito: GPIO 0, 2, 5, 12 e 15 são pinos que definem o comportamento de boot da placa na inicialização, e uma carga ligada a eles pode ser acionada sem querer ao energizar. O código compila igual no core do Arduino para ESP32 2.x e 3.x; se você usa o core 3.x, basta instalar a versão 2.3.8 ou mais nova da biblioteca OneWire. Como próximo passo, você pode levar esse termostato para o Wi-Fi e definir a temperatura alvo pelo celular via Home Assistant.

C++ (Arduino IDE)
1#include <OneWire.h>
2#include <DallasTemperature.h>
3
4const int SSR_PIN = 26;            // NPN tabanına 1 kΩ ile / to NPN base via 1 kΩ
5const int ONE_WIRE_PIN = 4;        // DS18B20 veri / DS18B20 data
6const float HEDEF_C = 40.0;        // hedef sıcaklık / target temperature
7const float HISTEREZIS_C = 1.0;    // ±1 °C ölü bant / ±1 °C dead band
8const float EMNIYET_C = 70.0;      // güvenlik sınırı / safety cutoff
9
10OneWire oneWire(ONE_WIRE_PIN);
11DallasTemperature sensors(&oneWire);
12
13bool isitici = false;
14unsigned long sonOlcum = 0;
15
16void setup() {
17  pinMode(SSR_PIN, OUTPUT);
18  digitalWrite(SSR_PIN, LOW);      // açılışta kapalı / off at start
19  Serial.begin(115200);
20  sensors.begin();
21}
22
23void loop() {
24  if (millis() - sonOlcum < 1000) return;
25  sonOlcum = millis();
26
27  sensors.requestTemperatures();   // yaklaşık 750 ms bekler / waits about 750 ms
28  float t = sensors.getTempCByIndex(0);
29
30  if (t == DEVICE_DISCONNECTED_C || t >= EMNIYET_C) {
31    isitici = false;               // arıza ya da aşırı sıcaklık / fault or overheat
32  } else if (t < HEDEF_C - HISTEREZIS_C) {
33    isitici = true;                // soğuk: ısıt / cold: heat
34  } else if (t > HEDEF_C + HISTEREZIS_C) {
35    isitici = false;               // sıcak: kapat / hot: switch off
36  }
37  digitalWrite(SSR_PIN, isitici ? HIGH : LOW);
38
39  Serial.printf("Sicaklik / Temp: %.1f C  SSR: %s\n", t, isitici ? "ACIK / ON" : "KAPALI / OFF");
40}

Controle de SSR com Raspberry Pi Pico e MicroPython

No Raspberry Pi Pico, os módulos onewire e ds18x20 já vêm embutidos no MicroPython; você não precisa copiar nenhum arquivo extra. O código abaixo faz o mesmo controle proporcional ao tempo do exemplo para Arduino: o DS18B20 fica no GP16, e a base do transistor que aciona o SSR é ligada ao GP15 por um resistor de 1 kΩ. Ligue o terminal + do SSR ao pino VBUS (pino físico 40), que fornece 5 V quando o Pico é alimentado pela USB. Para a temporização são usadas time.ticks_ms() e time.ticks_diff(); como essas funções dão a diferença correta mesmo quando o contador dá a volta, são seguras em um termostato que fica funcionando por muito tempo. Se o sensor não for encontrado ou uma leitura falhar, a taxa de potência vai para zero, então o aquecedor fica desligado. Se é a primeira vez que você usa o Pico, veja O que é o Raspberry Pi Pico para instalar o MicroPython.

MicroPython
1from machine import Pin
2import onewire, ds18x20, time
3
4ssr = Pin(15, Pin.OUT, value=0)                       # NPN tabanı (1 kΩ) / NPN base (1 kΩ)
5sensor = ds18x20.DS18X20(onewire.OneWire(Pin(16)))    # DS18B20 veri / DS18B20 data
6roms = sensor.scan()
7
8HEDEF_C = 40.0      # hedef sıcaklık / target temperature
9BANT_C = 5.0        # oransal bant / proportional band
10EMNIYET_C = 70.0    # güvenlik sınırı / safety cutoff
11PENCERE_MS = 2000   # zaman penceresi / time window
12
13def olcum_baslat():
14    try:
15        sensor.convert_temp()                         # dönüşümü başlat / start conversion
16    except Exception:
17        pass                                          # sensör yok / no sensor
18
19oran = 0.0
20son_olcum = time.ticks_ms()
21pencere_basi = time.ticks_ms()
22olcum_baslat()
23
24while True:
25    simdi = time.ticks_ms()
26    if time.ticks_diff(simdi, son_olcum) >= 1000:     # saniyede bir / once per second
27        son_olcum = simdi
28        try:
29            t = sensor.read_temp(roms[0])
30            if t >= EMNIYET_C:
31                oran = 0.0                            # aşırı sıcaklık / overheat
32            else:
33                oran = min(max((HEDEF_C - t) / BANT_C, 0.0), 1.0)
34            print("Sicaklik / Temp: {:.1f} C  Guc / Power: %{:.0f}".format(t, oran * 100))
35        except Exception:
36            oran = 0.0                                # hata: ısıtıcı kapalı / error: heater off
37            print("Sensor hatasi / Sensor error")
38        olcum_baslat()                                # sonraki ölçüm / next conversion
39    if time.ticks_diff(simdi, pencere_basi) >= PENCERE_MS:
40        pencere_basi = time.ticks_add(pencere_basi, PENCERE_MS)   # yeni pencere / new window
41    ssr.value(1 if time.ticks_diff(simdi, pencere_basi) < oran * PENCERE_MS else 0)

Alerta de SSR falsificado: por que um relé com etiqueta de 40 A queima?

Boa parte dos SSRs baratos do mercado são cópias que imitam a aparência de uma marca conhecida. Ao desmontar muitos relés falsos de 40 A, encontra-se dentro um pequeno triac de 12–16 A; alguns não têm circuito de passagem por zero nem snubber na saída, e a isolação entre entrada e saída é bem menor do que a impressa na etiqueta. Esses relés superaquecem mesmo com poucos ampères, o invólucro plástico amolece e geralmente falham em curto, ou seja, o aquecedor nunca mais desliga. Por isso, nunca trate o SSR como o único elemento de segurança em um projeto de aquecimento. Você reconhece um SSR falsificado por estes sinais:

  • Preço e peso: custa várias vezes menos que os SSRs de marca original e parece visivelmente mais leve na mão.
  • Mesmo invólucro, corrente diferente: versões de 10 A, 25 A e 40 A vendidas exatamente no mesmo tamanho, pelo mesmo preço e com o mesmo peso.
  • Falhas de impressão e etiqueta: logotipo apagado ou desalinhado, nome da marca com erro de grafia, ou ausência de número de série e data de fabricação.
  • Resina de encapsulamento: o preenchimento na parte de baixo é irregular, com bolhas ou parcialmente vazio.
  • Teste de aquecimento: com carga, meça a temperatura da base metálica com um termômetro durante a primeira hora; se ela passar rapidamente de 60 °C mesmo com metade da corrente nominal, não confie no relé.
  • A solução segura: compre marcas conhecidas como Omron, Crydom, Carlo Gavazzi ou Schneider de um vendedor confiável; use um SSR de origem desconhecida com no máximo um quarto da corrente nominal.

Ideias de projetos com SSR

  • Termostato inteligente: mantenha um aquecedor de ambiente na temperatura alvo; veja o post sobre termostato com Arduino para a lógica básica.
  • Sous-vide e iogurteira: combine o controle proporcional ao tempo com controle PID para manter a água estável dentro de ±0,5 °C.
  • Chocadeira: mantenha 37,5 °C estáveis por dias; adicione um segundo sensor para monitorar a umidade.
  • Mini forno de refusão (reflow): aqueça um pequeno forno elétrico seguindo um perfil de solda com um termopar MAX6675 e um SSR.
  • Tomada inteligente: ligue e desligue aparelhos de 230 V pelo celular com um ESP32; detalhes no post sobre tomada inteligente com ESP32.
  • Aquecedor para canos e estufa: use um alarme de geada para ligar o cabo aquecedor quando a temperatura cair para 2 °C.

Erros comuns e como corrigi-los

SintomaCausa provávelSolução
O LED do SSR acende, mas a carga não funcionaO circuito da carga está aberto, o fusível queimou ou a corrente da carga está abaixo da corrente mínima do SSRVerifique as linhas de fase e neutro; para cargas muito pequenas, use um relé mecânico
A carga nunca desligaUm SSR de saída AC está acionando uma carga DC, ou o SSR falhou em curtoPara DC, use um SSR tipo DD ou um MOSFET; troque o SSR com defeito
Uma lâmpada LED fica acesa fraquinha ou pisca quando desligadaA corrente de fuga do SSRAdicione um resistor de carga adequado em paralelo com a carga, ou escolha um relé mecânico para essa carga
O multímetro mostra 230 V na saída de um SSR desligadoNormal sem carga ligada, por causa da corrente de fugaFaça a medição com a carga conectada
O SSR e o dissipador esquentam muitoDissipador pequeno demais, sem pasta térmica, corrente alta demais ou SSR falsificadoUse um dissipador maior, recalcule a corrente, use um SSR de marca original
Às vezes não dispara com ESP32 ou Pico3,3 V fica no limite inferior da faixa de entradaAcione o SSR a partir de 5 V por um transistor NPN
O aquecedor liga por um instante enquanto a placa inicializaO pino fica flutuando na inicialização, ou foi escolhido um pino de bootAdicione um pull-down de 10 kΩ, use um pino seguro como o GPIO 26
O ajuste de potência com analogWrite é inconsistenteUm SSR com passagem por zero não acompanha PWM rápidoUse uma janela proporcional ao tempo de 1–2 segundos

Bem escolhido e bem refrigerado, o SSR é a forma mais silenciosa e duradoura de controlar um aquecedor em projetos com Arduino; basta escolher um SSR compatível com o tipo de carga, calcular a corrente com folga, tomar cuidado com relés falsificados e sempre adicionar uma proteção térmica independente. Se quiser entender primeiro a lógica dos relés e a medição de temperatura passo a passo, no app BlueGrays você pode explorar projetos como acender uma lâmpada de 220 V com botão e controle remoto, iluminação inteligente com ESP32 e medição de temperatura, com esquemas do circuito e códigos.

Perguntas frequentes

Dá para ligar um relé SSR diretamente no Arduino?

Sim. Com um SSR de entrada DC como o SSR-25DA, você pode ligar o terminal 3 (+) a um pino digital do Arduino e o terminal 4 (−) ao GND; como a entrada consome só 5–15 mA e tem um limitador de corrente embutido, não precisa de resistor extra. O lado da carga é totalmente isolado do Arduino e deve ser ligado separadamente, seguindo as normas de instalação elétrica.

O relé SSR funciona com 3,3 V?

A maioria dos SSRs com entrada de 3–32 V dispara com 3,3 V, mas esse valor está muito perto do limite inferior e não é confiável, principalmente com relés copiados. Ao usar um ESP32 ou um Raspberry Pi Pico, acionar o SSR a partir de 5 V por um transistor NPN como o BC547 ou o 2N2222 é a solução mais robusta.

Por que o SSR esquenta, e o dissipador é obrigatório?

Cerca de 1–1,6 V caem sobre o SSR quando ele conduz, e essa tensão multiplicada pela corrente vira calor; em 10 A são cerca de 13 W. Um SSR sem dissipador geralmente funciona com segurança até uns 2 A; em correntes maiores, um dissipador de alumínio montado com pasta térmica é indispensável.

Dá para controlar um motor CC ou uma fita de LED com SSR?

Só com um SSR de saída DC (tipo DD). Os SSRs de saída AC com etiqueta DA ou AA usam triac e, uma vez ligados em DC, nunca desligam. Para cargas DC de baixa tensão, um MOSFET de nível lógico costuma ser uma opção mais barata e mais eficiente.

Dá para dimerizar uma lâmpada com um SSR de passagem por zero?

Não. Um SSR com passagem por zero só consegue ligar quando a tensão está perto de zero, então não faz controle de ângulo de fase; a lâmpada ou acende totalmente ou fica piscando. Para dimerizar, é preciso um SSR random turn-on (que liga na hora) com um circuito detector de passagem por zero, ou um módulo dimmer AC pronto; para aquecedores, o método certo é o controle proporcional ao tempo com um SSR de passagem por zero.

Por que eu meço tensão na saída de um SSR desligado?

Mesmo desligados, os SSRs deixam passar alguns miliampères de corrente de fuga por causa do circuito snubber na saída e da estrutura do semicondutor. Sem carga ligada, a alta resistência de entrada do multímetro mostra quase toda a tensão da rede a partir dessa corrente minúscula; isso é normal. Mas, por esse motivo, nunca use um SSR como seccionador de segurança e sempre tire o plugue da tomada antes da manutenção.

Ver todos os projetos
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
Acender uma lâmpada de 220V com botão de pressão
AR-19Avançado
Premium

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.

4.4(30)
38
Ligar e desligar uma lâmpada de 220V com botão
AR-20Avançado
Premium

Ligar e desligar uma lâmpada de 220V com botão

Quer ligar e desligar uma lâmpada de casa com um pequeno botão? Ao pressionar o botão, o Arduino aciona um relé e a lâmpada acende; ao pressionar novamente, ela apaga.

4.5(33)
44
Acender uma lâmpada de 220V com controle remoto
AR-21Avançado
Premium

Acender uma lâmpada de 220V com controle remoto

Ligue e desligue uma lâmpada de casa com o controle da TV, sem sair do sofá. O Arduino lê o sinal de luz invisível do controle; o botão de ligar aciona o relé e acende a lâmpada, e o botão de…

4.4(23)
31
Medição de temperatura com NTC e display LCD 2x16
AR-44Iniciante
Premium

Medição de temperatura com NTC e display LCD 2x16

Meça a temperatura ao seu redor com um sensor que parece uma pequena conta. Esse componente, chamado NTC, deixa a eletricidade passar com mais facilidade à medida que aquece; o Arduino lê essa…

4.5(33)
44
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
Iluminação inteligente com ESP32 (PIR + LDR + relé + OLED)
ES-37Avançado
Premium

Iluminação inteligente com ESP32 (PIR + LDR + relé + OLED)

Transforme a iluminação do corredor, banheiro ou despensa em iluminação inteligente com ESP32! Com um sensor de movimento PIR, um sensor de luz LDR e um módulo relé, montamos o cenário clássico de "acender a luz ao detectar movimento no escuro" — se o ambiente já estiver claro, o movimento NÃO aciona a luz, economizando energia durante o dia. A luz fica acesa por 30 segundos; se o movimento continuar, o temporizador reinicia e a luz permanece acesa por mais tempo.

4.3(6)
11
Iluminação inteligente de escadas e corredores
AR-82Intermediário
Premium

Iluminação inteligente de escadas e corredores

Ao entrar na escada ou no corredor, as luzes acendem uma a uma no sentido em que você caminha.

5.0(36)
52