MOSFET con Arduino: controla tiras LED, motores y bombas de 12V

Un circuito con MOSFET y Arduino es la forma más eficiente de encender y apagar con seguridad cargas que consumen varios amperios, como una tira LED de 12 V, un motor de corriente continua, una bomba de agua o una cerradura de solenoide, usando pines de Arduino que solo pueden entregar unos 20 mA. El MOSFET es un interruptor electrónico controlado por tensión: si aplicas 5 V a su puerta (gate), el camino entre drenador (drain) y fuente (source) se convierte casi en un cable sin resistencia; con 0 V queda totalmente cortado. Un MOSFET de nivel lógico bien elegido apenas se entibia al manejar una carga de 3 A sin disipador.

En este artículo aprenderás cómo funciona un MOSFET, por qué no cualquier MOSFET sirve para Arduino (la diferencia entre el IRLZ44N y el IRF520), para qué sirven la resistencia de puerta, la resistencia pull-down y el diodo flyback, y cómo regular velocidad y brillo con PWM. Más abajo tienes código listo para una tira LED, un motor DC, una bomba y una cerradura de solenoide de 12 V, ejemplos para ESP32 y Raspberry Pi Pico, el cálculo del calentamiento y del disipador, y una tabla comparativa entre MOSFET, transistor y relé.

¿Qué es un MOSFET y cómo funciona?

El MOSFET (Metal Oxide Semiconductor Field Effect Transistor) es un transistor de efecto de campo con tres patas: puerta (gate), drenador (drain) y fuente (source). La puerta está aislada del resto del componente por una fina capa de óxido, así que no circula corriente continua por ella y se comporta como un pequeño condensador. Cuando la tensión entre puerta y fuente (VGS) supera cierto umbral, se forma un canal conductor entre drenador y fuente y la corriente de la carga pasa por él. Un transistor BJT clásico se controla con la corriente de base, mientras que el MOSFET se controla por tensión; el pin de Arduino solo entrega corriente durante los pocos microsegundos que tarda en cargar y descargar la puerta.

En los proyectos con Arduino casi siempre se usa un MOSFET de canal N colocado en el lado negativo (GND) de la carga; esto se llama conmutación en el lado bajo (low-side). El positivo de la carga va directamente al positivo de la fuente externa, su negativo va al drenador del MOSFET y la fuente del MOSFET se conecta a GND. Así la tensión puerta-fuente es simplemente la tensión del pin de Arduino. Estos son los valores de la hoja de datos que debes revisar:

MOSFET de nivel lógico: IRLZ44N, IRF520 y otros

El error más común es mirar VGS(th) y pensar «el umbral es 4 V, Arduino da 5 V, entonces funciona». La tensión umbral es el punto en el que el canal deja pasar apenas 250 µA; para que el MOSFET conduzca varios amperios con baja resistencia, la tensión de puerta debe estar bastante por encima. La pregunta correcta es: ¿a qué VGS garantiza la hoja de datos el RDS(on)? Si está indicado para 4,5 V o 5 V, el MOSFET conduce por completo con un Arduino de 5 V y se llama MOSFET de nivel lógico (logic level). Si solo se indica para 10 V, es un MOSFET estándar y un pin de Arduino solo lo abrirá a medias. En la nomenclatura de International Rectifier (hoy Infineon), los modelos que empiezan por IRL (IRLZ44N, IRLB8721, IRL540N) son de nivel lógico, mientras que el IRFZ44N, el IRF520 y el IRF540N son estándar.

La regla de la tabla es sencilla: para placas de 5 V como Uno, Nano y Mega, elige un MOSFET cuyo RDS(on) esté especificado a 4,5 V o 5 V. Con placas de 3,3 V como ESP32 y Pico es un poco más difícil, porque las hojas de datos de MOSFET TO-220 populares como el IRLZ44N y el IRLB8721 no garantizan ningún valor a 3,3 V; volveremos a esto en la sección del ESP32. Tampoco elijas por el encapsulado: el IRLZ44N y el IRFZ44N vienen en la misma cápsula con una serigrafía casi igual, pero esa única letra (L) lo cambia todo para Arduino. Puedes comprobar el orden de las patas con la herramienta Patillaje de transistores; en los MOSFET TO-220, con la cara impresa hacia ti, el orden de izquierda a derecha es puerta, drenador, fuente (G-D-S) y la lengüeta metálica está unida al drenador.

Conexión del MOSFET a Arduino: resistencia de puerta, pull-down y GND común

El circuito básico tiene cinco partes: el MOSFET, la resistencia de puerta, la resistencia pull-down, un diodo flyback para cargas inductivas y una fuente de alimentación externa. La tabla muestra la conexión para tres placas; la carga de ejemplo es una tira LED o un motor de 12 V. Todo el código del artículo usa estos pines.

La resistencia de puerta (100–220 Ω) limita la corriente instantánea que sale del pin mientras se carga la capacidad de la puerta. La capacidad de entrada del IRLZ44N ronda los 1700 pF; sin resistencia, el pin ve casi un cortocircuito durante un instante en cada conmutación y aparecen oscilaciones (ringing) en la línea de puerta. Con 220 Ω la corriente de pico es como mucho 5 / 220 ≈ 23 mA y la puerta se carga igualmente en pocos microsegundos. La resistencia pull-down (10 kΩ) evita que la puerta quede flotando mientras el pin es una entrada, algo que ocurre al arrancar, al reiniciar o al cargar un programa. Una puerta flotante puede cargarse a medias con el ruido; el MOSFET queda medio encendido, el motor gira solo y el MOSFET se sobrecalienta enseguida. Coloca la pull-down del lado del MOSFET, directamente entre puerta y fuente, para que el MOSFET siga apagado aunque se suelte el cable de control. Las dos resistencias forman un pequeño divisor de tensión, pero su efecto es despreciable: a la puerta llegan 5 × 10000 / 10220 ≈ 4,89 V.

Diodo flyback: por qué es obligatorio con motores, bombas y solenoides

Las cargas inductivas como motores, bombas, solenoides, bobinas de relé y ventiladores se oponen a que la corriente se corte de golpe. En el instante en que el MOSFET se apaga, la energía magnética de la bobina se libera como un pico de tensión en el drenador muy por encima de la tensión de alimentación (V = L × di/dt). Ese pico puede superar el límite VDS del MOSFET y destruirlo, o generar interferencias que reinician el Arduino. La solución es un diodo conectado en inversa en paralelo con la carga: el cátodo (extremo con franja) al positivo de la alimentación y el ánodo al drenador. En funcionamiento normal el diodo está polarizado en inversa y no conduce; cuando el MOSFET se apaga, la corriente de la bobina circula por el diodo y se extingue suavemente. El diodo interno del MOSFET no cumple esta función, porque está entre fuente y drenador, no en paralelo con la carga. Tienes más detalles en ¿Qué es un diodo?.

Paso a paso: regular el brillo de una tira LED de 12 V con Arduino

1. Reúne el material: Arduino Uno, IRLZ44N, resistencias de 220 Ω y 10 kΩ, un potenciómetro de 10 kΩ, una tira LED de 12 V y un adaptador de 12 V capaz de dar la corriente de la tira.
2. Calcula la corriente de la tira: una tira 5050 de 60 LED/m consume unos 14,4 W por metro, es decir, 1,2 A a 12 V. Dos metros son 2,4 A; elige el adaptador con un 20 % de margen (al menos 3 A).
3. Coloca el MOSFET: conecta la fuente del IRLZ44N a la línea de GND, la puerta a D9 a través de 220 Ω y pon 10 kΩ entre puerta y GND.
4. Conecta la carga: el cable +12V de la tira va al positivo del adaptador y el negativo al drenador del MOSFET. Los contactos de la protoboard soportan alrededor de 1 A; con más corriente, usa bornes de tornillo o suelda los cables de la carga.
5. Conecta el potenciómetro: patas exteriores a 5V y GND, pata central a A0.
6. Une las tierras y prueba: conecta el negativo del adaptador al GND de Arduino, carga el código y después enchufa el adaptador.

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}

analogWrite() genera en el pin 9 una señal PWM que se enciende y apaga unas 490 veces por segundo; 0 significa apagado del todo y 255 encendido del todo. Los pines PWM del Uno son 3, 5, 6, 9, 10 y 11; los pines 5 y 6 trabajan a unos 980 Hz. Como el ojo no percibe el brillo de forma lineal, elevar al cuadrado el valor del potenciómetro (una corrección gamma sencilla) da un ajuste mucho más suave en los niveles bajos. Tienes la explicación completa del PWM en ¿Qué es PWM?. Calculemos también el calor: a 2,4 A el IRLZ44N disipa P = I² × RDS(on) = 2,4² × 0,025 ≈ 0,14 W, así que al tocarlo apenas está tibio. Mientras tanto, la tira LED consume 28,8 W; la pérdida en el MOSFET es menos del uno por ciento del total.

Control de velocidad de motores y bombas DC con PWM

Para controlar un motor o una bomba se usa el mismo circuito que con la tira LED; la única diferencia es que debes añadir un diodo flyback en paralelo con la carga. Los motores tienen además una corriente de arranque: un motor parado puede consumir en el primer instante de 3 a 8 veces su corriente de trabajo. Por eso dimensiona el MOSFET y la fuente según la corriente de bloqueo (stall) del motor y aplica un arranque suave en lugar de pasar de golpe de 0 a 255. Las mini bombas sumergibles consumen unos 0,1–0,3 A a 3–6 V y las bombas de diafragma de 12 V suelen consumir 0,5–1 A; el IRLZ44N maneja ambas con mucho margen. Eso sí, alimenta la mini bomba con una fuente de su propia tensión (5–6 V), no con el adaptador de 12 V; el circuito del MOSFET no cambia. Para elegir la bomba y montar un riego, consulta Mini bomba de agua.

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}

El código se acerca un paso a la velocidad objetivo leída del potenciómetro cada 8 ms, así que el motor pasa de 0 a velocidad máxima en unos 2 segundos y la corriente de arranque no hunde la fuente. MIN_DUTY es el valor PWM más bajo con el que el motor empieza a girar; encuéntralo probando con tu propio motor. El PWM de 490 Hz produce un zumbido audible en el motor. La línea comentada con TCCR1B sube la frecuencia de D9 y D10 a unos 3,9 kHz; la librería Servo también usa el Timer1, así que no uses ambas a la vez. Subir aún más la frecuencia es tentador, pero como un pin de Arduino tarda unos microsegundos en cargar la puerta de un MOSFET grande en cada conmutación, las pérdidas de conmutación crecen con la frecuencia: hacia 20 kHz, incluso un motor de 2 A puede provocar más de 1 W de pérdidas en el MOSFET. A esas frecuencias se usa un driver de puerta como el TC4427.

Cerraduras de solenoide y cargas de uso breve

Las cerraduras de puerta de solenoide de 12 V consumen 0,5–1 A y la mayoría no está pensada para estar energizada de forma continua; si se queda activada mucho tiempo, la bobina se calienta. Por eso el código debe mantener la cerradura abierta solo unos segundos. Como el solenoide se enciende y apaga sin PWM, basta con un 1N4007 como diodo flyback. En el ejemplo siguiente, al pulsar el botón de D2 la cerradura se abre durante 3 segundos y luego se cierra aunque el botón siga pulsado. Para activarla con un lector de tarjetas RFID o un teclado matricial solo tienes que cambiar la condición del if; los tipos de cerradura y su comportamiento ante un corte de luz están en Cerradura de 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 qué el módulo IRF520 se queda corto con 5 V?

El módulo MOSFET IRF520, muy habitual en los kits de iniciación, es una placa pequeña con bornes de tornillo que se vende con valores como «24 V, 5 A». Junto al MOSFET lleva algunas resistencias y un LED de señal; la mayoría de versiones no incluye diodo flyback. El problema está en el propio MOSFET: el IRF520 es un MOSFET estándar con un umbral de 2–4 V, y su RDS(on) de 0,27 Ω solo está garantizado con VGS = 10 V. Según las curvas típicas de la hoja de datos, con 5 V en la puerta el IRF520 empieza a limitar la corriente hacia los 2 A; en una unidad con umbral alto, ese límite baja de 1 A. En ese punto el MOSFET ya no se comporta como un interruptor, sino como una resistencia variable.

Veámoslo con un ejemplo: imagina que controlas con el módulo IRF520 un motor de 12 V que consume 2 A. Si caen 1,5 V en el MOSFET, disipa P = 1,5 × 2 = 3 W. Con una resistencia térmica de 62 °C/W para el encapsulado TO-220 sin disipador, eso son unos 186 °C por encima de la temperatura ambiente; el MOSFET se sobrecalienta enseguida y se estropea o, en el mejor de los casos, el motor gira despacio. Los 5 A de la etiqueta del módulo solo valen con 10 V en la puerta. Estos son los terminales del módulo y su conexión:

• Cambia el MOSFET: desuelda el IRF520 del módulo y suelda en su lugar un IRLZ44N con el mismo orden de patas (G-D-S); la placa funciona igual, pero ahora conduce por completo con 5 V.
• Usa un módulo de nivel lógico: los módulos con el MOSFET AOD4184A (D4184) ofrecen un RDS(on) de como máximo 9,5 mΩ a 4,5 V y funcionan sin problemas con un Arduino de 5 V.
• Excita la puerta con más tensión: un driver de puerta como el TC4427 alimentado a 12 V convierte la señal de 5 V o 3,3 V de Arduino en 12 V en la puerta, y el IRF520 alcanza su capacidad real. Respeta el límite de tensión de puerta: ±20 V en el IRF520 y ±16 V en el IRLZ44N.
• Úsalo tal cual con cargas pequeñas: por debajo de 1 A (una tira LED corta, una mini bomba) el módulo IRF520 funciona con 5 V con un calentamiento aceptable; si el MOSFET quema al tocarlo, reduce la carga.

MOSFET con ESP32 y Raspberry Pi Pico (3,3 V)

Como los pines del ESP32 y de la Pico dan 3,3 V, elegir bien el MOSFET es aún más importante. La hoja de datos del IRLZ44N especifica el RDS(on) solo hasta 4 V; según las curvas típicas, a unos 3 V sigue dejando pasar varios amperios sin problema, pero en una unidad con umbral alto no está garantizado. Regla práctica: con placas de 3,3 V usa el IRLZ44N o el IRLB8721 hasta 2–3 A, mide la tensión drenador-fuente con el multímetro con la carga funcionando y calcula la potencia disipada con P = VDS × I; con un TO-220 sin disipador, quédate por debajo de 1 W. Para corrientes mayores usa un driver que eleve la puerta a 5–12 V, y para cargas pequeñas un AO3400A, cuyo RDS(on) está garantizado a 2,5 V. En el ESP32 elige para el MOSFET pines como GPIO 25, 26, 27, 32 o 33: GPIO 0, 2, 5, 12 y 15 son pines de arranque (strapping), y GPIO 1, 3, 5, 14 y 15 pueden ponerse en HIGH un momento o sacar PWM al arrancar. En esos pines la carga puede encenderse sola al arrancar o la pull-down puede impedir que la placa arranque bien.

El siguiente código para ESP32 arranca una bomba a través del MOSFET con arranque suave cuando el sensor de humedad indica que la tierra está seca, riega durante 5 segundos y luego la detiene suavemente. Para el PWM usa las funciones ledcAttach() y ledcWrite() del core 3.x de ESP32 para Arduino; las versiones 2.x antiguas usaban en su lugar ledcSetup() y ledcAttachPin(), y su ledcWrite() recibía un número de canal en vez de un pin. Las líneas #if del código eligen las llamadas adecuadas para el core instalado, así que compila en las dos versiones. Como la puerta se excita con 3,3 V a través de 100 Ω, la frecuencia se mantiene en 1 kHz para que las pérdidas de conmutación sean despreciables. Mide los valores en seco y en mojado del sensor en tu propia tierra, como en Sensor de humedad del suelo, y ajusta el umbral DRY_LEVEL.

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}

En la Raspberry Pi Pico basta con la clase machine.PWM para generar PWM en MicroPython; duty_u16() acepta valores de 0 a 65535. El siguiente código da a una tira LED de 12 V conectada al MOSFET en GP15 un suave efecto de «respiración». Igual que en el ejemplo de Arduino, el valor se eleva al cuadrado como corrección gamma sencilla, para que el paso de oscuro a claro parezca natural. Los pines de la Pico también dan 3,3 V, así que aquí valen las mismas reglas de MOSFET que para el ESP32.

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)

Calentamiento, cálculo de potencia y elección del disipador

El calor de un MOSFET en conducción plena sale de una sola fórmula: P = I² × RDS(on). Ten en cuenta dos cosas. Primero, el RDS(on) aumenta con la temperatura; en el IRLZ44N, a 100 °C es aproximadamente 1,5 veces el valor a 25 °C, así que es más realista calcular con 38 mΩ en lugar de 25 mΩ. Segundo, la cápsula solo puede ceder cierta cantidad de calor al aire: la resistencia térmica de un TO-220 sin disipador (RθJA) es de 62 °C/W, es decir, cada vatio eleva la temperatura del chip 62 °C por encima del ambiente. La tabla muestra cómo se calienta el IRLZ44N con 5 V en la puerta y sin disipador:

El disipador se calcula con la misma lógica: Tj = Tambiente + P × (RθJC + RθCS + RθSA). Si a 10 A se disipan 3,8 W y quieres mantener el chip a 100 °C en una habitación a 30 °C, la resistencia térmica total no debe superar (100 − 30) / 3,8 ≈ 18 °C/W. La resistencia unión-cápsula del IRLZ44N es de 1,4 °C/W y un contacto con pasta térmica ronda los 0,5 °C/W, así que el disipador debe tener como mucho 16 °C/W, lo que corresponde a un disipador TO-220 pequeño pero con aletas. La lengüeta metálica del MOSFET está unida al drenador; si montas varios MOSFET en el mismo disipador, pon una lámina aislante de mica o silicona y un casquillo de plástico para el tornillo. La segunda fuente de calor con PWM son las pérdidas de conmutación; a 490 Hz son despreciables, pero crecen al subir la frecuencia.

MOSFET, transistor y relé: comparativa

En resumen: si quieres controlar una carga de CC de forma rápida, silenciosa y con PWM, usa un MOSFET; si vas a encender una lámpara o un enchufe de la red de 230 V, usa un módulo de relé. Para cargas pequeñas de unos cientos de miliamperios también sirve un BJT barato; el cálculo de la resistencia de base está en ¿Qué es un transistor?. Si el mismo motor debe girar en los dos sentidos, un solo MOSFET no basta: necesitas un puente H con cuatro interruptores, así que usa un driver de motor L298N o un módulo de puente H con MOSFET.

Ideas de proyectos con MOSFET

• Luz automática de armario o escalera: cuando un sensor PIR detecta movimiento, enciende suavemente una tira LED de 12 V con PWM y apágala al cabo de un rato.
• Lámpara de atardecer: con una LDR, sube poco a poco el brillo de la tira a medida que oscurece.
• Ventilador inteligente: aumenta la velocidad de un ventilador de PC de 12 V conforme sube la temperatura medida con un DHT11.
• Riego automático de plantas: riega tus macetas solas con un sensor de humedad del suelo y una bomba controlada por MOSFET; usa un MOSFET distinto para cada bomba.
• Cerradura con tarjeta: abre una cerradura de solenoide de 12 V durante 3 segundos cuando un RFID RC522 lea la tarjeta correcta.
• Invernadero inteligente: monta un invernadero inteligente que controle ventilador, bomba y calefactor con MOSFET separados.

Errores frecuentes y soluciones

El MOSFET es la forma más limpia de conectar Arduino con cargas potentes del mundo real: con una pieza de nivel lógico bien elegida, una resistencia de puerta, una pull-down y un diodo para las cargas inductivas, controlas cualquier carga de CC, de una tira LED a una bomba, de forma silenciosa y eficiente. En la app BlueGrays encontrarás proyectos como el fundido de LED con PWM, el control de brillo con potenciómetro, una estación de riego inteligente o iluminación inteligente, con esquemas y código paso a paso, para convertir enseguida en un proyecto real el circuito con MOSFET que has aprendido aquí.