Comandos de Arduino: 36 tarjetas con C++ y MicroPython a la par

La forma más fiable de aprender los comandos de Arduino no es memorizar una lista larga, sino recorrerlos en orden, cada uno con un ejemplo pequeño y un proyecto real. Para eso la app BlueGrays tiene la Guía de código en la sección Lecciones de su pestaña Aprende: 18 tarjetas en la ruta Arduino C++, de pinMode a tone, y 18 tarjetas en la ruta MicroPython, de import a I2C, 36 tarjetas en total. Todas siguen el mismo esquema: ¿Para qué sirve?, ¿Por qué?, Sintaxis, Ejemplo (con las pestañas Bloques, Arduino y MicroPython), Error frecuente, Consejo, Verlo en proyectos y un Minitest de dos preguntas. El orden también está fijado: primero los pines (pinMode, digitalWrite, digitalRead, analogRead, analogWrite), después el tiempo (delay, millis), luego variables, condiciones, bucles y funciones, y al final Serial, map, random y tone. Si usas una Raspberry Pi Pico, aprendes las mismas ideas en la ruta MicroPython con Pin, Pin.value, time.sleep, ADC.read_u16 y PWM.

Este artículo es un mapa de la guía. Primero verás qué hay dentro de una tarjeta y después las 18 tarjetas de cada ruta en su orden real dentro de la app, con el equivalente en el otro lenguaje. Luego vienen tres ejemplos cortos que ponen lado a lado la versión en C++ y en MicroPython del mismo programa, cómo funcionan el minitest y el registro de progreso, un orden de aprendizaje de 4 semanas, una rutina diaria de 20 minutos y los 8 errores más frecuentes con estos comandos. Si buscas una explicación detallada de cada comando, el artículo comandos de Arduino con sintaxis y ejemplos dedica una sección a cada uno; este explica en qué orden aprenderlos y cómo practicar.

¿Dónde está la Guía de código y cómo funciona?

Entras a la guía desde la pestaña Aprende de abajo: en la sección Lecciones, arriba, toca la casilla Guía de código. Al abrir la guía ves dos pestañas arriba: Arduino C++ y MicroPython; la app recuerda qué ruta abriste la última vez. Debajo están el contador Lo que has aprendido y la línea Siguiente tarjeta, así que nunca tienes que buscar dónde lo dejaste. Las tarjetas se agrupan por temas: Pines, Tiempo, Variables, Condiciones, Bucles, Funciones, Puerto serie, Matemáticas y Sonido; la ruta MicroPython añade Estructura básica y Manejo de errores. La Guía de código es gratis: no necesitas Premium para leer las tarjetas, ver los ejemplos ni resolver los minitests. Las tarjetas están en 10 idiomas, así que lees las explicaciones en el idioma en el que usas la app.

¿Qué hay dentro de una tarjeta?

Todas las tarjetas usan el mismo esqueleto, así que a partir de la tercera ya sabes dónde mirar. La tabla muestra las secciones con la 7.ª tarjeta de la ruta Arduino, millis; la columna de la derecha resume lo que dice la tarjeta. El orden de las secciones es en sí un orden de aprendizaje: primero oyes en una frase qué hace el comando, luego entiendes para qué lo necesitas con una comparación cotidiana, ves cómo se escribe, lees un ejemplo que funciona, conoces la trampa más común y te pones a prueba con dos preguntas.

La sección Ejemplo se abre en la ruta de la propia tarjeta: en una tarjeta de Arduino aparece primero la pestaña Arduino, en una de MicroPython la pestaña MicroPython. Pero la otra pestaña siempre está ahí, y eso convierte la guía en un diccionario. En la tarjeta Pin de salida: Pin(15, Pin.OUT) de la ruta MicroPython, por ejemplo, la pestaña Arduino contiene código que hace lo mismo con pinMode y digitalWrite, y los comentarios dicen qué línea corresponde a qué (como la línea que equivale a led.toggle()). Casi todas las tarjetas tienen además una tercera pestaña, Bloques, que muestra el programa de ejemplo en bloques. Si pasas de Arduino a la Pico, el método más rápido es este: abre una tarjeta que conozcas, cambia de pestaña y empareja los dos programas línea a línea.

Ruta Arduino C++: 18 tarjetas y sus equivalentes en MicroPython

La tabla es el orden real de la ruta Arduino en la app; la última columna muestra cómo se hace lo mismo con MicroPython en una Raspberry Pi Pico. Los números de pin coinciden con los ejemplos de las tarjetas: para un LED, 13 o 9 en el Uno y GP15 en la Pico; para un botón, 2 en el Uno y GP14 en la Pico; para la lectura analógica, A0 en el Uno y GP26 en la Pico. Las cinco primeras tarjetas tratan los pines, la 6 y la 7 el tiempo, de la 8 a la 14 las bases de la programación, y las cuatro últimas el puerto serie, el cambio de escala, los números aleatorios y el sonido. El orden es intencionado: primero aprendes cómo la placa toca el mundo exterior y después controlas esos contactos con variables, condiciones y bucles.

Ruta MicroPython: 18 tarjetas y sus equivalentes en Arduino

La ruta MicroPython está pensada para la Raspberry Pi Pico; los ejemplos de las tarjetas son programas cortos que puedes ejecutar en una Pico, por ejemplo con Thonny. El orden difiere un poco del de la ruta Arduino, porque en Python primero hay que acostumbrarse a las reglas del propio lenguaje: añadir módulos con import, mostrar texto con print y la regla de la sangría y los dos puntos. La pestaña Arduino de cada tarjeta de MicroPython incluye también la versión en C++ del mismo programa, así que, si ya sabes Arduino, puedes leer la tabla de derecha a izquierda. Si es tu primera Pico, el artículo qué es la Raspberry Pi Pico es una buena preparación para la instalación y los pines.

El mismo programa en dos lenguajes: 3 ejemplos lado a lado

El primer ejemplo es el «hola mundo» de cualquier lenguaje: hacer parpadear el LED de la placa cada medio segundo. En el Uno el LED integrado está en el pin 13, así que no necesitas montar ningún circuito. En la Pico es algo distinto: en la Pico normal el LED integrado está en GP25, pero en la Pico W ese LED va conectado al chip inalámbrico y Pin(25) no lo enciende. Por eso en MicroPython es más seguro escribir Pin("LED", Pin.OUT); en las versiones actuales de MicroPython ese nombre encuentra el LED integrado tanto en la Pico como en la Pico W. Si el firmware de tu placa no reconoce el nombre "LED", instala un MicroPython actual en la Pico. El proyecto gratuito Parpadeo LED Integrado Raspberry Pi Pico (Pico y Pico W) explica justo esta diferencia.

1// Örnek 1: dahili LED'i yakıp söndür / Example 1: blink the built-in LED
2void setup() {
3  pinMode(13, OUTPUT);     // Uno'da dahili LED 13. pinde / built-in LED is on pin 13 on the Uno
4}
5
6void loop() {
7  digitalWrite(13, HIGH);  // LED yanar / LED on
8  delay(500);              // 500 ms bekle / wait 500 ms
9  digitalWrite(13, LOW);   // LED söner / LED off
10  delay(500);              // 500 ms bekle / wait 500 ms
11}

1# Örnek 1: dahili LED'i yakıp söndür / Example 1: blink the onboard LED
2from machine import Pin
3import time
4
5led = Pin("LED", Pin.OUT)  # Pico ve Pico W'de dahili LED / onboard LED on Pico and Pico W
6# Pin(25, Pin.OUT) yalnız düz Pico'da çalışır / Pin(25, Pin.OUT) works only on the plain Pico
7
8while True:                # Arduino'daki loop() gibi / like loop() in Arduino
9    led.on()               # LED yanar / LED on
10    time.sleep_ms(500)     # 500 ms bekle / wait 500 ms
11    led.off()              # LED söner / LED off
12    time.sleep_ms(500)     # 500 ms bekle / wait 500 ms

El segundo ejemplo añade una entrada: el LED se enciende mientras el botón está pulsado. El botón va entre el pin 2 y GND en el Uno, y entre GP14 y GND en la Pico. En el Uno volvemos a usar el LED integrado del pin 13; en la Pico, conecta un LED externo a GP15 con una resistencia de 220 Ω (la herramienta Resistencia para LED calcula el valor para tu propio LED). En los dos lenguajes se activa la resistencia pull-up interna: INPUT_PULLUP en Arduino y Pin.PULL_UP en MicroPython. Con este montaje la lógica va al revés: al pulsar, el pin se lleva a GND, así que el Arduino lee LOW y la Pico lee 0. La pausa de 20 ms del final no resuelve del todo el rebote mecánico del botón, pero reduce los parpadeos muy cortos. Los detalles del montaje están en el artículo cómo conectar un botón a Arduino.

1// Örnek 2: butona basılıyken LED yanar / Example 2: LED on while the button is pressed
2const int BUTTON_PIN = 2;  // buton: 2. pin ile GND arasında / button between pin 2 and GND
3const int LED_PIN = 13;    // dahili LED / built-in LED
4
5void setup() {
6  pinMode(BUTTON_PIN, INPUT_PULLUP);  // iç pull-up direnci açık / internal pull-up on
7  pinMode(LED_PIN, OUTPUT);
8}
9
10void loop() {
11  if (digitalRead(BUTTON_PIN) == LOW) {  // basılıyken LOW okunur / reads LOW while pressed
12    digitalWrite(LED_PIN, HIGH);
13  } else {
14    digitalWrite(LED_PIN, LOW);
15  }
16  delay(20);  // kısa bekleme / short pause
17}

1# Örnek 2: butona basılıyken LED yanar / Example 2: LED on while the button is pressed
2from machine import Pin
3import time
4
5button = Pin(14, Pin.IN, Pin.PULL_UP)  # buton: GP14 ile GND arasında / button between GP14 and GND
6led = Pin(15, Pin.OUT)                 # LED: GP15 + 220 ohm direnç / LED on GP15 with 220 ohm
7
8while True:
9    if button.value() == 0:            # basılıyken 0 okunur / reads 0 while pressed
10        led.value(1)
11    else:
12        led.value(0)
13    time.sleep_ms(20)                  # kısa bekleme / short pause

El tercer ejemplo muestra la diferencia más importante entre los dos lenguajes: los rangos de números. La patilla central del potenciómetro va a A0 en el Uno y a GP26 en la Pico; las patillas de los extremos van a 5V y GND en el Uno, y a 3V3 (OUT) y GND en la Pico. El LED va en el pin 9 (marcado con ~) en el Uno y en GP15 en la Pico, en ambos casos con una resistencia de 220 Ω. En Arduino, analogRead devuelve 0–1023 pero analogWrite espera 0–255, por eso entre ambos aparece map(raw, 0, 1023, 0, 255). En la Pico, read_u16 y duty_u16 usan los dos 0–65535, así que puedes pasar la lectura directamente al PWM. Cómo funciona el PWM lo tienes en el artículo qué es PWM, y cómo ver los valores en directo, en la guía del monitor serie.

1// Örnek 3: potansiyometreyle LED parlaklığı / Example 3: LED brightness with a potentiometer
2const int POT_PIN = A0;  // potansiyometrenin orta ucu / potentiometer wiper
3const int LED_PIN = 9;   // ~ işaretli PWM pini / PWM pin marked with ~
4
5void setup() {
6  pinMode(LED_PIN, OUTPUT);
7  Serial.begin(9600);
8}
9
10void loop() {
11  int raw = analogRead(POT_PIN);               // 0-1023
12  int brightness = map(raw, 0, 1023, 0, 255);  // 0-255 aralığına ölçekle / scale to 0-255
13  analogWrite(LED_PIN, brightness);
14  Serial.println(raw);                         // Seri Monitör'de izle / watch in the Serial Monitor
15  delay(50);
16}

1# Örnek 3: potansiyometreyle LED parlaklığı / Example 3: LED brightness with a potentiometer
2from machine import Pin, ADC, PWM
3import time
4
5pot = ADC(26)            # GP26 = ADC0, orta uç / wiper on GP26 (ADC0)
6led = PWM(Pin(15))       # LED: GP15 + 220 ohm direnç / LED on GP15 with 220 ohm
7led.freq(1000)           # saniyede 1000 aç-kapa / 1000 cycles per second
8
9while True:
10    raw = pot.read_u16()     # 0-65535
11    led.duty_u16(raw)        # aynı aralık, ölçekleme gerekmez / same range, no scaling needed
12    print(raw)               # Thonny kabuğunda izle / watch in the Thonny shell
13    time.sleep_ms(50)

Minitest, «Entendido» y tu progreso en Mi nivel

• Minitest: Cada tarjeta termina con dos preguntas, y el encabezado dice Minitest · 1 / 2. Al tocar una opción recibes enseguida Correcto. o No del todo. con una breve explicación; sigues con Siguiente pregunta.
• Puntuación: Al terminar las dos preguntas ves una puntuación como 2 / 2 correctas. La tarjeta no se puede terminar sin el test; en lugar del botón aparece Resuelve el minitest para terminar la tarjeta.
• Entendido: Cuando acabas el test aparece el botón Entendido, siguiente tarjeta (en la última tarjeta de una ruta, solo Entendido). Al tocarlo, la tarjeta se guarda como aprendida en tu cuenta, una pequeña celebración muestra tu progreso, por ejemplo ¡Genial! 5 / 18 tarjetas, y se abre la siguiente tarjeta.
• Insignia y contador: Las tarjetas aprendidas llevan la marca Aprendida en la lista y sube el contador Lo que has aprendido de la parte superior. Cuando terminas todas las tarjetas de una ruta aparece Has aprendido todas las tarjetas de esta ruta.
• Mi nivel: En la pantalla Mi nivel de la sección Aprende, bajo el título Guía de código y la nota Tarjetas aprendidas, hay dos barras separadas: Arduino C++ x/18 y MicroPython x/18. Estas barras cuentan solo las tarjetas de la guía de código.
• Una regla honesta contigo: La app no te frena tras una respuesta incorrecta; el botón Entendido aparece en cuanto terminas el test. Así que antes de tocarlo, asegúrate de poder explicar en voz alta por qué las dos respuestas son correctas; si no puedes, vuelve a la sección Ejemplo y lee el código otra vez línea a línea.

Verlo en proyectos: encontrar el comando en código real

El último paso para aprender un comando es reconocerlo en un proyecto que funciona y que ha escrito otra persona. En la sección Verlo en proyectos la tarjeta muestra algunos proyectos seleccionados y, debajo, una frase que dice en cuántos proyectos aparece el comando; el enlace Todos abre la lista completa. Está ordenada de fácil a difícil y se puede acotar con los filtros Todos, Gratis y Premium. millis, por ejemplo, aparece en el código de más de 50 proyectos: la lista empieza con el proyecto gratuito Control de LED con botón en ESP32 (Toggle), sigue con proyectos de iniciación para Pico como Piano de botones con Raspberry Pi Pico (5 botones + zumbador + grabadora) y Sensor de aparcamiento con Raspberry Pi Pico (HC-SR04 + 3 LED + zumbador), y sube a proyectos de nivel intermedio como Semáforo Raspberry Pi Pico con selector de 4 modos (máquina de estados, GP11-13 + GP4), que combinan un botón con temporización. Nuestra sugerencia: abre un proyecto gratuito de la lista, busca el comando en el código, cambia un valor y predice antes el resultado. Para ver qué hace cada línea del código, la pestaña Entender el código del proyecto es el paso natural siguiente.

Orden de aprendizaje recomendado: un plan de 4 semanas

Supongamos que puedes dedicar unos 20 minutos al día, 5 días por semana. Para terminar una ruta en 4 semanas basta con una tarjeta la mayoría de los días; los demás días repasas y trabajas en un proyecto en lugar de una tarjeta nueva. Si tienes un Arduino, sigue solo la columna de Arduino; si tienes una Pico, la de MicroPython. Si tienes las dos placas, termina primero la ruta Arduino y pasa a MicroPython el segundo mes; los conceptos son los mismos, así que la segunda ruta va mucho más rápido. Todos los proyectos de la tabla son gratis en BlueGrays. Si quieres un plan más amplio, la hoja de ruta de 30 días del artículo aplicación para aprender Arduino encaja bien con esta tabla; si das clase con la Pico, el plan de clase de Raspberry Pi Pico reparte las tarjetas de MicroPython en 6 semanas de clases.

Una rutina diaria de 20 minutos

1. 3 minutos, calentamiento: Resuelve las preguntas del día en la sección Aprende o repite el minitest de ayer. El objetivo es comprobar que hoy sigues recordando el comando de ayer.
2. 5 minutos, tarjeta nueva: Lee las secciones ¿Para qué sirve?, ¿Por qué? y Sintaxis. Copia la sintaxis a mano en un papel; al escribirla es mucho más difícil que se te escapen paréntesis y puntos y coma.
3. 3 minutos, ejemplo: Explícate el ejemplo línea a línea y luego cambia de pestaña. En una tarjeta de Arduino mira la pestaña MicroPython, en una de MicroPython la pestaña Arduino, y empareja las líneas que hacen lo mismo en los dos programas.
4. 2 minutos, minitest: Responde las dos preguntas y lee la explicación de la que hayas fallado. En este momento vuelve a mirar los recuadros Error frecuente y Consejo.
5. 6 minutos, proyecto: Abre un proyecto gratuito y fácil de la lista Verlo en proyectos, busca el comando en el código y cambia un solo valor: una espera, un número de pin o un umbral. Si tienes el circuito montado, súbelo a la placa; si no, predice el resultado y compruébalo con Entender el código.
6. 1 minuto, nota: Escribe una línea en tu cuaderno: el nombre del comando, su significado en una frase y su equivalente en el otro lenguaje. Al cabo de cuatro semanas esa página será tu propio diccionario de comandos.

8 errores frecuentes con estos comandos

La pestaña Bloques: entender un comando viéndolo

La pestaña Bloques te deja ver qué hace un comando sin escribir código, sobre todo en las primeras tarjetas de una ruta. En la imagen de arriba, pinMode se convierte en el bloque «configurar pin 9 como SALIDA», digitalWrite en «escribir ALTO en pin 9» y delay en «esperar 100 ms»; en la tarjeta pinMode, una nota bajo la vista de bloques indica además las opciones del menú desplegable: SALIDA, ENTRADA y ENTRADA (PULLUP). Los bloques se muestran en el idioma de la app y sirven para leer: en la app no arrastras bloques para escribir un programa, y a la placa siempre se sube el código real. La forma recomendada de usarlos: primero predice en la pestaña Bloques qué hará el programa, luego pasa a la pestaña Arduino y busca a qué línea corresponde cada bloque. En los proyectos con vista de bloques, el interruptor Ver en bloques de la página del proyecto te permite hacer el mismo emparejamiento con un proyecto entero; las bases están en el artículo qué es la programación por bloques.

En resumen, para aprender los comandos de Arduino no necesitas una lista larga: bastan el orden correcto, un pequeño ejemplo que funcione para cada comando, una comprobación de dos preguntas y un proyecto real que use el comando. Si empiezas hoy con la tarjeta pinMode, en cuatro semanas habrás terminado las 18 tarjetas y habrás visto cada comando con tus propios ojos en al menos un proyecto; cuando pases a la Pico, recorrerás los mismos conceptos en la ruta MicroPython mucho más rápido. Si quieres probar las tarjetas y los proyectos que incluyen, instala BlueGrays en tu móvil y abre la primera tarjeta en la sección Aprende.