MOSFET com Arduino: fita LED, motor e bomba de 12 V com o IRLZ44N

Um circuito de MOSFET com Arduino é a forma mais eficiente de ligar e desligar cargas que puxam vários ampères, como uma fita LED de 12 V, um motor CC, uma bomba d'água ou uma fechadura solenoide, usando pinos do Arduino que só fornecem cerca de 20 mA. O MOSFET é uma chave eletrônica controlada por tensão: aplique 5 V no gate e o caminho entre dreno e fonte vira quase um fio de resistência zero; com 0 V, ele fica totalmente cortado. Um MOSFET de nível lógico bem escolhido só fica levemente morno ao conduzir uma carga de 3 A sem dissipador.

Neste guia você vai aprender como um MOSFET funciona, por que nem todo MOSFET serve para o Arduino (a diferença entre o IRLZ44N e o IRF520), qual é a função do resistor de gate, do resistor de pull-down e do diodo de roda livre, e como ajustar velocidade e brilho com PWM. Mais adiante há código pronto para fita LED de 12 V, motor CC, bomba e solenoide, exemplos com ESP32 e Raspberry Pi Pico, cálculos de aquecimento e dissipador, e uma tabela comparando MOSFET, transistor e relé.

O que é um MOSFET e como ele funciona?

O MOSFET (Metal Oxide Semiconductor Field Effect Transistor) é um transistor de efeito de campo com três terminais: o gate (G, porta), o dreno (D, drain) e a fonte (S, source). O gate é isolado do resto do componente por uma fina camada de óxido, então nenhuma corrente contínua entra nele e ele se comporta como um pequeno capacitor. Quando a tensão entre gate e fonte (VGS) passa de um certo limiar, forma-se um canal condutor entre dreno e fonte, e a corrente da carga passa por ele. O transistor BJT clássico é acionado pela corrente de base, enquanto o MOSFET é acionado por tensão; o pino do Arduino só fornece corrente durante os poucos microssegundos necessários para carregar e descarregar o gate.

Nos projetos com Arduino, quase sempre se usa um MOSFET de canal N colocado no lado negativo (GND) da carga; isso se chama chaveamento do lado baixo (low-side). O terminal positivo da carga vai direto ao positivo da fonte de alimentação externa, o negativo vai ao dreno do MOSFET, e a fonte (S) do MOSFET é ligada ao GND. Assim, a tensão entre gate e fonte é simplesmente a tensão do pino do Arduino. Estes são os valores do datasheet que você precisa conferir:

MOSFETs de nível lógico: IRLZ44N, IRF520 e outros

O erro mais comum é olhar o VGS(th) e pensar “o limiar é 4 V, o Arduino dá 5 V, então vai funcionar”. O limiar é o ponto em que o canal deixa passar só 250 µA; para o MOSFET conduzir vários ampères com baixa resistência, a tensão de gate precisa estar bem acima do limiar. A pergunta certa é: em qual VGS o datasheet garante o RDS(on)? Se for para 4,5 V ou 5 V, o MOSFET liga por completo com um Arduino de 5 V e é chamado de MOSFET de nível lógico (logic level). Se for só para 10 V, é um MOSFET padrão, e o pino do Arduino só vai ligá-lo pela metade. Na nomenclatura da International Rectifier (hoje Infineon), as peças que começam com IRL (IRLZ44N, IRLB8721, IRL540N) são de nível lógico, enquanto IRFZ44N, IRF520 e IRF540N são padrão.

A regra da tabela é simples: para placas de 5 V como Uno, Nano e Mega, escolha um MOSFET cujo RDS(on) seja especificado a 4,5 V ou 5 V. Em placas de 3,3 V como ESP32 e Pico é um pouco mais difícil, porque os datasheets de MOSFETs TO-220 populares como o IRLZ44N e o IRLB8721 não garantem nenhum valor a 3,3 V; voltaremos a isso na seção do ESP32. Também não escolha pelo encapsulamento: o IRLZ44N e o IRFZ44N vêm no mesmo encapsulamento, com marcação quase igual, mas essa única letra (L) muda tudo para o Arduino. Você pode conferir a ordem dos terminais na ferramenta Pinagem de transistores; nos MOSFETs TO-220, com o lado impresso virado para você, a ordem da esquerda para a direita é gate, dreno, fonte, e a aba metálica está ligada ao dreno.

Ligação do MOSFET no Arduino: resistor de gate, pull-down e GND comum

O circuito básico tem cinco partes: o MOSFET, um resistor de gate, um resistor de pull-down, um diodo de roda livre para cargas indutivas e uma fonte de alimentação externa. A tabela abaixo mostra a ligação para três placas; a carga de exemplo é uma fita LED ou um motor de 12 V. Todo o código deste artigo usa estes pinos.

O resistor de gate (100–220 Ω) limita a corrente momentânea puxada do pino enquanto a capacitância do gate se carrega. A capacitância de entrada do IRLZ44N é de cerca de 1700 pF; sem resistor, o pino vê por um instante algo próximo de um curto-circuito a cada transição, e a linha do gate começa a oscilar (ringing). Com 220 Ω, a corrente de pico é no máximo 5 / 220 ≈ 23 mA, e o gate ainda se carrega em poucos microssegundos. O resistor de pull-down (10 kΩ) impede que o gate fique flutuando enquanto o pino está como entrada, o que acontece quando o Arduino inicializa, reinicia ou recebe um novo sketch. Um gate flutuante pode captar ruído e se carregar pela metade; o MOSFET então fica meio ligado, gira o motor sozinho e superaquece rápido. Coloque o pull-down do lado do MOSFET em relação ao resistor de gate, direto entre gate e fonte; assim o MOSFET continua desligado mesmo que o fio de controle se solte. Os dois resistores formam um pequeno divisor de tensão, mas o efeito é desprezível: chegam ao gate 5 × 10000 / 10220 ≈ 4,89 V.

Diodo de roda livre: por que motores, bombas e solenoides precisam dele

Cargas indutivas como motores, bombas, solenoides, bobinas de relé e ventoinhas resistem a uma interrupção brusca da corrente. No instante em que o MOSFET desliga, a energia magnética armazenada na bobina é liberada como um pico de tensão no dreno, muito acima da tensão de alimentação (V = L × di/dt). Esse pico pode ultrapassar o VDS máximo do MOSFET e destruí-lo, ou gerar interferência que reinicia o Arduino. A solução é um diodo ligado invertido sobre a carga: o cátodo (lado da faixa) vai ao positivo da alimentação, e o ânodo ao dreno. Em operação normal, o diodo fica reversamente polarizado e não conduz; quando o MOSFET desliga, a corrente da bobina circula pelo diodo e se extingue suavemente. O diodo de corpo do MOSFET não faz esse papel, porque fica entre fonte e dreno, e não sobre a carga. Para mais detalhes, veja O que é um diodo?.

Passo a passo: controlando o brilho de uma fita LED de 12 V com Arduino

1. Separe as peças: Arduino Uno, IRLZ44N, resistores de 220 Ω e 10 kΩ, um potenciômetro de 10 kΩ, uma fita LED de 12 V e um adaptador de 12 V capaz de fornecer a corrente da fita.
2. Calcule a corrente da fita: uma fita 5050 com 60 LEDs/m consome cerca de 14,4 W por metro, ou seja, 1,2 A em 12 V. Dois metros precisam de 2,4 A; escolha o adaptador com 20% de folga (pelo menos 3 A).
3. Posicione o MOSFET: ligue a fonte (S) do IRLZ44N ao barramento de GND, o gate ao D9 através de 220 Ω, e coloque 10 kΩ entre gate e GND.
4. Ligue a carga: o fio +12V da fita vai ao positivo do adaptador, e o fio negativo ao dreno do MOSFET. Os contatos da protoboard aguentam cerca de 1 A; para correntes maiores, use bornes de parafuso ou solde os fios da carga.
5. Ligue o potenciômetro: terminais externos no 5V e no GND, terminal do meio no A0.
6. Una os GNDs e teste: ligue o negativo do adaptador ao GND do Arduino, carregue o código e só então conecte o adaptador na tomada.

1// IRLZ44N ile 12 V LED şerit parlaklık kontrolü / 12 V LED strip dimming with an IRLZ44N
2const int STRIP_PIN = 9;    // PWM pini, 220 Ω ile gate'e / PWM pin, to the gate via 220 Ω
3const int POT_PIN = A0;     // potansiyometre orta ucu / potentiometer wiper
4
5void setup() {
6  pinMode(STRIP_PIN, OUTPUT);
7  digitalWrite(STRIP_PIN, LOW);             // açılışta kapalı / off at startup
8  Serial.begin(9600);
9}
10
11void loop() {
12  int pot = analogRead(POT_PIN);            // 0–1023
13  float x = pot / 1023.0;                   // 0.0–1.0
14  int duty = (int)(x * x * 255.0 + 0.5);    // basit gama düzeltmesi / simple gamma correction
15  analogWrite(STRIP_PIN, duty);             // D9'da 490 Hz PWM / 490 Hz PWM on D9
16  Serial.print("Parlaklik / Brightness: %");
17  Serial.println(duty * 100 / 255);
18  delay(50);
19}

O analogWrite() gera no pino 9 um sinal PWM que liga e desliga cerca de 490 vezes por segundo; 0 significa totalmente desligado e 255, totalmente ligado. Os pinos PWM do Uno são 3, 5, 6, 9, 10 e 11; os pinos 5 e 6 trabalham a cerca de 980 Hz. Como o olho não percebe o brilho de forma linear, elevar ao quadrado o valor do potenciômetro (uma correção gama simples) dá um controle bem mais suave em brilho baixo. Os detalhes do PWM estão em O que é PWM?. Vamos conferir também o aquecimento: a 2,4 A, o IRLZ44N dissipa P = I² × RDS(on) = 2,4² × 0,025 ≈ 0,14 W, então ao toque ele fica só morno. Enquanto isso, a própria fita LED consome 28,8 W; a perda no MOSFET é menos de um por cento do total.

Controle de velocidade de motor CC e bomba com PWM

Acionar um motor ou uma bomba usa o mesmo circuito da fita LED; a única diferença é que você adiciona um diodo de roda livre sobre a carga. Motores também têm corrente de partida: um motor parado pode puxar de 3 a 8 vezes a corrente de funcionamento no primeiro instante. Por isso, dimensione o MOSFET e a fonte de alimentação pela corrente de travamento do motor, e use uma partida suave em vez de pular direto de 0 para 255. Minibombas submersíveis puxam cerca de 0,1–0,3 A em 3–6 V, enquanto bombas de diafragma de 12 V costumam puxar 0,5–1 A; o IRLZ44N dá conta das duas com muita folga. Só alimente a minibomba com uma fonte na tensão dela (5–6 V), e não com o adaptador de 12 V; o circuito do MOSFET continua o mesmo. Para escolher a bomba e ver detalhes de irrigação, veja minibomba de água.

1// IRLZ44N ile motor/pompa hız kontrolü ve yumuşak kalkış / Motor or pump speed control with soft start (IRLZ44N)
2const int MOTOR_PIN = 9;     // 220 Ω ile gate'e / to the gate via 220 Ω
3const int POT_PIN = A0;      // hız ayarı / speed setting
4const int MIN_DUTY = 60;     // bunun altında motor yalnızca vızıldar / below this the motor only hums
5
6int current = 0;             // şu anki PWM değeri / current PWM value
7
8void setup() {
9  pinMode(MOTOR_PIN, OUTPUT);
10  digitalWrite(MOTOR_PIN, LOW);
11  // TCCR1B = (TCCR1B & 0b11111000) | 0x02;   // isteğe bağlı: D9/D10 PWM ≈3,9 kHz / optional: D9/D10 PWM ≈3.9 kHz
12}
13
14void loop() {
15  int target = map(analogRead(POT_PIN), 0, 1023, 0, 255);
16  if (target < MIN_DUTY) target = 0;         // çok düşük hızda tamamen durdur / stop completely at very low speed
17
18  if (current < target) current++;           // yavaşça hızlan / speed up gently
19  else if (current > target) current--;      // yavaşça yavaşla / slow down gently
20
21  analogWrite(MOTOR_PIN, current);
22  delay(8);                                  // 0→255 yaklaşık 2 s / 0→255 takes about 2 s
23}

O código avança um passo em direção à velocidade-alvo lida no potenciômetro a cada 8 ms, então o motor vai de 0 à velocidade máxima em cerca de 2 segundos, e a corrente de partida não derruba a fonte de alimentação. MIN_DUTY é o menor valor de PWM em que o motor começa a girar; descubra-o testando com o seu próprio motor. O PWM de 490 Hz produz um zumbido audível no motor. A linha comentada com TCCR1B eleva a frequência de D9 e D10 para cerca de 3,9 kHz; a biblioteca Servo também usa o Timer1, então não use as duas coisas juntas. É tentador subir ainda mais a frequência, mas, como o pino do Arduino precisa de alguns microssegundos para carregar o gate de um MOSFET grande a cada transição, as perdas de chaveamento crescem com a frequência: perto de 20 kHz, até um motor de 2 A pode causar mais de 1 W de perda no MOSFET. Nessas frequências se usa um driver de gate como o TC4427.

Fechaduras solenoides e cargas de uso breve

Fechaduras solenoides de 12 V para portas puxam 0,5–1 A, e a maioria não foi projetada para ficar energizada continuamente; se ficar ligada por muito tempo, a bobina esquenta. Por isso, o código deve manter a fechadura aberta só por alguns segundos. Como o solenoide é ligado e desligado, sem PWM, um 1N4007 basta como diodo de roda livre. No exemplo abaixo, apertar o botão no D2 abre a fechadura por 3 segundos; depois ela fecha, mesmo que o botão continue pressionado. Para acionar a fechadura com um leitor RFID ou um teclado matricial, basta mudar a condição do if; para tipos de fechadura e o comportamento em caso de queda de energia, veja fechadura solenoide.

1// Butonla 3 saniyelik solenoid kilit açma / Open a solenoid lock for 3 seconds with a button
2const int LOCK_PIN = 9;                 // 220 Ω ile IRLZ44N gate'ine / to the IRLZ44N gate via 220 Ω
3const int BUTTON_PIN = 2;               // buton D2 ile GND arasında / button between D2 and GND
4const unsigned long OPEN_MS = 3000;     // kilidin açık kalma süresi / how long the lock stays open
5
6void setup() {
7  pinMode(LOCK_PIN, OUTPUT);
8  digitalWrite(LOCK_PIN, LOW);          // kilit kapalı / locked
9  pinMode(BUTTON_PIN, INPUT_PULLUP);    // basılınca LOW / LOW when pressed
10}
11
12void loop() {
13  if (digitalRead(BUTTON_PIN) == LOW) {
14    digitalWrite(LOCK_PIN, HIGH);       // solenoid çeker, kilit açılır / solenoid pulls in, lock opens
15    delay(OPEN_MS);
16    digitalWrite(LOCK_PIN, LOW);        // bobini soğumaya bırak / let the coil cool down
17    while (digitalRead(BUTTON_PIN) == LOW) {}   // buton bırakılana kadar bekle / wait until released
18    delay(50);                          // buton zıplamasını süz / debounce
19  }
20}

Por que o módulo IRF520 deixa a desejar em 5 V

O módulo MOSFET IRF520, muito comum em kits iniciantes, é uma plaquinha com bornes de parafuso vendida com especificações como “24 V, 5 A”. Ao lado do MOSFET, ela tem alguns resistores e um LED de sinalização; a maioria das versões não tem diodo de roda livre. O problema é o próprio MOSFET: o IRF520 é um MOSFET padrão com limiar de 2–4 V, e seu RDS(on) de 0,27 Ω só é garantido com VGS = 10 V. Pelas curvas típicas do datasheet, com 5 V no gate o IRF520 começa a limitar a corrente por volta de 2 A; em uma peça com limiar alto, esse limite cai para menos de 1 A. Nesse ponto, o MOSFET não se comporta como uma chave, e sim como um resistor variável.

Veja um exemplo: imagine acionar com o módulo IRF520 um motor de 12 V que puxa 2 A. Se caírem 1,5 V sobre o MOSFET, ele dissipa P = 1,5 × 2 = 3 W. Com a resistência térmica de 62 °C/W de um encapsulamento TO-220 sem dissipador, isso dá cerca de 186 °C acima da temperatura ambiente; o MOSFET superaquece rápido e queima ou, na melhor das hipóteses, o motor gira devagar. Os 5 A da etiqueta do módulo só valem com 10 V no gate. Estes são os terminais do módulo e como ligá-los:

• Troque o MOSFET: dessolde o IRF520 do módulo e solde no lugar um IRLZ44N, que tem a mesma ordem de terminais (G-D-S); a placa funciona exatamente igual, mas agora liga por completo com 5 V.
• Use um módulo de nível lógico: módulos prontos com o MOSFET AOD4184A (D4184) oferecem RDS(on) de no máximo 9,5 mΩ a 4,5 V e funcionam tranquilamente com um Arduino de 5 V.
• Acione o gate com uma tensão maior: um driver de gate como o TC4427, alimentado com 12 V, transforma o sinal de 5 V ou 3,3 V do Arduino em 12 V no gate, e assim o IRF520 alcança sua capacidade real. Mantenha a tensão de gate dentro dos limites: ±20 V para o IRF520 e ±16 V para o IRLZ44N.
• Use como está em cargas pequenas: abaixo de 1 A (uma fita LED curta, uma minibomba), o módulo IRF520 funciona em 5 V com aquecimento aceitável; se o MOSFET ficar quente demais para tocar, reduza a carga.

Usando MOSFET com ESP32 e Raspberry Pi Pico (3,3 V)

Como os pinos do ESP32 e do Pico fornecem 3,3 V, escolher o MOSFET certo importa ainda mais. O datasheet do IRLZ44N informa o RDS(on) só para VGS de 4 V para cima; pelas curvas típicas, ele ainda conduz vários ampères com folga por volta de 3 V, mas isso não é garantido em uma peça com limiar alto. Uma regra prática: em placas de 3,3 V, use o IRLZ44N ou o IRLB8721 para até 2–3 A, meça a tensão entre dreno e fonte com um multímetro com a carga funcionando e calcule a potência dissipada com P = VDS × I; fique abaixo de 1 W em um TO-220 sem dissipador. Para correntes maiores, use um driver que eleve o gate para 5–12 V e, para cargas pequenas, um AO3400A, cujo RDS(on) é garantido a 2,5 V. No ESP32, escolha pinos como GPIO 25, 26, 27, 32 ou 33 para o MOSFET: GPIO 0, 2, 5, 12 e 15 são pinos de strapping, e GPIO 1, 3, 5, 14 e 15 podem ir para HIGH por um instante ou emitir PWM na inicialização. Nesses pinos, a carga pode ligar sem querer na partida, ou o resistor de pull-down pode atrapalhar o boot.

O código do ESP32 abaixo liga uma bomba pelo MOSFET com partida suave quando o sensor de umidade do solo indica solo seco, rega por 5 segundos e depois a desliga suavemente. Para o PWM, ele usa as funções ledcAttach() e ledcWrite() do core ESP32 para Arduino 3.x; as versões antigas 2.x usavam ledcSetup() e ledcAttachPin(), e o ledcWrite() delas recebia um número de canal em vez de um pino. As linhas #if do código escolhem as chamadas certas para o core instalado, então ele compila nas duas versões. Como o gate é acionado com 3,3 V através de 100 Ω, a frequência fica em 1 kHz para que as perdas de chaveamento continuem desprezíveis. Meça as leituras de solo seco e molhado do sensor na sua própria terra, como em Sensor de umidade do solo, e ajuste o limite DRY_LEVEL de acordo.

1// ESP32 + MOSFET ile otomatik sulama pompası / Automatic watering pump with ESP32 + MOSFET
2const int PUMP_PIN = 25;                 // 100 Ω ile gate'e, gate–GND 10 kΩ / to the gate via 100 Ω, 10 kΩ gate–GND
3const int SOIL_PIN = 34;                 // toprak nem sensörü, ADC1 / soil moisture sensor, ADC1
4const int DRY_LEVEL = 2800;              // üstü kuru sayılır, kalibre et / above this counts as dry, calibrate
5const unsigned long WATER_MS = 5000;     // sulama süresi / watering time
6
7void pumpWrite(int duty) {               // 0–255 PWM, iki çekirdek sürümünde / on both core versions
8#if ESP_ARDUINO_VERSION_MAJOR >= 3
9  ledcWrite(PUMP_PIN, duty);             // 3.x: pin numarasıyla / 3.x: by pin number
10#else
11  ledcWrite(0, duty);                    // 2.x: kanal 0 ile / 2.x: by channel 0
12#endif
13}
14
15void pumpRamp(int from, int to) {        // yumuşak hız değişimi / smooth speed change
16  int step = (to > from) ? 5 : -5;
17  for (int d = from; d != to; d += step) {
18    pumpWrite(d);
19    delay(20);
20  }
21  pumpWrite(to);
22}
23
24void setup() {
25  Serial.begin(115200);
26#if ESP_ARDUINO_VERSION_MAJOR >= 3
27  ledcAttach(PUMP_PIN, 1000, 8);         // 1 kHz, 8 bit (0–255); çekirdek 3.x / core 3.x
28#else
29  ledcSetup(0, 1000, 8);                 // çekirdek 2.x: kanal 0 / core 2.x: channel 0
30  ledcAttachPin(PUMP_PIN, 0);
31#endif
32  pumpWrite(0);                          // pompa kapalı / pump off
33}
34
35void loop() {
36  int soil = analogRead(SOIL_PIN);       // 0–4095
37  Serial.printf("Toprak / Soil: %d\n", soil);
38  if (soil > DRY_LEVEL) {
39    pumpRamp(0, 255);                    // yaklaşık 1 s'de tam hıza / full speed in about 1 s
40    delay(WATER_MS);
41    pumpRamp(255, 0);                    // yumuşakça dur / stop gently
42    delay(60000);                        // suyun toprağa yayılmasını bekle / let the water soak in
43  }
44  delay(1000);
45}

No Raspberry Pi Pico, a classe machine.PWM é tudo de que você precisa para gerar PWM em MicroPython; duty_u16() recebe um valor de 0 a 65535. O código abaixo dá um efeito suave de “respiração” a uma fita LED de 12 V ligada ao MOSFET no GP15. Como no exemplo do Arduino, o valor é elevado ao quadrado para uma correção gama simples, de modo que a passagem do escuro para o claro pareça natural. Os pinos do Pico também fornecem 3,3 V, então as regras de MOSFET que demos para o ESP32 valem aqui também.

1# Pico + MOSFET ile 12 V LED şerit nefes efekti / 12 V LED strip breathing effect with Pico + MOSFET
2from machine import Pin, PWM
3import time
4
5strip = PWM(Pin(15))          # 100 Ω ile gate'e, gate–GND 10 kΩ / to the gate via 100 Ω, 10 kΩ gate–GND
6strip.freq(1000)              # 1 kHz: titreme görünmez / 1 kHz: no visible flicker
7
8def set_level(x):             # x: 0.0–1.0
9    strip.duty_u16(int(x * x * 65535))   # basit gama düzeltmesi / simple gamma correction
10
11while True:
12    for i in range(101):                 # yavaşça aydınlan / fade in
13        set_level(i / 100)
14        time.sleep_ms(20)
15    for i in range(100, -1, -1):         # yavaşça sön / fade out
16        set_level(i / 100)
17        time.sleep_ms(20)
18    time.sleep_ms(500)

Aquecimento, cálculo de potência e escolha do dissipador

O calor em um MOSFET totalmente ligado vem de uma única fórmula: P = I² × RDS(on). Tenha duas coisas em mente. Primeiro, o RDS(on) aumenta com a temperatura; no IRLZ44N, a 100 °C, ele fica cerca de 1,5 vez o valor a 25 °C, então usar 38 mΩ em vez de 25 mΩ no cálculo é mais realista. Segundo, o encapsulamento só consegue passar uma quantidade limitada de calor para o ar: a resistência térmica de um TO-220 sem dissipador (RθJA) é de 62 °C/W, ou seja, cada watt eleva a temperatura do chip 62 °C acima do ambiente. A tabela abaixo mostra como o IRLZ44N esquenta com 5 V no gate e sem dissipador:

O dimensionamento do dissipador segue a mesma lógica: Tj = Tambiente + P × (RθJC + RθCS + RθSA). Se 3,8 W são dissipados a 10 A e você quer manter o chip a 100 °C em um ambiente de 30 °C, a resistência térmica total não pode passar de (100 − 30) / 3,8 ≈ 18 °C/W. A resistência junção–encapsulamento do IRLZ44N é de 1,4 °C/W, e um contato com pasta térmica fica em cerca de 0,5 °C/W, então o próprio dissipador deve ter 16 °C/W ou menos, o que corresponde a um dissipador TO-220 pequeno, mas aletado. A aba metálica do MOSFET está ligada ao dreno; se você montar vários MOSFETs no mesmo dissipador, use uma pastilha isolante de mica ou silicone e uma bucha plástica no parafuso. A segunda origem de calor com PWM é a perda de chaveamento; ela é desprezível em 490 Hz, mas cresce conforme a frequência aumenta.

MOSFET, transistor e relé: comparação

Resumindo: se você quer controlar uma carga CC de forma rápida, silenciosa e com PWM, use um MOSFET; se vai ligar e desligar uma lâmpada ou tomada da rede elétrica, use um módulo relé. Para cargas pequenas de algumas centenas de miliampères, um BJT barato também resolve; o cálculo do resistor de base está em O que é um transistor?. Se o mesmo motor precisa girar nos dois sentidos, um MOSFET só não basta: é preciso uma ponte H com quatro chaves, então use um driver de motor L298N ou um módulo de ponte H com MOSFETs.

Ideias de projetos com MOSFET

• Luz automática de armário ou escada: quando um sensor PIR detectar movimento, acenda suavemente uma fita LED de 12 V com PWM e apague-a depois de um tempo.
• Luminária pôr do sol: use um LDR para aumentar o brilho da fita aos poucos conforme o ambiente escurece.
• Ventoinha inteligente: aumente a velocidade de uma ventoinha de PC de 12 V conforme sobe a temperatura medida por um DHT11.
• Irrigação automática de plantas: regue seus vasos automaticamente com um sensor de umidade do solo e uma bomba acionada por MOSFET; use um MOSFET separado para cada bomba.
• Fechadura com cartão: abra uma fechadura solenoide de 12 V por 3 segundos quando um RFID RC522 ler o cartão certo.
• Estufa inteligente: monte uma estufa inteligente que controla a ventoinha, a bomba e o aquecedor com MOSFETs separados.

Erros comuns e como corrigir

O MOSFET é a forma mais limpa de ligar um Arduino a cargas potentes do mundo real: com uma peça de nível lógico bem escolhida, um resistor de gate, um pull-down e um diodo para cargas indutivas, você controla qualquer carga CC, de uma fita LED a uma bomba, de forma silenciosa e eficiente. No app BlueGrays você encontra projetos como LED com fade por PWM, controle de brilho com potenciômetro, estação de irrigação inteligente e iluminação inteligente, com esquemas do circuito e código passo a passo, para transformar logo o circuito de MOSFET que aprendeu aqui em um projeto de verdade.