Arduino es una
plataforma abierta que facilita la programación de un microcontrolador (por ejemplo el ATmega32u4), es una plataforma de prototipo electrónico de código abierto
(open – source) basada en hardware y software libre y fáciles de utilizar para
los creadores y desarrolladores.
El hardware de
Arduino consiste en una placa con un microcontrolador generalmente Atmel AVR con
puertos de comunicación y puertos de entrada/salida (I/O).
Por otro lado Arduino
nos proporciona un software consistente en un entorno de desarrollo (IDE) que
implementa el lenguaje de programación de Arduino, las herramientas para
transferir el firmware al microcontrolador y el bootloader ejecutado en la
placa. La principal característica del software y del lenguaje de programación
es su sencillez y facilidad de uso.
Arduino cuenta con la
ventaja de tener entre sus elementos pines de entrada/salida (I/O), lo que le
permite conectarse por medio de un cable USB a una computadora para
poder trabajar con ella desde nivel software, ya que es dónde se le darán las
“ordenes” que ejecutarán cada uno de los componentes conectados a la placa,
además, Arduino para operar necesita de una fuente de alimentación externa, lo
podemos alimentar desde 7v hasta 12v Dc, o también lo podemos alimentar con el
mismo cable que va conectado a la laptop.
¿Para qué sirve Arduino? Arduino se puede utilizar para desarrollar elementos
autónomos, conectándose a dispositivos e interactuar tanto con el hardware como
con el software. Nos sirve tanto para controlar un elemento, pongamos por
ejemplo un motor que nos suba o baje una persiana basada en la luz existente en
una habitación, gracias a un sensor de luz conectado al Arduino, o bien para
leer la información de una fuente, como puede ser un teclado, y convertir la
información en una acción como puede ser encender una luz y pasar por un
display lo tecleado.
ARDUINO LEONARDO.
En mi caso utilizare
este Arduino, cabe resaltar que hay más tarjetas Arduino, yo escogí este
arduino por la cantidad de pines, hay otros mejores, pero para empezar este cae
muy bien para hacer nuestros proyectos en electrónica.
Arduino Leonardo es una placa con un
microcontrolador ATmega32U4 que permite un diseño mucho más sencillo y
económico. Una de las ventajas de este nuevo microcontrolador es que dispone de
USB nativo por hardware y por lo tanto no necesita de ninguna conversión
serie-USB. También permite a la placa ser utilizada y programada como un
dispositivo de entrada para emular un teclado, ratón, etc.
Tiene 20 pines digitales de
entrada/salida, de los cuales 7 pueden ser usadas como salidas PWM y 12 como
entradas analógicas.
El puerto de comunicación USB es
emulado, por tanto, deja el puerto serial hardware libre para la programación,
De esta forma ya no ocurren conflictos de programación mientras tenemos
periféricos serial conectados a la placa.
CARACTERÍSTICAS DEL ARDUINO LEONARDO
|
Microcontrolador: ATmega32u4.
|
Tensión de funcionamiento: 5v DC
|
Alimentación recomendad: 7v – 12v DC
|
Pines I/O Digitales: 20
|
Pines PWM : 7
|
Entradas Analógicas : 12
|
Corriente máxima de los pines I/O: 40 mA
|
Corriente máxima del pin 3.3v : 50 mA
|
Memoria flash : 32KB (4KB usados para el bootloader)
|
SRAM: 2.5 KB
|
EEPROM interna: 1 KB
|
Velocidad: 16 MHz
|
Voltaje de
alimentación para Arduino.
La placa Arduino Leonardo, puede ser alimentada a través de la conexión
micro USB o con una fuente de alimentación externa. La fuente de alimentación
se selecciona automáticamente.
Para usar alimentación externa (no mediante USB), ésta puede venir de
una pila de 9v con un conector tipo Jack Macho de 2.1mm con centro positivo a
la toma de alimentación de la placa, esta alimentación es la que yo les
recomiendo, les dejo una foto de cómo va conectado la pila con el Arduino.
La placa puede operar mediante una alimentación externa de 7 a 12
Voltios DC. En caso de alimentar la placa con menos de 7 Voltios, el regulador
de 5 Voltios puede no llegar a este valor y la placa podría volverse inestable. Sin embargo,
si utilizamos más de 12 voltios, el regulador de tensión puede sobrecalentarse
y llegar a dañar nuestra placa. Por lo tanto, el rango recomendado de
alimentación es de 7 a 12 Voltios.
Los pines de
alimentación son los siguientes:
- VIN. El voltaje de entrada a la
placa Arduino cuando se utiliza una fuente de alimentación externa (a
diferencia de 5 Voltios de la conexión USB o de otra fuente de
alimentación regulada). Se puede suministrar tensión a través de este pin,
por este pin lo podemos alimentar desde 7v hasta 9v DC.
- 5V. Fuente de alimentación
regulada usada para alimentar el microcontrolador y otros componentes en
la placa (por este pin debemos de conectarlo 5v).
- 3.3V. Un suministro de 3.3
Voltios, generados por el integrado. Consumo de corriente máxima: 50 mA.
- GND. Pines de negativo o tierra
(0 Voltios).
- IOREF. Tensión a la cual los pines
de entrada y salida están funcionando.
Microcontrolador.
El ATmega32u4 que incorpora el Arduino
Leonardo, posee 32 KB (4 KB utilizados para el bootloader). También ofrece 2,5
KB de SRAM y 1 KB de EEPROM (los cuales pueden ser leídos y escritos con
la librería EEPROM).
Entradas y salidas
I/O.
Cada uno de los 20 pines digitales de entrada/salida que posee la placa,
se pueden utilizar mediante las funciones de siempre: pinMode(), digitalWrite() o
digitalRead().
Cada uno de los 20 pines de I/O digitales se pueden utilizar como
entrada o salida, usando las funciones pinMode(), digitalWrite() y digitalRead(). Cada pin nos proporcionará un máximo de 40 mA y,
tampoco podrá recibir más de este valor.
- Serial: 0 (RX) y 1 (TX). Se
utiliza para recibir (RX) y transmitir (TX) datos serie TTL con la
capacidad de hardware serie del ATmega32U4. Hay que tener en cuenta que,
en Arduino Leonardo, la clase Serial se refiere a la comunicación USB (CDC);
para serie TTL en los pines 0 y 1, utilizaremos la clase Serial1.
- IST: 2 (SDA) y 3 (SCL). Soportan la comunicación
TWI utilizando la librería Wire.
- Interrupciones externas: 2 y 3.
Estos pines se pueden configurar para desencadenar una interrupción en un
valor bajo, un flanco ascendente o descendente, o un cambio en el valor.
- PWM: 3, 5, 6, 9, 10, 11 y 13. Proporcionan
8-bit de salida PWM con la función analogWrite
().
- SPI: en la cabecera de ICSP. Estos pines soportan la
comunicación SPI utilizando la librería SPI. Debemos
tener en cuenta que los pines de SPI no está conectados a cualquiera de
los pines digitales de entrada/salida, como están en Arduino UNO.
Sólo están disponibles en el conector ICSP.
- LED: 13. Hay un LED smd conectado al pin digital 13. Cuando el pin tiene valor alto, el LED está encendido, cuando se pasa a valor bajo, el led se apaga.
- Entradas Analógicas: A0-A5, A6 – A11 (en
los pines digitales 4, 6, 8, 9, 10, y 12). La placa Arduino Leonardo
tiene 12 entradas analógicas, las cuales van desde A0 hasta A11. También
pueden ser utilizadas como entradas/salidas digitales. Los pines A0-A5
están situados en el mismo lugar que en Arduino UNO; las entradas A6-A11
se corresponden con las entradas/salidas digitales de los pines 4, 6, 8,
9, 10 y 12, respectivamente. Cada entrada analógica puede proporcionar 10
bits de resolución, es decir 1024 valores diferentes (desde 0 hasta 1023).
Por defecto, la medida de las entradas analógicas van desde 0 a 5 Voltios,
aunque se puede cambiar el extremo superior de su rango con el pin AREF y
la función analogReference().
- AREF. Tensión de referencia para
las entradas analógicas. Se utiliza con analogReference().
- Reset:
reinicia el microcontrolador.
Comunicación.
La placa Arduino
Leonardo ofrece importantes facilidades para obtener comunicación con un
ordenador, otro Arduino o incluso con otros
microcontroladores. El ATmega32u4 incorpora comunicación serie UART TTL
(5 Voltios) disponible en los pines digitales 0 (RX) y 1 (TX), los cuales se han
comentado anteriormente.
Este
microcontrolador también nos permitirá establecer una comunicación serial a
través de USB (CDC) y aparecer como puerto COM virtual con en nuestro sistema
operativo. El integrado también actúa a modo de dispositivo de máxima velocidad
USB 2.0, utilizando los drivers estándar de COM USB. Para Windows, se
necesitará un archivo con extensión .inf.
El IDE de Arduino
incluye un monitor de puerto serie que nos va a proporcionar la opción de
transmitir texto desde la placa Arduino y, hacia la misma. Ya sabemos que los
LEDs TX y RX de la placa parpadearán cuando se transmitan datos a través de la
conexión USB al ordenador (pero no para la comunicación de serie en los pines 0
y 1).
Para establecer una
comunicación serie en cualquiera de los pines digitales de Arduino, usaremos
la librería SoftwareSerial.
El ATmega32u4
también es compatible con la comunicación I2C (TWI) y SPI. El IDE de Arduino incluye
la librería Wire, para simplificar el uso del bus I2C. La librería SPI la utilizaremos para la comunicación SPI. Mediante Arduino
Leonardo, podemos emular un teclado y un ratón genérico, y puede ser programado
para controlar estos dispositivos de entrada utilizando clases Keyboard & Mouse.
Programación.
La placa Arduino Leonardo se programará con el
software de Arduino y, tan sólo deberemos elegir el modelo de placa que vamos a
utilizar.
Protección contra
cortocircuitos.
La placa Arduino Leonardo posee un polifusible reseteable que
protege los puertos USB de nuestro ordenador de las variaciones de corriente.
Aunque, si no todos, la mayoría de los ordenadores ofrecen una protección
interna, el fusible nos proporciona una protección extra. Si aplicamos más de
500 mA al puerto USB del ordenador, el fusible automáticamente corta la
conexión hasta que el cortocircuito o sobrecarga desaparezca.
Hasta aquí ya tenemos una teoría básica de Arduino, les sugiero que
visitan la página oficial de Arduino, allí encontrarán bastante teoría del
mismo, les recomiendo leer la página, ahora si podemos hacer dos pequeños
ejemplos, el primero será como encender y apagar un led, y más abajo veremos un
secuencial con 5 les muy llamativo.
1er ejemplo:
Primero vamos a realizar el diagrama, de acuerdo a eso vamos a realizar
la programación.
Ahora si procedemos hacer la programación, en si encender y apagar un
led en Arduino es muy simple, además podemos extraerlo del mismo programa de
Arduino, mas abajo les dejare para que lo descarguen la programación.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void setup() { //
Colocamos o escribimos aquello que debemos ejecutar una sola vez
pinMode(13, OUTPUT); // se inicia con el pin 13 como salida
}
void loop() { //
la funcion loop es el que se ejecuta un numero infinito de veces
digitalWrite(13, HIGH); // se enciende el led en nivel alto
delay(3000); //
el led esta encendido por 1 segundo
digitalWrite(13, LOW); // se apaga el led
delay(500); // se apaga el led por 1 segundo
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
Este código lo cargamos al Arduino por medio del cable usb, a
continuación, les dejo una foto del circuito en una protoboard.
La siguiente
programación será hacer un circuito secuencial con diodos leds, primero
diseñamos el diagrama.
Ahora si vamos a la
programación, a continuación, les dejo el código.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int tiempo =
1000; // Variable tiempo
150 milisegundos
int pin; // variable pin
void setup()
{
for(pin = 0; pin <= 4; pin++) // aqui agregamos el ciclo for, pines a
utilizar 0,1,2,3,4
{
pinMode(pin, OUTPUT); // pines del arduino 0,1,2,3,4 se
configuran como salida
}
}
void loop() // Empesamos con el
secuencial con leds
{
for(pin = 0; pin <= 4; pin++) // los leds se encenderan y apagaran de a
uno en forma creciente
{
digitalWrite(pin, HIGH); // los leds se encienden
delay(tiempo);
digitalWrite(pin, LOW); // los leds se apagan
delay(tiempo);
}
for(pin = 4; pin >= 0; pin--) // los leds se encenderan y apagaran de a
uno en forma decreciente
{
digitalWrite(pin, HIGH); // los leds se encienden
delay(tiempo);
digitalWrite(pin, LOW); // los leds se apagan
delay(tiempo);
}
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////
Una vez que hayamos compilado el código y este todo ok, ahora si vamos
ensamblar el circuito en la protoboard, y luego cargamos el código, les dejo mi
circuito en la protoboard.
Hasta aquí ya tenemos una idea de que es Arduino y de cómo empezar a
programarlo, a continuación, les dejo un vídeo, donde allí explicamos conceptos
básicos de Arduino, pines del mismo, voltaje de alimentación, en si todas sus
características, y por último la programación, les recomiendo que vean el
siguiente vídeo.
Ahora vamos a realizar una secuencia de leds muy llamativo, realizaremos
unas 8 secuencias de con leds, pero podríamos hacer más secuencias, esa tarea
les dejo para ustedes, a continuación, les dejo el diagrama de las secuencias
de leds, vamos hacer una secuencia con 12 diodos leds, como lo vemos en la siguiente
imagen.
El código fuente de Arduino les dejo más abajo, en los links de descarga,
en el siguiente video explicamos paso a paso de cómo hacer la secuencia de leds
(8 secuencias), allí les explico cómo programar y cargar el código al Arduino y
a la ves explico el ensamble en la protoboard.
Vídeo.
Link s de descarga:
1.- Ejemplo 1 (como
encender y apagar un led)
2.- Ejemplo 2
(secuencial con diodo leds)
https://mega.nz/#F!HMBgxa5L!GUAntOp_PMtApAEeV-1EMw
Gracias por visitar mi blog,cualquier duda me comentan.
3.- Secuencial con
leds código arduino, 8 secuencias, con 12 diodos leds.
Comentarios