Arduino Leonardo: ¿Qué es, para qué sirve y cuáles son las características especiales de estas placas de hardware libre?

Las características especiales que tiene Arduino Leonardo las podrás encontrar en los siguientes párrafos de este artículo. Te explicaremos, de una manera sencilla, para qué sirve esta placa de hardware libre.

Además, vas a poder conocer los principales beneficios que tiene Arduino Leonardo y cuáles son los componentes que usa. Siendo uno de los más importantes, la distribución de sus pines en el bus.

Pero esto no es todo lo que encontrarás en el post, también te presentaremos los proyectos más interesantes que puedes crear tú mismo con Arduino Leonardo. Continúa leyendo y conviértete en un verdadero experto en electrónica.

¿Qué es Arduino Leonardo y para qué sirve esta placa de desarrollo libre?

Arduino Leonardo es una placa con un MCU ATmega32u4, memoria flash de 32KB y una estática de 2,5 KB. Tiene un puerto USB por hardware por lo que no es necesario la conversión serie-USB, esto permite que se pueda trabajar en una gran cantidad de proyectos y utilizar periféricos (como un teclado o un ratón) para mejorar la comodidad del usuario.

Se diferencia con Arduino UNO por tener 20 pines digitales, de los cuales puede distribuir 12 para entradas analógicas y 7 para la modulación de pulso, los cuales pueden soportar una corriente máxima de entrada y salida de 40 mA. Esta placa ofrece una gran versatilidad gracias a la anatomía que ofrece Arduino.

¿Cuáles son las características más interesantes de las placas de desarrollo Arduino Leonardo?

Las características principales que tiene Arduino Leonardo son:

• En relación con otras placas la Arduino Leonardo dispone de más pines. Esto permite incluir más elementos al mismo tiempo, por lo que no es necesario agregar más circuitos a proyectos complejos.
• La memoria estática SRAM tiene más capacidad que la de Arduino UNO (la placa más usada), ya que la misma es de 2,5 KB lo cual beneficia en aquellos proyectos en donde se necesite rapidez en el procesamiento.
• Las dimensiones son similares a las de otras placas, por lo que se la puede incluir en cualquier tipo proyecto. Esto también trae como beneficio que su coste no sea elevado.
• Al disponer de puertos nativos, se puede conectar de manera directa periféricos que ayudan a mejorar el manejo y la programación de la placa.
• En la página oficial de Arduino existen librerías que se pueden acceder y emplear de manera fácil en la programación de proyectos.

Anatomía de la Arduino Leonardo ¿Cuáles son los componentes que utiliza?

Los componentes que se utilizan en una placa Arduino Leonardo son:

• Sus dimensiones totales son 68,6 × 53,3mm con un peso aproximado de 20 gramos.
• El MCU es un microcontrolador modelo Atmel ATmega32u4 que trabaja a 16 Mhz.
• La memoria Flash, restando los 4 KB del bootloader, es de 28 KB.
• La EEPROM es de 1KB, mientras que la memoria SRAM es de 2,5 KB.
• Posee los pines A0 al A11 como entradas analógicas, mientras que para PWM se usa los pines 3, 5, 6, 9, 10, 11 y 13.
• Cuenta con un bus I2C en el que ubica a la línea de datos y a la línea del reloj en los pines 2 y 3, respectivamente.
• Dispone de un conector macho de 6 pines usado para la comunicación ICSP, esto es una diferencia importante con respecto a otras placas, ya que las demás disponen de diferentes pines para la comunicación SPI.
• Los pines 3, 2, 0, 1, y 7 se usa para la interrupción externa de tipo 0, mientras que para la interrupción 1 dispone de los pines 0, 1, 2, 3, y 4.
• El puerto para la conexión por USB es de tipo A-micro B.

Lista de los proyectos más interesantes que puedes crear tú mismo con Arduino Leonardo

En los pasos que siguen podrás encontrar los mejores proyectos que puedes crear tú mismo con una placa de Arduino Leonardo:

Extensión de teclado

Podrás utilizar una placa de Arduino Leonardo en un proyecto que te permita agregar teclas táctiles capacitivas y luego personalizarlas. Para esto necesitarás, además de la placa Arduino Leonardo, cantidad necesaria de sensores táctiles capacitivos, una protoboard cables para la conexión. Lo primero que deberás hacer es montar insertando los cables en los conectores y luego crea las teclas de acceso rápido.

Para esto tendrás que ingresar:

#include <Keyboard.h>

const int delayValue = 100;

const char cmdKey = KEY_LEFT_GUI;

void setup(){

pinMode(2, INPUT);

pinMode(3, INPUT);

pinMode(4, INPUT);

pinMode(5, INPUT);

begin();

}

void loop(){

if (digitalRead(2)) {

press(cmdKey);

press('c');

delay(delayValue);

releaseAll();

while(digitalRead(2));

}

if (digitalRead(3)) {

press(cmdKey);

press('v');

delay(delayValue);

releaseAll();

while(digitalRead(3));

}

if (digitalRead(4)) {

press(cmdKey);

press('n');

delay(delayValue);

releaseAll();

while(digitalRead(4));

}

if (digitalRead(5)) {

press(cmdKey);

press('z');

delay(delayValue);

releaseAll();

while(digitalRead(5));

}

}

Luego deberás ingresar los códigos siguientes para terminar de programar:

#include <Keyboard.h>

configuración vacía () {

pinMode ( 2 , ENTRADA );

pinMode ( 3 , ENTRADA );

pinMode ( 4 , ENTRADA );

pinMode ( 5 , ENTRADA );

Teclado . comenzar ();

}

bucle vacío () {

checkPress ( 2 , 'd' );

checkPress ( 3 , 'f' );

checkPress ( 4 , 'g' );

checkPress ( 5 , 'h' );

}

void checkPress ( int  pin ,  char  key )  {

if ( digitalRead ( pin ))  {

Teclado . presione ( tecla );

}

else {

Teclado . liberación ( tecla );

}

}

Programa tu máquina CNC

Necesitarás una placa Arduino Leonardo y pulsadores para convertir a tu máquina CNC con un colgante de madera. Este proyecto te ayudará a mover el volante y dejar quieto el resto del equipo cuando trabajes. Podrás incorporar diferentes interruptores, modificar el tamaño del comando y elegir un volante que se adapte a tus necesidades.

Luego de ensamblar las piezas tendrás que programar en el IDE de Arduino los siguientes códigos:

#include "ClickButton.h"

#include "Keyboard.h"

long int aux1_delay =  0 ;

botones int const =  20 ;

const int buttonPin0 =  0 ;

const int buttonPin1 =  0 ;

const int buttonPin2 =  1 ;

const int buttonPin3 =  2 ;

const int buttonPin4 =  3 ;

const int buttonPin5 =  4 ;

const int buttonPin6 =  5 ;

const int buttonPin7 =  6 ;

const int buttonPin8 =  7 ;

const int buttonPin9 =  8 ;

const int buttonPin10 =  9 ;

const int buttonPin11 =  10 ;

const int buttonPin12 =  11 ;

const int buttonPin13 = 12;

const int buttonPin14 = 13;

const int buttonPin15 = A0;

const int buttonPin16 = A1;

const int buttonPin17 = A2;

const int buttonPin18 = A3;

const int buttonPin19 = A4;

const int buttonPin20 = A5;

{

ClickButton (buttonPin0, LOW, CLICKBTN_PULLUP),

ClickButton (buttonPin1, LOW, CLICKBTN_PULLUP),

• Continúa de la misma manera hasta buttonPin20, luego cierra IDE con };

Después tendrás que seguir ingresando estos códigos:

void setup()

{

for (int i = 1; i <= buttons; i++)

{

button[i].debounceTime = 20;

button[i].multiclickTime = 250;

button[i].longClickTime = 1000;

}

}

void loop()

{

for (int i = 1; i <= buttons; i++)

{

button[i].Update();

}

if (button[1].clicks != 0)

{

switch (button[1].clicks)

{

case 1: // Single click

press_RESET();

break;

case 2: // Double click

press_ESC();

break;

case 3: // Triple click

break;

case -1: // Single Click and Hold

// TURN DRIVERS OFF

press_ESC();

goto_MACHINE_IO_MENU();

press_F2();

goto_MAIN_MENU();

break;

case -2: // Double Click and Hold

break;

case -3: // Triple Click and Hold

break;

}

}

if (button[2].clicks != 0)

{

switch (button[2].clicks)

{

case 1: // Single click

press_ESC();

goto_MAIN_MENU();

break;

case 2: // Double click

break;

case 3: // Triple click

break;

case -1: // Single Click and Hold

break;

case -2: // Double Click and Hold

break;

case -3: // Triple Click and Hold

break;

}

}

if (button[3].clicks != 0)

{

switch (button[3].clicks)

{

case 1: // Single click

break;

case 2: // Double click

break;

case 3: // Triple click

break;

case -1: // Single Click and Hold

press_ESC();

goto_MAIN_MENU();

shortcut_HOME_ALL();

break;

case -2: // Double Click and Hold

break;

case -3: // Triple Click and Hold

break;

}

}

if (button[4].clicks != 0)

{

switch (button[4].clicks)

{

case 1: // Single click

// TOGGLE MDI

shortcut_TOGGLE_MDI();

break;

case 2: // Double click

break;

case 3: // Triple click

break;

case -1: // Single Click and Hold

break;

case -2: // Double Click and Hold

break;

case -3: // Triple Click and Hold

break;

}

}

Desde aquí puedes agregar para cada botón qué acciones quieres que hagas. Puedes romper, iniciar el temporizador, esperar, etc. Para las teclas modificadoras tendrás que usar estas definiciones establecidas por Arduino Leonardo. Vamos a expresar primero la clave, luego el valor hexadecimal y por último su valor decimal.

Mira a continuación:

KEY_LEFT_CTRL 0x80 128

KEY_LEFT_SHIFT 0x81 129

KEY_LEFT_ALT 0x82 130

KEY_LEFT_GUI 0x83 131

KEY_RIGHT_CTRL 0x84 132

KEY_RIGHT_SHIFT 0x85 133

KEY_RIGHT_ALT 0x86 134

KEY_RIGHT_GUI 0x87 135

KEY_UP_ARROW 0xDA 218

KEY_DOWN_ARROW 0xD9 217

KEY_LEFT_ARROW 0xD8 216

KEY_RIGHT_ARROW 0xD7 215

KEY_BACKSPACE 0xB2 178

KEY_TAB 0xB3 179

KEY_RETURN 0xB0  176

KEY_ESC 0xB1  177

KEY_INSERT 0xD1  209

KEY_DELETE 0xD4  212

KEY_PAGE_UP 0xD3  211

KEY_PAGE_DOWN 0xD6  214

KEY_HOME 0xD2  210

KEY_END 0xD5  213

KEY_CAPS_LOCK 0xC1  193

KEY_F1 0xC2  194

KEY_F2 0xC3  195

KEY_F3 0xC4  196

KEY_F4 0xC5  197

KEY_F5 0xC6  198

KEY_F6 0xC7  199

KEY_F7 0xC8  200

KEY_F8 0xC9  201

KEY_F9 0xCA  202

KEY_F10 0xCB  203

KEY_F11 0xCC  204

KEY_F12 0xCD  205

Un ejemplo de la programación de estas teclas es:

void press_RESET()

{

begin();

press(KEY_F1);

delay(100);

releaseAll();

}

void press_ESC()

{

begin();

press(KEY_ESC);

delay(100);

releaseAll();

}

void press_F2()

{

begin();

press(KEY_F2);

delay(100);

releaseAll();

}

void press_F3()

{

begin();

press(KEY_F3);

delay(100);

releaseAll();

}

Sensor de movimiento

Con este proyecto vas a poder crear un radar que encienda una luz led cuando detecta movimiento en una zona cercana. Para esto necesitarás una placa de Arduino Leonardo, un sensor ultrasónico, un motor paso a paso, luces LED y cables para ensamblar. El siguiente paso será montar los componentes y escribir los siguientes comandos para la luz led y el sensor ultrasónico.

Estos son:

{larga duración; pinMode (trigPin, SALIDA);

pinMode (echoPin, INPUT);

digitalWrite (trigPin, BAJO);

delayMicroseconds (2);

digitalWrite (trigPin, HIGH);

delayMicroseconds (20);

digitalWrite (trigPin, BAJO);

duración = pulseIn (echoPin, HIGH);

duración = duración / 59;

if ((duración <2) || (duración> 300)) devuelve falso;

duración del regreso; }

configuración vacía ()

{Serial.begin (9600);

digitalWrite (6, BAJO);

pinMode (5, SALIDA); }

bucle vacío ()

{Serial.print ("distancia:");

print ("");

print (ardublockUltrasonicSensorCodeAutoGeneratedReturnCM (6, 7));

print ("");

println ();

si ((((ardublockUltrasonicSensorCodeAutoGeneratedReturnCM (6, 7))

<(30.0)) && ((ardublockUltrasonicSensorCodeAutoGeneratedReturnCM (6, 7))> (0.0)))) {digitalWrite (5, HIGH); }

{

digitalWrite (5, BAJO); }}

A continuación, deberás incorporar los códigos para el funcionamiento del motor:

void __StepMotor (int MotorStep, int MotorSpeed, int pinNumberA, int pinNumberB, int pinNumberC, int pinNumberD)

{

pinMode (pinNumberA, SALIDA);

pinMode (pinNumberB, SALIDA);

pinMode (pinNumberC, SALIDA);

pinMode (pinNumberD, SALIDA);

para (int i = 0; i

digitalWrite (pinNumberA, HIGH);

digitalWrite (pinNumberB, LOW);

digitalWrite (pinNumberC, LOW);

digitalWrite (pinNumberD, LOW);

retraso (MotorSpeed);

digitalWrite (pinNumberA, LOW);

digitalWrite (pinNumberB, HIGH);

retraso (MotorSpeed);

digitalWrite (pinNumberB, LOW);

digitalWrite (pinNumberC, HIGH);

retraso (MotorSpeed);

digitalWrite (pinNumberC, LOW);

digitalWrite (pinNumberD, HIGH);

retraso (MotorSpeed);

}

digitalWrite (pinNumberD, LOW); }

configuración vacía ()

{

}

bucle vacío ()

{__StepMotor (1024.0, 10.0, 8, 9, 10, 11);

retraso (1000,0);

__StepMotor (1024.0, 10.0, 11, 10, 9, 8);

}