Lo Último en IP@P
- UGREEN Nexode Pro: El Cargador Ultradelgado que revoluciona la carga de dispositivos móviles
- La computación en la nube está transformando los juegos Online y estas son sus grandes ventajas
- Actualizaciones del Programa de Afiliados de TEMU: ¡Hasta MX$500,000 al mes!
- ¿Aún es rentable invertir en oro en comparación con la inversión en criptomonedas?
- ¡Netflix sigue siendo el rey! Estas son las plataformas de streaming con más usuarios en el mundo
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
Más en Informática
- Mi ordenador va muy lento ¿Cómo recuperar la velocidad de tu viejo PC o portátil? Guía paso a paso
- Flops ¿Qué son las operaciones de coma flotante por segundo?
- Aplicaciones ofimáticas: ¿Qué son, para qué sirven y qué tipos hay?
- Variables en Arduino ¿Qué son, para qué sirven y cuáles son las más importantes?
- ¿Cuáles son los mejores proyectos Arduino con estructuras de control para aprender a programar? Lista 2024
SÍGUENOS EN 👉 YOUTUBE TV
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); }