Placa de Arduino: ¿Qué es, para qué sirve y qué dispositivos se pueden desarrollar con ellas?

Una placa de Arduino es un bus electrónico que permite desarrollar una gran variedad de dispositivos. Debido a esto es importante conocer para qué sirven estos componentes de hardware y cuáles son sus funciones principales.

Esta información la vas a encontrar en los párrafos siguientes, en los que también te enseñaremos la anatomía que tiene la placa y qué elementos la componen. Además, conocerás todas las versiones de Arduino en una lista completa.

Pero esto no es todo, si continúas leyendo, te mostraremos los mejores proyectos de Arduino que puedes hacer tú mismo y desde cero. No te pierdas de ningún detalle.

¿Qué es una placa Arduino y para qué sirven estos componentes de hardware?

Las placas Arduino son dispositivos electrónicos y que se utilizan en la creación de proyectos de automatización, robótica, obtención de datos y tecnología, entre otras áreas. Son buses muy versátiles que presentan una gran variedad de modelos, los cuales se adaptan a cada necesidad que tiene el usuario.

Son construidas por las compañías Smart Projects, SparkFun Electronics (SFE) y Gravitech, pero eso no implica que no puedas encontrar placas personalizadas realizadas por los propios usuarios. Debes tener presente que estas últimas no disponen de la misma calidad y no cuentan con todo el soporte técnico que tienen las Arduino.

El entorno de programación se llama IDE y es compatible con Linux, MacOS y Windows, entre otros. En cuanto al hardware cualquier placa está compuesta por pines, puertos USB, conectores, microprocesador, memorias y otros elementos más. Dentro de las versiones más destacadas que tiene Arduino se encuentran la UNO, Leonardo, Yún, ZERO y DUE, por lo que antes de elegir algún modelo deberás conocer a la perfección todas las características y prestaciones que ofrecen cada una.

Anatomía de una placa Arduino ¿Cuáles son todos los elementos que la componen?

Tomaremos como ejemplo Arduino UNO para mostrarte los elementos que componen una placa.

Estos son:

• GND o toma a tierra. Se usa estos conectores para vincular el circuito con la tierra.
• Pines digitales, los cuales se utilizan para recibir voltaje por medio de señales. Están serigrafiados del 0 al 13, placas diferentes a la UNO esto puede cambiar por otros canales.
• Salida TX y Entrada RX. Son pines que se utilizan de manera digital.
• Botón Reset, usado para reiniciar el proceso electrónico de la placa.
• Programador serial en circuito también conocido como ICSP. Se utiliza este conector para instalar programas de manera externa.
• Microcontrolador o MCU, es el encargado de realizar las operaciones solicitadas a gran velocidad.
• Pines analógicos. En el modelo Arduino UNO se puede encontrar a estos conectores en los canales A0 a A5, cuentan con una resolución de 10 bits y un voltaje de tensión de 0 a 5.
• El pin VIN cumple con una doble tarea porque sirve para la alimentación externa de hasta 12V y para la toma tierra.
• Pines 3 y 5V. Son los encargados de entregar una salida al tipo de voltaje que lleva su nombre y cuentan con una capacidad máxima de corriente de 60mA.
• Pin RESET se conecta con el botón RESET y cumple con una función de reiniciar el microcontrolador.
• Conector USB, el cual se usa para conectar la placa al ordenador y para incorporar un software programado en la IDE de Arduino.
• Alimentación Jack, se utiliza este conector para alimentar la placa entre 7 y 12V.

¿Qué tipo de dispositivos se pueden crear y programar a partir de un Arduino?

Existe una gran cantidad de dispositivos que se pueden crear y programar a partir de un Arduino. El límite es muy grande y dependerá de tu capacidad de creación para obtener nuevos resultados.

Entre los proyectos que más se destacan se puede encontrar: 

• Semáforos, estaciones meteorológicas, robots, sensores de purificación del aire, carteles iluminados por medio de WiFi, luces que se encienden de manera remota, sensores de movimiento, Internet de las Cosas y expendedores de golosinas.
• Automatización industrial, riego por goteo en grandes campos, riego por aspersión, control de dietas de animales y control de heladas y granizo en plantaciones.

¿Cuáles son todos los tipos de placas Arduino que existen y cuál es la mejor?

Puedes encontrar una gran variedad de modelos de placa de Arduino, siendo la más usada la versión UNO. Esto se debe a la cantidad de pines analógicos y digitales que ofrece y a la capacidad de rendimiento que ofrece el MCU y la memoria.

Pero estos no son los únicos modelos que puedes encontrar en el mercado, también se fabrican:

• BT: se puede encontrar en esta placa de Arduino un microcontrolador ATmega168 y un módulo compatible con una conexión por Bluetooth.
• Due: el MCU Atmel SAM3X8E ARM Cortex-M3 de 32 bits es uno de los más potentes dentro de las placas de Arduino. La gran versatilidad que ofrece está basada en la capacidad de ejecutar operaciones dentro de un ciclo del reloj.
• Esplora: la característica más destacada de esta versión es su forma y la inclusión de sensores de temperatura, luz y acelerómetro. Además, posee un socket que puede ser conectado a una pantalla grande.
• Ethernet: esta versión es similar a la UNO, pero incluye su capacidad para conectarse a la web por medio de puerto Ethernet.
• Fio: el MCU ATmega328P permite trabajar de manera similar a la versión Ethernet pero con una frecuencia de 8 MHz.
• Genuino 101: esta placa italiana posee un módulo Intel, 80KB de SRAM y cuenta con Bluetooth y giroscopio.
• Leonardo: la principal que tiene esta placa de arduino es un microcontrolador ATmega32u4, el cual trabaja con una memoria flash de 32KB. La característica más importante que tiene esta versión es la capacidad de manejar 20 pines digitales y 12 pines analógicos.
• LilyPad: esta versión circular de Arduino cuenta con un microcontrolador ATmega328V y dispone de 1KB de SRAM.
• Mega: esta versión cuenta con MCU ATmega2560, el cual trabaja a 16Mhz. Dispone una memoria SRAM de 8KB y de hasta 4KB para la EEPROM, pero esto no es todo también se incluye 54 pines digitales y 16 pines analógicos. Lo cual permite trabajar con gran comodidad en proyectos grandes.
• Micro: al igual que el modelo siguiente, se caracteriza por sus reducidas dimensiones. Cuenta con un MCU ATmega32u4 de 16Mhz, por lo que tampoco es una de las versiones más potentes.
• Nano: la capacidad que tiene esta versión de Arduino es similar a otras, pero se caracteriza por sus dimensiones. Mide solo 18,5 x 43,2 mm, por lo que se puede incluir en proyectos bastante pequeños.
• Primo: la capacidad que tiene la placa para conectarse a la web y realizar proyectos de Internet de las Cosas es una de las características más destacadas que ofrece. Es compatible con una conexión por Bluetooth y WiFi.
• Pro y Pro Mini: son dos versiones que se diferencian por su tamaño y se caracterizan por tener un bajo coste de adquisición debido a las bajas prestaciones que ofrecen.
• Star Otto: dispone de un procesador de gráficos ideal para proyectos gráficos. Su MCU es un SMT32F469BIT6 y una memoria SRAM de 384Kb.
• TRE: es la primera placa que se fabricó en Estados Unidos y posee microcontrolador Atmel ATMega32u4 de 16Mhz. La memoria flash es de 32KB y tiene una memoria SRAM de 2,5KB.
• Yún: en esta placa de Arduino encontrarás un MCU ATmega32u4, siendo lo más destacado el procesador qué puede ser trabajado por medio de la distribución de Linux OpenWrt-Yun. Además, es compatible con una conexión a WiFi y red LAN.
• Zero: es una de las más potentes que puedes encontrar en el mercado, ya que ofrece un reloj de 48MHz, un microcontrolador de Atmel SAMD21 MCU y una memoria SRAM de 32 KB. Se caracteriza por trabajar con una tensión de 3,3V.

Ejemplo de proyectos con Arduino que puedes hacer tú mismo desde cero

Te mostraremos a continuación proyectos que puedes hacer tú mismo desde cero con una placa de Arduino.

Comencemos:

Sensor de estacionamiento

Con una placa Arduino podrás crear un dispositivo que logre detectar la cercanía de un elemento y emitir una alarma cuando te acerques más. Es ideal para colocarlo en tu coche y disponer de una herramienta de última tecnología. Necesitarás una placa Arduino UNO, un sensor de cabezal de cobre con punto láser, receptor del sensor, un led genérico y cables para la conexión. El diagrama de conexión del circuito lo deberás hacer de acuerdo con la figura que te mostramos.

Una vez que termines de montar todos los componentes, tendrás que copiar el siguiente código.

Lo primero que deberás hacer es asociar todas las variables que has definido en cualquier biblioteca:

#include <LowPower.h>

#define DETECTH 2

#define DETECTHP 12

#define ACTIONH 8

#define DETECTL 9

#define DETECTLP 13

#define ACTIONL 10

int detectadoH2 = digitalRead ( DETECTH ) ;

#define LED 7

configuración vacía () {

begin ( 9600 ) ;

print ( "Prueba" ) ;

println () ;

pinMode ( DETECCIÓN, ENTRADA ) ;

pinMode ( ACCIÓNH, SALIDA ) ; /

pinMode ( DETECTAR, ENTRADA ) ;

pinMode ( ACTIONL, OUTPUT ) ;

pinMode ( DETECTHP, SALIDA ) ;

pinMode ( DETECTLP, SALIDA ) ;

}

Lo que se debe hacer ahora es informarle a la placa que apague cualquier componente cuando el modo de consumo es bajo:

bucle vacío () {

idle ( SLEEP_8S, ADC_OFF, TIMER2_OFF, TIMER1_OFF, TIMER0_OFF, SPI_OFF, USART0_OFF, TWI_OFF ) ;

print ("PASO 1");

println ();

for (int h; h <30; h ++) {

print ("no hacer nada");

println ();

}

int detectadoL2 = digitalRead (DETECTL);

digitalWrite (ACTIONL, HIGH);

escritura digital ( DETECTLP, ALTA ) ;

if ( detectadoL2  == HIGH ) {

print ( "El sensor inferior está viendo láser" ) ;

if

println () ;

escritura digital ( DETECTHP, BAJA ) ;

escritura digital ( ACCIÓN H, BAJA ) ;

digitalWrite ( LED, BAJO ) ;

}

Ahora se debe programar que los pines den energía al sensor cuando realizan diferentes acciones:

else {

if

escritura digital ( ACCIÓN H, ALTA ) ;

escritura digital ( DETECTHP, ALTA ) ;

print ( "EL LÁSER no puede ser visto por el sensor inferior" ) ;

else

println () ;

para ( int i =  0 , j  =  1 ; i < 20000 ; i ++ )

{

int detectadoH2 = digitalRead ( DETECTH ) ;

for

int detectadoL2 = digitalRead ( DETECTL ) ;

print ( "para bucle" ) ;

println () ;

if ( updatedH2 == HIGH )

{

digitalWrite ( ACTIONL, LOW ) ;

escritura digital ( DETECTLP, BAJA ) ;

j ++ ;

print ( "j ++" ) ;

}

else

else

{

escritura digital ( ACCIÓN H, BAJA ) ;

escritura digital ( DETECTHP, BAJA ) ;

escritura digital ( LED, ALTA ) ;

print ( "SIN LÁSER" ) ;

else

println () ;

retraso ( 20000 ) ;

digitalWrite ( LED, BAJO ) ; /

romper ;

}

}

}

print ( "Fin" ) ;

println () ;

}

Medidor de nivel de agua

Necesitarás para este proyecto una placa arduino NANO R3, un sensor ultrasónico, un módulo HC-12, leds de color rojo, verde y amarillo de 5 mm, un zumbador, resistencias, un botón ON/OFF y una pantalla LCD. La conexión la deberás realizar mediante el siguiente esquema.

Luego deberás copiar el código que te dejamos a continuación:

# incluye <SoftwareSerial.h>

SoftwareSerial HC12 ( 4 ,  5 );

Establece los valores que deseas tener para que el dispositivo se accione:

int MinLevel  =  24 ;

int MaxLevel  =  102 ;

int potencia  =  6 ;

long dist_1  =  0 ;

long dist_2  =  0 ;

int Time  =  0 ;

int trig  =  3 ;

int echo  =  2 ;

configuración vacía () {

//Serial.begin(9600);

HC12 . comenzar ( 9600 );

pinMode ( trig , SALIDA );

digitalWrite ( trig , LOW );

pinMode ( eco , ENTRADA );

pinMode ( potencia , SALIDA );

digitalWrite ( potencia , 1 );

}

bucle vacío () {

Time ++ ;

digitalWrite ( trig , LOW );

delayMicroseconds ( 5 );

digitalWrite ( trig , HIGH );

delayMicroseconds ( 10 );

digitalWrite ( trig , LOW );

dist_1 =  (  pulseIn ( eco ,  ALTO )) * 0.034 / 2 ;

if ( dist_1  <  MaxLevel + 100 ) {

Enviar_datos ( dist_1 );}

//Serial.print(dist_1);

//Serial.print('\n ');

retraso ( 500 );

}

void Send_data ( int  dist_1 ) {

int enviado  =  mapa  ( dist_1 ,  MinLevel ,  MaxLevel ,  100 ,  0 );

if ( Tiempo  ==  100 )  {

HC12 . escribir ( enviado );

Tiempo =  0 ;

}

Para enviar información cuando varía el nivel del tanque tendrás que ingresar:

if ( dist_1  ! =  dist_2 )  {

HC12 . escribir ( enviado );

dist_2 =  dist_1 ;

}

Calibra el sensor:

print ("sensor leído-");

print (dist_1);

print ("valor enviado -");

print (enviado);

print ('\ n');

}

Aro de luz hexadecimal

Si eres de las personas que les gusta grabar vídeo con la cámara frontal del móvil podrás crear tu propio aro de luz con Arduino y agregarle funciones que pueden ser personalizadas de una manera sencilla. Los materiales que necesitarás son: una Arduino NANO, microchip ATtiny85, leds y PCB.

Tendrás que unirlos elementos mediante el diagrama que te dejamos en la imagen y a continuación copiar y pegar el código:

#include <Adafruit_NeoPixel.h>

#define PIXEL_PIN 0

#define PIXEL_COUNT 36

Adafruit_NeoPixel tira  =  Adafruit_NeoPixel ( PIXEL_COUNT ,  PIXEL_PIN ,  NEO_GRB  +  NEO_KHZ800 );

configuración vacía () {

tira . comenzar ();

tira . mostrar ();

}

bucle vacío () {

arco iris ( 20 );

}

arco iris vacío ( uint8_t espera )  {

uint16_t i ,  j ;

para ( j = 0 ; j < 256 ;  j ++ )  {

para ( i = 0 ; i < strip . numPixels ();  i ++ )  {

tira . setPixelColor ( i , Wheel (( i + j )  y  255 ));

}

tira . mostrar ();

retraso ( espera );

}

}

uint32_t Wheel ( byte  WheelPos )  {

WheelPos =  255  -  WheelPos ;

si ( WheelPos <  85 )  {

tira de retorno . Color ( 255 -  WheelPos  *  3 ,  0 ,  WheelPos  *  3 );

}

si ( WheelPos <  170 )  {

WheelPos - =  85 ;

tira de retorno . Color ( 0 , WheelPos  *  3 ,  255  -  WheelPos  *  3 );

}

WheelPos - =  170 ;

tira de retorno . Color ( WheelPos *  3 ,  255  -  WheelPos  *  3 ,  0 );

}

Sensor de fugas de gas

En este proyecto necesitarás una placa del modelo UNO, un sensor de detección de gas y de hidrógeno, cables y un motor de corriente continua de 12 voltios. Este proyecto te ayudará a mantener la seguridad de tu hogar y de cualquier ambiente, ya que cuenta con un sistema de detección de fuga de gas, el cual alerta sobre posibles amenazas.

Para esto tendrás que montar lentes de acuerdo al diagrama que te dejamos en la imagen.

Luego deberás ingresar este código en el IDE de Arduino:

#include <LiquidCrystal.h>

LiquidCrystal lcd ( 8 ,  9 ,  10 ,  11 ,  12 ,  13 );

int Gas_Sensor_Value  =  0 ;

int Sensor_gás  =  A0 ;

int Piezo  =  3 ;

int motor_eléctrico_1  =  4  ;

int motor_eléctrico_2  =  5  ;

int motor_eléctrico_3  =  6  ;

int motor_eléctrico_4  =  7  ;

configuración vacía ()

{

lcd . comenzar ( 16 , 2 );

pinMode ( sensor de gas , ENTRADA );

pinMode ( Piezo , SALIDA );

pinMode ( electric_motor_1 , OUTPUT );

pinMode ( electric_motor_2 , OUTPUT );

pinMode ( electric_motor_3 , OUTPUT );

pinMode ( electric_motor_4 , OUTPUT );

}

bucle vacío ()

{

lcd . claro ();

Gas_Sensor_Value =  analogRead ( A0 );

si ( Gas_Sensor_Value  > =  700 )

{

digitalWrite ( Piezo , ALTO );

digitalWrite ( electric_motor_1 , ALTO );

digitalWrite ( electric_motor_2 , ALTO );

digitalWrite ( electric_motor_3 , ALTO );

digitalWrite ( electric_motor_4 , ALTO );

lcd . print ( "Precaución: fuga de gas" );

retraso ( 1000 );

}

más

{

digitalWrite ( Piezo , BAJO );

digitalWrite ( electric_motor_1 , LOW );

digitalWrite ( electric_motor_2 , LOW );

digitalWrite ( electric_motor_3 , LOW );

digitalWrite ( electric_motor_4 , LOW );

lcd . print ( "El medio ambiente" ); // Imprime un mensaje en la pantalla LCD.

lcd . setCursor ( 0 , 1 );

lcd . print ( "es seguro" );

retraso ( 1000 );

}

}

Sensor de temperatura

Este proyecto te permitirá obtener información de la temperatura que hay en un ambiente y en los líquidos. Vas a necesitar una placa de Arduino UNO, un protoboard, un sensor de temperatura, una resistencia de 4,75 k ohmios y cables para la conexión.

Deberás montar todos los componentes tal como te mostramos en la figura.

A continuación, tendrás que ingresar en el IDE de arduino el siguiente código: 

#include <OneWire.h>

#include <DallasTemperature.h>

#define ONE_WIRE_BUS 2

OneWire oneWire(ONE_WIRE_BUS);

DallasTemperature sensors(&oneWire);

void setup(void)

{

begin(9600);

println("Dallas Temperature IC Control Library Demo");

begin();

}

void loop(void)

{

print(" Requesting temperatures...");

requestTemperatures(); // Send the command to get temperature readings

println("DONE");

print("Temperature is: ");

print(sensors.getTempCByIndex(0));

delay(1000);

}