Guía para principiantes de Arduino

Ya sea que sea un experto en sistemas integrados, un científico de secundaria o una persona curiosa, debe comenzar sus exploraciones electrónicas en alguna parte. Si el manual no es suficiente, consulte esta guía para principiantes de Arduino.

¿Qué es un Arduino?

Arduino es una marca de placas de microcontrolador de código abierto desarrollada por la empresa Arduino .

Cuando hablas de Arduino, generalmente se trata de la placa. Las placas Arduino son especiales porque son duraderas. Están destinados a ser utilizados por estudiantes (o cualquier persona) que pueda estropear las cosas y romper algo.

La otra cosa que los hace especiales es que son de código abierto. Las hojas de datos de todas las placas y escudos Arduino están disponibles en línea. Puedes hacer tu propia placa Arduino si tienes los conocimientos técnicos.

¿Qué significa esto para mi?

Para un principiante, esto significa:

1. No necesita hacer sus propios circuitos para estudiar microcontroladores.
2. Estas tablas vienen con características de seguridad para evitar que las rompas accidentalmente.
3. La comunidad de hardware de código abierto ha creado una amplia gama de tableros para diferentes propósitos, ¡incluso hay uno diseñado para poner productos electrónicos en la ropa !

Anatomía de una placa Arduino

Hay muchos tipos de placas Arduino. Algunas son tan pequeñas como una batería, mientras que otras son tan grandes como una cámara digital, pero todas tienen algunas partes en común:

1. unidad de microcontrolador
2. pines de cabecera
3. Puertos de alimentación y USB
4. Indicadores LED

También hay otras placas de terceros basadas en Arduino que son construidas por sus propios fabricantes, pero normalmente tienen estas cosas en común.

Unidad de microcontrolador (MCU)

La unidad de microcontrolador, también conocida como MCU, lee y controla todas las entradas y salidas de la placa. También almacena el código creado por el usuario que hace que haga cosas.

El Arduino Uno R3 tiene un chip MCU extraíble especial. De esta manera, puede reemplazar esa parte una vez que esté rota o desgastada. Otras placas tienen sus chips MCU soldados a la propia placa. El inconveniente es obvio, pero generalmente están hechos para ser mucho más pequeños y rápidos que sus contrapartes no soldadas.

Pines de encabezado

A los lados, deberías ver algunas piezas de plástico elevadas con agujeros en la parte superior. Son pines de cabecera hembra. Se supone que debes poner cables o pines de puente macho en ellos.

Arduino Uno pinout

There are two kinds of pins: GPIO and power pins. GPIO pins let you process inputs and outputs. By default, all Arduino pins are inputs. On the other hand, power pins are meant for moving electricity around the board. 5V and 3.3V always emit as much voltage as their name says. GND stands for “ground” and Vin lets you power the board through that pin.

Power and USB Ports

All Arduino boards typically have two types of ports: a USB port and DC barrel jack, but some don’t have a DC barrel jack. They usually get their power from either the USB port or the power pins.

DC barrel jacks are typically sized as 2.1×5.5mm with the inside as positive and outside as negative. They’re designed to accept anything between 7 and 20 volts, but you’re better off sticking to 9 volts whenever possible.

USB ports are different, depending on the model. They may use Type-A, Type-B, USBmicro, or Type-C. You can power the board through these, and they also serve as communication ports.

Indicator LEDs

Left (top to bottom): L, TX, and RX LEDs. Right: ON LED.

Lastly, there are typically three indicator LEDs that let you see the state of the board.

1. RX (Receive)
2. TX (Transmit)
3. L (LED Built in)
4. ON (Power On)

The L and ON pins are self-explanatory. One is a built-in LED that you can control, while the other turns on whenever electricity passes through the board. The first two, on the other hand, turn on whenever the Arduino receives or transmits information over serial communication.

Arduino IDE

Beginners should start with the Arduino IDE before moving to any other program, like PlatformIO, partly because it’s easy, with everything you need there. You’re also less likely to mess things up if you use this. It’s made for Arduino boards, after all.

The Arduino IDE has three important functions:

1. Editing
2. Building
3. Uploading

Normally, the building and uploading functions work hand-in-hand. As soon as you finish typing and editing your code, you can build it then upload everything straight to your board. But there are times when you only have to build it and don’t have to upload.

The Arduino IDE can be downloaded through the Arduino website.

Ways to Blink the Built-in LED

Hacer parpadear el LED incorporado es la versión Arduino de un script «Hello World» y es una forma sencilla de probar si Arduino está funcionando. Estoy demostrando todas las diferentes formas de hacerlo parpadear, incluso decirle a la computadora que ya está parpadeando.

Ejemplo 1: parpadeo básico

Estamos comenzando con el guión básico de parpadeo. Solo tendrá que encender el LED incorporado durante 0,5 segundos y luego apagarlo durante otros 0,5 segundos.

1. Abre tu IDE de Arduino.

2. Debería ser recibido con un nuevo boceto tan pronto como abra el IDE. De lo contrario, haga clic en «Archivo -> Nuevo» o presione Ctrl + N.

3. Reemplace el código en el IDE con el siguiente código:

configuración vacía () {
  // pon tu código de configuración aquí, para ejecutar una vez:
  pinMode(LED_BUILTIN, SALIDA);
}
 
bucle vacío () {
  // pon tu código principal aquí, para ejecutar repetidamente:
  digitalWrite(LED_BUILTIN, ALTO);
  retraso (500);
  digitalWrite(LED_BUILTIN, BAJO);
  retraso (500);
}

4. Vaya a «Sketch -> Cargar» o presione Ctrl + U para cargar su código en Arduino.

El código Arduino generalmente se divide en dos partes: setup()y loop().

Cuando vea setup(), se supone que debe definir sus salidas y entradas. En este caso, estamos utilizando pinMode()para convertir el LED_BUILTINpin en un pin de salida.

El LED_BUILTINpin es el pin 13 y está directamente conectado al LED L. Lo encenderá siempre que reciba suficiente electricidad para ponerlo en ALTO. Incluso puede reemplazar todas las instancias de LED_BUILTINcon 13y seguirá funcionando.

setup() is discussed more in the next example. Here, everything starts from the first line within loop(), and the Arduino executes that line, then does the second one, then third, and so on, until it reaches the last line. It will then go back to the first line after that. That’s why it’s called a loop().

In this example, we used digitalWrite() to power LED_BUILTIN to HIGH. 5V of electricity passes through here, then delay(500) will temporarily stop the Arduino from reading more code for 500 milliseconds. After that, the Arduino runs the next line, which bringsLED_BUILTIN down to LOW.

It’s actually a loop of turning it on, waiting for half a second, turning it off, waiting for another half of a second, then going back to the starting line again. It keeps lopping for as long as it’s connected to a power source.

Example 2: Three Blinks at Start-up

This time, we’re playing around with setup() so that we can make the built-in LED quickly blink three times before blinking slowly every 0.5 seconds.

1. On your current code, move the cursor to pinMode(LED_BUILTIN, OUTPUT); make a new line under void setup().

2. Paste the following code on that line:

 digitalWrite(LED_BUILTIN, HIGH);
 delay(1000);
 digitalWrite(LED_BUILTIN, LOW);
 delay(250);
 digitalWrite(LED_BUILTIN, HIGH);
 delay(1000);
 digitalWrite(LED_BUILTIN, LOW);
 delay(250);
 digitalWrite(LED_BUILTIN, HIGH);
 delay(1000);
 digitalWrite(LED_BUILTIN, LOW);
 delay(250);

3. Your code should look like the following:

void setup() {
  // put your setup code here, to run once:
  pinMode(LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, HIGH);
  delay(1000);
  digitalWrite(LED_BUILTIN, LOW);
  delay(250);
  digitalWrite(LED_BUILTIN, HIGH);
  delay(1000);
  digitalWrite(LED_BUILTIN, LOW);
  delay(250);
  digitalWrite(LED_BUILTIN, HIGH);
  delay(1000);
  digitalWrite(LED_BUILTIN, LOW);
  delay(250);
}
 
void loop() {
  // put your main code here, to run repeatedly:
  digitalWrite(LED_BUILTIN, HIGH);
  delay(500);
  digitalWrite(LED_BUILTIN, LOW);
  delay(500);
}

4. ¡Cargue su código, luego mire su Arduino go! Recuerde, es «Sketch -> Upload» o Ctrl + U para enviar su código a su tablero.

El ejemplo anterior habló loop()y cómo funciona. Retrocedamos un poco y ampliemos setup().

Todo lo que colocas en se setup()ejecuta una vez, tal como dice el comentario preescrito. Con esto, puedes hacer que tu Arduino haga algo para decirte que va a empezar a funcionar. Si tiene una pantalla LCD, OLED o AMOLED, ¡incluso podría darle una animación de carga falsa!

Un par de pantallas LCD QAPASS 16×2. De izquierda a derecha: vistas frontal y posterior.

Aquí también es donde se supone que debe iniciar comandos especiales, como establecer comunicación a través de serie.

Ejemplo 3: uso de la comunicación en serie

A diferencia de una comunicación en paralelo, una comunicación en serie envía datos desde el origen al destino un bit a la vez.

Esta vez, Arduino enviará algunos mensajes en serie para brindarle actualizaciones de estado.

1. En setup(), crea una nueva línea antes pinMode(LED_BUILTIN, OUTPUT);y escribe Serial.begin(9600);. Haz una nueva línea debajo para que se vea un poco más ordenada.

2. Haga una nueva línea después de pinMode(LED_BUILTIN, OUTPUT);, luego escriba Serial.println("Arduino, starting up!");esa nueva línea. Deje una nueva línea entre estos dos.

3. Ir loop()a Haga una nueva línea debajo digitalWrite(LED_BUILTIN, HIGH);y escriba Serial.println("LED on");. Haga lo mismo para digitalWrite(LED_BUILTIN, LOW);pero escriba Serial.println("LED off");en su lugar.

4. (Opcional) Puede dejar una nueva línea entre la primera delay(500)y digitalWrite(LED_BUILTIN, LOW);.

5. El código completo debería tener el siguiente aspecto:

configuración vacía () {
  // pon tu código de configuración aquí, para ejecutar una vez:
  Serial.begin(9600);
 
  pinMode(LED_BUILTIN, SALIDA);
 
  Serial.println("¡Arduino, iniciando!");
  digitalWrite(LED_BUILTIN, ALTO);
  retraso (1000);
  digitalWrite(LED_BUILTIN, BAJO);
  retraso (250);
  digitalWrite(LED_BUILTIN, ALTO);
  retraso (1000);
  digitalWrite(LED_BUILTIN, BAJO);
  retraso (250);
  digitalWrite(LED_BUILTIN, ALTO);
  retraso (1000);
  digitalWrite(LED_BUILTIN, BAJO);
  retraso (250);
}
 
bucle vacío () {
  // pon tu código principal aquí, para ejecutar repetidamente:
  digitalWrite(LED_BUILTIN, ALTO);
  Serial.println("LED encendido");
  retraso (500);
 
  digitalWrite(LED_BUILTIN, BAJO);
  Serial.println("LED apagado");
  retraso (500);
}

6. Cargue su código usando «Sketch -> Upload» o Ctrl + U.
7. Abra Serial Monitor yendo a «Herramientas -> Serial Monitor» o presionando Ctrl + Shift + M en el teclado. Debería aparecer una pantalla rectangular e imprimir todas las salidas en serie con las que programó su Arduino.

Como el software usa una consola para la depuración, se supone que debe usar Serial en el hardware para lo mismo.

En setup(), agregó la línea Serial.begin(9600);. Esto le dice a Arduino que abra un canal con la computadora para la comunicación en serie. El número al lado muestra qué tan rápido debe enviar datos.

El 9600se refiere a 9600 baudios. Esto significa que va a enviar 9600 bits por segundo. Las tasas de baudios varían de 300 a más de 2 millones de baudios para el IDE de Arduino. Las tarifas más pequeñas son mejores para cables más largos (piense en cables telefónicos para la distancia), mientras que las más grandes son para cables más cortos. Sin embargo, 2 millones de baudios es excesivo. En muchos casos, incluso 19200 baudios son más que suficientes incluso para los sensores aficionados más sensibles.

Con eso fuera del camino, hablemos de lo Serial.println();siguiente. Este comando significa «imprimir, línea nueva» y crea una nueva línea después de imprimir lo que hay dentro del ()área.

Serial.println()acepta cadenas o variables que contienen cadenas. Se comporta de manera extraña cuando agrega números en ellos, especialmente si comienza con 0.

Serial.println(000);imprime un solo cero en lugar de tres ceros.

Si observa los resultados de su monitor en serie, también debe notar que imprime «¡Arduino, iniciando!» sólo una vez. Mientras tanto, «LED encendido» y «LED apagado» se imprimen repetidamente en cada ciclo de parpadeo. Esa es la gran diferencia entre setup()y loop().

De hecho, incluso puede poner su código de setup()en loop(), pero eso suele ser una mala práctica. Puede terminar convirtiendo un pin de entrada en un pin de salida, lo que podría romper el chip del microcontrolador.

Ejemplo 4: parpadeo con For-Loops

Esto ayuda mucho. Un bucle for te permite hacer un mini loop()que termina después de un número determinado de veces.

Intentemos hacer patrones de parpadeo complejos con múltiples bucles for. En la primera carga, el LED debe parpadear 13 veces, encendido durante 500 ms y apagado durante 250 ms, y solo una vez. Luego debe repetirse, parpadear cuatro veces, encenderse durante 1000 ms y apagarse durante 1000 ms, luego parpadear dos veces más, encenderse durante 500 ms y apagarse durante 250 ms.

1. En setup(), elimine el bloque de código que se convierte LED_BUILTINen HIGHo LOW. Además, elimine las delay()funciones.

2. Reemplace ese código con lo siguiente:

para (int i = 0; i < 12; i++) {
  digitalWrite(LED_BUILTIN, ALTO);
  retraso (500);
  digitalWrite(LED_BUILTIN, BAJO);
  retraso (250);
}

3. En loop(), elimine todo y reemplácelo con el siguiente código que enciende el LED durante 1000 ms y lo apaga durante 1000 ms, cada uno cuatro veces:

para (int i = 0; i < 4; i++) {
  digitalWrite(LED_BUILTIN, ALTO);
  retraso (1000);
  Serial.println("LED encendido por 1 segundo");
  digitalWrite(LED_BUILTIN, BAJO);
  retraso (1000);
  Serial.println("LED apagado por 1 segundo");
}

4. Cree una nueva línea y agregue el siguiente código que enciende el LED durante 500 ms y lo apaga durante 250 ms, cada uno dos veces:

para (int i = 0; i < 2; i++) {
  digitalWrite(LED_BUILTIN, ALTO);
  retraso (500);
  Serial.println("LED encendido durante 0,5 segundos");
  digitalWrite(LED_BUILTIN, BAJO);
  retraso (250);
  Serial.println("LED apagado durante 0,25 segundos");
}

5. Cargue su código, luego abra el monitor serial. Debería comenzar a contar hasta 13 parpadeos del LED antes de hacer los dos mini bucles diferentes.

Los números muestran cuántas veces ha parpadeado el LED.

El bucle for es una herramienta simple pero fácil de aprender. Tiene tres partes: for, (int i = 0; i < x; i++)y lo que sea que esté dentro del { }.

• forle dice al IDE de Arduino que es una función de bucle for. Hay muchos otros, como while, ify switch.
• (int i = 0; i < x; i++)es una condición Dice que mientras el número entero i, que es 0, está por debajo del valor de x, entonces haga i++y ejecute la función. i++es la abreviatura de i + 1. Incluso puede reemplazarlo con i + x«x» es cualquier número o hacer que cuente hacia atrás usando el operador «-«.
• contiene todo lo { }que hará el bucle. No necesita un ;al final. Simplemente déjalo como está.

Conclusión

Con esta sencilla guía para principiantes de Arduino, puede comenzar a crear sus propios efectos de luz personalizados o tal vez una elegante luz navideña.

Hay más que aprender, por supuesto, pero es mejor aprender sobre la marcha. ¡Podría probar motores, sensores, relés y mucho más! Si está preparado para el desafío, es posible que desee programar un Arduino con una Raspberry Pi.