Cerradura solenoide Arduino: cerradura de 12V con MOSFET y RFID
Guía de cerradura solenoide con Arduino: cómo funciona la de 12V, control con MOSFET o relé, diodo flyback, calentamiento, teclado y RFID, fail-safe y ESP32.
Una cerradura solenoide es un pestillo eléctrico que retrae su lengüeta cuando circula corriente por la bobina interior y deja que un muelle la saque de nuevo cuando la corriente se corta. Con una cerradura solenoide y Arduino puedes hacer un armario con código, una puerta que se abre con una tarjeta RFID, un cajón que se abre con la huella o un buzón que desbloqueas desde el móvil. El tipo más común en proyectos de hobby es la pequeña "cerradura de armario" de 12 V que consume unos 0,5-1 A. Eso es entre 25 y 50 veces lo que puede dar un pin de Arduino, por lo que la cerradura no se controla directamente desde un pin, sino a través de un MOSFET o un relé.
En esta guía explicaré qué hay dentro de una cerradura solenoide, cómo calcular su corriente y potencia, dos formas de controlarla con un MOSFET o un relé, el diodo flyback imprescindible para no quemar tu placa y por qué la bobina solo debe alimentarse durante poco tiempo. Después escribiremos el código de una cerradura con teclado, otra con tarjeta RC522 y otra con ESP32 que se abre desde el móvil. Por último veremos fail-safe y fail-secure, que deciden qué pasa cuando se va la luz. Si los MOSFET son nuevos para ti, cómo usar un MOSFET con Arduino es un buen comienzo.
¿Qué es una cerradura solenoide y cómo funciona?
La palabra "solenoide" describe una bobina de hilo enrollada alrededor de un tubo. Cuando circula corriente por la bobina se forma un campo magnético en su interior que atrae hacia sí el núcleo de hierro (émbolo) del centro. En la cerradura, ese émbolo está unido a una lengüeta con la cara inclinada. Sin corriente, un muelle mantiene la lengüeta fuera y la puerta queda cerrada; al aplicar 12 V el émbolo se retrae, la lengüeta entra y la puerta se abre. Gracias a la cara inclinada, al cerrar la puerta la lengüeta se empuja hacia dentro y vuelve a encajar sola, así que cerrar no necesita energía. Si te interesa cómo se comportan las bobinas, consulta qué es una bobina.
| Característica | Cerradura solenoide típica de 12 V | Nota |
|---|---|---|
| Tensión de trabajo | 12 V CC | A 9 V tira poco; a 5 V normalmente no abre |
| Corriente | 0,5-1 A (lo habitual, 0,6-0,8 A) | Mira la etiqueta o mide la resistencia de la bobina |
| Resistencia de la bobina | Unos 12-24 Ω | I = V / R; 0,75 A con 16 Ω |
| Potencia | 6-12 W | P = V × I; 12 V × 0,75 A = 9 W |
| Tiempo de activación | Unos segundos (máx. 10 s en la mayoría) | Se calienta si se mantiene abierta |
| Al cortarse la luz | Sigue cerrada (fail-secure) | Las cerraduras electromagnéticas hacen lo contrario y se abren |
Si no sabes la corriente de tu cerradura, pon el multímetro en ohmios, mide la resistencia entre los dos cables de la bobina y calcula la corriente con la calculadora de la ley de Ohm. Si mides 16 Ω a 12 V, la cerradura consume 0,75 A; elige una fuente de al menos el doble, es decir, 12 V 2 A. En el primer tirón la corriente puede subir un instante, y si la tensión de un adaptador débil cae, la cerradura no abre del todo.
Controlar la cerradura solenoide con un MOSFET o un relé
Hay dos métodos habituales. Un MOSFET es silencioso, rápido, no se desgasta y ocupa poco; bien elegido ni siquiera se calienta. Lo que hay que buscar es que sea de "nivel lógico": su puerta (gate) debe conducir del todo a 5 V, o a 3,3 V si usas un ESP32. El IRLZ44N tiene unos 0,025 Ω a 5 V; a 0,75 A disipa P = I² × R ≈ 14 mW, así que no necesita disipador. Los populares módulos IRF520, en cambio, están pensados para 10 V de puerta y a 5 V quedan medio abiertos y se calientan. Un módulo de relé es sencillo y además aísla los dos circuitos; sus pegas son el clic, el desgaste de los contactos y la corriente de su propia bobina. Para elegir transistor o MOSFET, consulta los valores de la herramienta de transistores.
| Conexión (circuito con MOSFET) | ¿Dónde? | ¿Por qué? |
|---|---|---|
| Cerradura rojo (+) | + del adaptador de 12 V | La bobina siempre va al positivo |
| Cerradura negro (-) | Drain (D) del MOSFET | El MOSFET conmuta el lado negativo |
| Source (S) del MOSFET | - del adaptador de 12 V y GND del Arduino | Masa común |
| Gate (G) del MOSFET | Arduino D10 con 220 Ω en serie | Limita el pico de carga del pin |
| Resistencia de 10 kΩ | Entre gate y GND | Evita que la cerradura se abra al encender |
| Diodo 1N4007 | En inversa sobre la cerradura; la franja al +12 V | Absorbe el pico de tensión inversa de la bobina |
| Condensador de 470 µF | Entre + y - de 12 V, cerca de la cerradura | Reduce la caída de tensión al tirar |
Alimentar el Arduino y la cerradura con el mismo adaptador de 12 V es práctico: puedes dar 12 V al Uno por su conector DC. Pero la tensión cae un instante cuando la cerradura tira y el regulador del Uno se calienta al bajar de 12 V a 5 V; una opción más robusta es bajar los 12 V a 5 V con un módulo LM2596 y alimentar la placa por su pin 5V. En cualquier caso, el source del MOSFET, el negativo del adaptador y el GND del Arduino deben unirse en un punto; explico por qué en detalle en GND y tierra común.
Activación breve y calor: ¿cuánto tiempo puede estar abierta la cerradura?
Disipar 9 W en una bobina pequeña es como tener un pequeño soldador encendido en el espacio de la palma de tu mano. Las cerraduras de armario baratas suelen estar pensadas para servicio intermitente: abrir unos segundos no es problema, pero si se mantiene abierta durante minutos la bobina se calienta tanto que no se puede tocar, el barniz aislante se degrada y la cerradura pierde fuerza con el tiempo. Por eso define siempre en el software un tiempo máximo de apertura; en los códigos de este artículo son 3 segundos. Si la puerta debe quedar abierta mucho tiempo, hay dos soluciones: elegir una cerradura que retenga la lengüeta mecánicamente o dar toda la potencia al tirar y luego reducirla con PWM. La bobina necesita mucha más fuerza para atraer la lengüeta que para retenerla; tras 200 ms a plena potencia, un PWM del 30-40 % la mantiene dentro en la mayoría de cerraduras y reduce varias veces el calentamiento. Tienes cómo funciona el PWM en qué es PWM.
Cerradura con código y teclado matricial

El primer proyecto usa un teclado 4x4 para introducir el código. Conecta los pines de fila a D9, D8, D7, D6 y los de columna a D5, D4, D3, D2; el gate del MOSFET va a D10 y un pequeño zumbador activo a A0. Instala la librería Keypad de Mark Stanley desde el Gestor de librerías. Escribes el código y confirmas con #, y * borra la entrada. Tras tres intentos fallidos el teclado se bloquea 30 segundos; esta pequeña medida hace prácticamente imposible adivinar el código probando. Tienes cómo funciona el teclado por dentro en el artículo del teclado matricial.
1// Keypad şifreli solenoid kilit / keypad-code solenoid lock
2#include <Keypad.h>
3
4const int LOCK_PIN = 10; // MOSFET gate (220 ohm üzerinden / via 220 ohm)
5const int BUZZER_PIN = A0; // aktif buzzer / active buzzer
6const unsigned long OPEN_MS = 3000; // kilit açık süresi / unlock time
7const unsigned long LOCKOUT_MS = 30000; // 3 hatadan sonra bekleme / lockout after 3 errors
8const char* PASSWORD = "2580"; // şifreyi değiştir / change the code
9
10const byte ROWS = 4, COLS = 4;
11char keys[ROWS][COLS] = {
12 {'1', '2', '3', 'A'},
13 {'4', '5', '6', 'B'},
14 {'7', '8', '9', 'C'},
15 {'*', '0', '#', 'D'}
16};
17byte rowPins[ROWS] = {9, 8, 7, 6};
18byte colPins[COLS] = {5, 4, 3, 2};
19Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS);
20
21String input = "";
22int wrongCount = 0;
23bool lockedOut = false;
24unsigned long lockoutStart = 0;
25
26void beep(int ms) {
27 digitalWrite(BUZZER_PIN, HIGH);
28 delay(ms);
29 digitalWrite(BUZZER_PIN, LOW);
30}
31
32void unlock() {
33 digitalWrite(LOCK_PIN, HIGH); // bobine enerji ver, dil çekilir / energise coil, bolt retracts
34 delay(OPEN_MS); // yalnız kısa süre / short time only
35 digitalWrite(LOCK_PIN, LOW); // yay dili geri iter / spring pushes the bolt back
36}
37
38void setup() {
39 pinMode(LOCK_PIN, OUTPUT);
40 digitalWrite(LOCK_PIN, LOW); // açılışta kilitli / locked at power-up
41 pinMode(BUZZER_PIN, OUTPUT);
42}
43
44void loop() {
45 char k = keypad.getKey();
46 if (!k) return;
47
48 if (lockedOut) {
49 if (millis() - lockoutStart < LOCKOUT_MS) { beep(300); return; }
50 lockedOut = false;
51 }
52 beep(30);
53
54 if (k == '*') { input = ""; return; } // temizle / clear
55 if (k == '#') { // onayla / confirm
56 if (input == PASSWORD) {
57 wrongCount = 0;
58 unlock();
59 } else {
60 beep(600);
61 if (++wrongCount >= 3) { // kaba kuvvete karşı / against brute force
62 lockedOut = true;
63 lockoutStart = millis();
64 wrongCount = 0;
65 }
66 }
67 input = "";
68 return;
69 }
70 if (input.length() < 8) input += k; // en fazla 8 hane / max 8 digits
71}Cerradura que se abre con tarjeta RFID (RC522)

En el segundo proyecto la cerradura se abre al pasar una tarjeta RFID registrada. Conecta el RC522 al Uno así: SDA → D10, SCK → D13, MOSI → D11, MISO → D12, RST → D9, 3.3V → 3.3V y GND → GND; como el SPI usa D10-D13, esta vez el gate del MOSFET va a D6. Instala la librería MFRC522, sube el código, acerca tu tarjeta y copia en la lista ALLOWED el UID que aparece en el Monitor Serie. Como los UID de las tarjetas se pueden clonar, este método sirve para armarios y cajones; por sí solo no basta donde se necesita mucha seguridad, como una puerta exterior. Para más detalles del RC522, consulta la guía del RFID RC522.
1// RFID kartla solenoid kilit / RFID card solenoid lock
2#include <SPI.h>
3#include <MFRC522.h>
4
5const int SS_PIN = 10; // RC522 SDA
6const int RST_PIN = 9; // RC522 RST
7const int LOCK_PIN = 6; // MOSFET gate
8const unsigned long OPEN_MS = 3000;
9
10// Yetkili kart UID'leri, Seri Monitör'den oku / authorised UIDs, read them from the Serial Monitor
11const byte ALLOWED[][4] = {
12 {0xDE, 0xAD, 0xBE, 0xEF},
13 {0x12, 0x34, 0x56, 0x78}
14};
15const int ALLOWED_COUNT = sizeof(ALLOWED) / sizeof(ALLOWED[0]);
16
17MFRC522 rfid(SS_PIN, RST_PIN);
18
19bool isAllowed(const byte* uid, byte size) {
20 if (size != 4) return false;
21 for (int i = 0; i < ALLOWED_COUNT; i++) {
22 if (memcmp(uid, ALLOWED[i], 4) == 0) return true;
23 }
24 return false;
25}
26
27void setup() {
28 Serial.begin(9600);
29 pinMode(LOCK_PIN, OUTPUT);
30 digitalWrite(LOCK_PIN, LOW);
31 SPI.begin();
32 rfid.PCD_Init();
33}
34
35void loop() {
36 if (!rfid.PICC_IsNewCardPresent() || !rfid.PICC_ReadCardSerial()) return;
37
38 Serial.print("UID:");
39 for (byte i = 0; i < rfid.uid.size; i++) {
40 Serial.print(rfid.uid.uidByte[i] < 0x10 ? " 0" : " ");
41 Serial.print(rfid.uid.uidByte[i], HEX);
42 }
43 Serial.println();
44
45 if (isAllowed(rfid.uid.uidByte, rfid.uid.size)) {
46 Serial.println("Açıldı / unlocked");
47 digitalWrite(LOCK_PIN, HIGH);
48 delay(OPEN_MS);
49 digitalWrite(LOCK_PIN, LOW);
50 } else {
51 Serial.println("Yetkisiz kart / unknown card");
52 }
53 rfid.PICC_HaltA(); // kartı beklemeye al / halt the card
54}¿Qué pasa si se va la luz? Fail-safe y fail-secure
La primera pregunta al elegir una cerradura eléctrica es: si se va la luz, ¿la puerta debe quedar abierta o cerrada? Las cerraduras fail-secure siguen cerradas sin energía; así funcionan los solenoides tipo armario, y son la opción correcta para cajas fuertes, cajones y buzones de paquetes. Las fail-safe, en cambio, se abren al cortarse la corriente; así funcionan las cerraduras electromagnéticas de los edificios, porque en un incendio o apagón la gente tiene que poder salir. Poner una cerradura fail-secure en una puerta de evacuación es peligroso y en la mayoría de sitios va contra la normativa.
| Tipo de cerradura | Si se va la luz | Uso adecuado |
|---|---|---|
| Cerradura solenoide de armario | Sigue cerrada (fail-secure) | Armarios, cajas fuertes, cajones, cajas |
| Cerradura electromagnética de puerta | Se abre (fail-safe) | Entradas de edificios, vías de evacuación |
| Cerradero eléctrico | Cualquiera, según el modelo | Como añadido a una cerradura existente |
| Cerradura motorizada | Se queda en su última posición | Cerraduras inteligentes, sistemas a pilas |
Si usas una cerradura fail-secure, piensa en un plan B para no quedarte fuera: una llave mecánica de repuesto, un botón de apertura de emergencia oculto o una batería de respaldo que mantenga la cerradura y el Arduino un tiempo. Por ejemplo, una pequeña batería de plomo de 12 V o un pack de litio 3S con circuito de carga da para unos cientos de aperturas durante un apagón.
Abrir la cerradura solenoide desde el móvil con un ESP32
El ESP32 es la forma más sencilla de abrir la cerradura por WiFi. El código siguiente monta un pequeño servidor web; al abrir en el navegador del móvil la IP que aparece en el Monitor Serie, te pide usuario y contraseña y después muestra un gran botón ABRIR. Al pulsarlo, la cerradura se abre 3 segundos y vuelve a cerrarse sola con millis(), mientras el servidor sigue funcionando. Una diferencia importante: los pines del ESP32 dan 3,3 V. Un IRLZ44N puede no conducir del todo con esa tensión; usa un MOSFET especificado para conmutar a 2,5-4,5 V como el IRLB8721 o el AO3400, o controla la cerradura con un módulo de relé que se active a 3,3 V. Para alimentar el ESP32 desde 12 V, bájalos a 5 V con un LM2596 y llévalos al pin 5V (VIN).
1// ESP32: telefondan solenoid kilit açma / open the solenoid lock from your phone
2#include <WiFi.h>
3#include <WebServer.h>
4
5const char* WIFI_SSID = "AgAdi"; // Wi-Fi adın / your Wi-Fi name
6const char* WIFI_PASS = "Sifre123"; // Wi-Fi şifren / your Wi-Fi password
7const char* WEB_USER = "kapi"; // sayfa kullanıcı adı / page user name
8const char* WEB_PASS = "degistir-beni"; // sayfa şifresi, değiştir / page password, change it
9const int LOCK_PIN = 26; // MOSFET gate (3,3 V ile tam açılan / fully on at 3.3 V)
10const unsigned long OPEN_MS = 3000;
11
12WebServer server(80);
13bool isOpen = false;
14unsigned long openedAt = 0;
15
16const char PAGE[] = R"html(<!DOCTYPE html><html><head>
17<meta name="viewport" content="width=device-width,initial-scale=1"><title>Kapi</title></head>
18<body style="font-family:sans-serif;text-align:center;margin-top:40px">
19<h2>Solenoid kilit / lock</h2>
20<form method="POST" action="/open"><button style="font-size:28px;padding:20px 40px">AC / OPEN</button></form>
21</body></html>)html";
22
23bool checkAuth() {
24 if (server.authenticate(WEB_USER, WEB_PASS)) return true;
25 server.requestAuthentication(); // tarayıcı şifre sorar / browser asks for a password
26 return false;
27}
28
29void handleRoot() {
30 if (!checkAuth()) return;
31 server.send(200, "text/html", PAGE);
32}
33
34void handleOpen() {
35 if (!checkAuth()) return;
36 if (!isOpen) {
37 digitalWrite(LOCK_PIN, HIGH); // kilidi aç / unlock
38 isOpen = true;
39 openedAt = millis();
40 }
41 server.sendHeader("Location", "/");
42 server.send(303); // ana sayfaya dön / back to the main page
43}
44
45void setup() {
46 pinMode(LOCK_PIN, OUTPUT);
47 digitalWrite(LOCK_PIN, LOW);
48 Serial.begin(115200);
49 WiFi.mode(WIFI_STA);
50 WiFi.begin(WIFI_SSID, WIFI_PASS);
51 while (WiFi.status() != WL_CONNECTED) delay(500);
52 Serial.println(WiFi.localIP()); // bu adresi telefonda aç / open this on your phone
53
54 server.on("/", HTTP_GET, handleRoot);
55 server.on("/open", HTTP_POST, handleOpen);
56 server.begin();
57}
58
59void loop() {
60 server.handleClient();
61 if (isOpen && millis() - openedAt >= OPEN_MS) { // süre dolunca kilitle / relock when time is up
62 digitalWrite(LOCK_PIN, LOW);
63 isOpen = false;
64 }
65}- El servidor solo es accesible en la red de casa; para abrir desde fuera, usa un intermediario como un bot de Telegram o MQTT en lugar de abrir un puerto en el router.
- La contraseña que pide el navegador viaja casi como texto plano por la red; en casa es aceptable, pero tu contraseña del WiFi debe ser robusta y debes cambiar WEB_PASS.
- La orden de apertura se envía por POST, así que el navegador no puede activar la cerradura al precargar la página o reabrirla desde el historial.
- Para más detalles sobre la página web y mostrar el estado en vivo, consulta servidor web y WebSocket con ESP32.
Errores frecuentes y cómo solucionarlos
| Síntoma | Causa | Solución |
|---|---|---|
| La cerradura hace clic pero no abre | La fuente no da corriente suficiente o cae la tensión | Usa una fuente de 12 V 2 A y un condensador de 470 µF |
| El Arduino se reinicia al abrir | Falta el diodo flyback o las masas no son comunes | Pon el diodo y une las masas en un punto |
| El MOSFET se calienta | No es de nivel lógico (p. ej. IRF520) o la resistencia de gate es grande | Usa un IRLZ44N, o IRLB8721/AO3400 con ESP32 |
| La cerradura se abre un instante al encender | El gate queda al aire | Añade 10 kΩ entre gate y GND |
| La cerradura nunca cierra, siempre abierta | MOSFET perforado (a menudo por usarlo sin diodo) | Cambia el MOSFET y añade el diodo |
| La bobina se calienta mucho | Está alimentada demasiado tiempo | Limita el tiempo de apertura o baja la potencia de retención con PWM |
Con un MOSFET, un diodo y unas pocas líneas de código, una cerradura solenoide puede ser uno de tus primeros proyectos que abre y cierra algo de verdad. En la app BlueGrays encontrarás proyectos como autenticación RFID, una cerradura con teclado y LCD, una caja fuerte electrónica inteligente y una cerradura RFID con ESP32, cada uno con esquema y código paso a paso, listos para añadirles el circuito de control del solenoide de este artículo.
Preguntas frecuentes
¿Se puede conectar una cerradura solenoide directamente al Arduino?
No. Una cerradura solenoide de 12 V consume 0,5-1 A, mientras que un pin de Arduino da como mucho 20-40 mA a 5 V. Alimenta la cerradura con una fuente de 12 V aparte a través de un MOSFET de nivel lógico (como el IRLZ44N) o un módulo de relé. No olvides el diodo flyback en la bobina.
¿Cuántos amperios consume una cerradura solenoide?
Las cerraduras de armario de 12 V que se usan en proyectos de hobby suelen consumir 0,5-1 A, normalmente 0,6-0,8 A. Puedes medir la resistencia de la bobina y calcularlo con I = V / R; una bobina de 16 Ω consume 0,75 A a 12 V. Elige una fuente de al menos el doble.
¿Qué MOSFET uso para una cerradura solenoide?
En placas de 5 V como el Arduino Uno van bien MOSFET de nivel lógico como el IRLZ44N o el IRL540N. En placas de 3,3 V como el ESP32 y la Pico elige modelos que conduzcan del todo a baja tensión, como el IRLB8721 o el AO3400. Los módulos IRF520 no se recomiendan porque necesitan 10 V en la puerta.
¿Por qué hace falta un diodo flyback?
Cuando se corta la corriente de una bobina, el campo magnético se derrumba y genera un pico de tensión inversa de cientos de voltios. Ese pico estropea el MOSFET, reinicia el Arduino o daña su pin. Un diodo como el 1N4007, conectado en inversa sobre la cerradura, absorbe el pico con seguridad.
¿Se puede mantener abierta una cerradura solenoide todo el tiempo?
La mayoría de cerraduras de armario baratas están pensadas para servicio intermitente y se calientan mucho en pocos minutos si se alimentan sin parar. Limita por software el tiempo de apertura a unos segundos. Si tiene que estar abierta más tiempo, da toda la potencia al tirar y luego baja la potencia de retención con PWM.
¿Una cerradura solenoide se abre si se va la luz?
Las cerraduras solenoide de armario son fail-secure, es decir, siguen cerradas al cortarse la corriente. Las cerraduras electromagnéticas de puerta son fail-safe y se abren sin energía. En puertas de evacuación se prefieren las fail-safe; en cajas fuertes y armarios, las fail-secure.
Proyectos para hacer después de leer esto
Ver todos los proyectos
Caja fuerte electrónica inteligente
Una pequeña caja fuerte para tus cosas de valor que se abre con un código. Escribes tu código de cuatro cifras en el teclado; si es correcto, el servomotor abre el cierre, se enciende la luz verde y…

Cerradura con contraseña, teclado 4x4 y LCD
Una pequeña cerradura electrónica que no deja pasar a quien no sepa la clave. Pulsas la tecla de almohadilla y escribes la clave en el teclado; si es correcta, la pantalla indica acceso permitido, se…

Autenticación RFID
Como el acceso con tarjeta del portal de un edificio: acercas tu tarjeta al lector RFID y el Arduino compara su número con el que tiene guardado.

Lectura de valores RFID
El llavero del portal o la tarjeta de acceso guardan un número de identificación secreto, y este proyecto lo lee.

Cerradura RFID ESP32 (RC522 + servo + OLED + zumbador + LED)
Construimos una cerradura inteligente con un ESP32, un módulo RFID RC522, un servo SG90, una pantalla OLED SSD1306, un zumbador activo y 2 LED. Al pasar una tarjeta, su UID se compara con las autorizadas definidas en el código; si coincide, el servo abre (LED verde + 2 pitidos cortos) y vuelve a cerrar a los 5 segundos. Con una tarjeta no autorizada se enciende el LED rojo, suenan 3 pitidos rápidos y la OLED muestra su UID.

Lector de tarjetas RFID RC522 para ESP32 (con LCD)
En este proyecto, conectaremos el módulo RFID RC522 basado en MFRC522 al ESP32 a través de SPI y leeremos el UID de la tarjeta o etiqueta. Esto constituye la base de aplicaciones como cerraduras, sistemas de afiliación y control de acceso. Mostraremos el UID leído en la pantalla LCD; esta versión no lo compara con una lista de tarjetas autorizadas. ATENCIÓN: El RC522 solo funciona a 3,3 V; si le aplicas 5 V, ¡el módulo se quemará!

Funcionamiento del teclado 3x4
El Arduino sabe al instante qué tecla pulsas en un teclado de 12 teclas parecido al de un teléfono, y la escribe en la pantalla de tu ordenador.

Bombilla 220V con Pulsador (Push)
Mientras mantienes pulsado el botón, una bombilla real de 220 voltios se queda encendida, y se apaga en cuanto lo sueltas.
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

