Esta es una adaptación de los tutoriales originalmente publicados en inglés por John Boxall en tronixstuff con licencia Creative Commons Attribution-Non Commercial-Share Alike v3.0 license de acuerdo con esta nota del autor original. Nuestra adaptación incluye traducción al español y pequeñas modificaciones a los contenidos a efecto de facilitar su lectura en español.
IMPORTANTE: Los enlaces dentro de cada tutorial permanecen apuntando hacia los originales, en algunos casos se agregan enlaces correspondientes a publicaciones en español o a referencias del traductor. Todas las referencias en primera persona (p.ej. "mis tutoriales", o "mi nuevo libro", etc.), son referencias dadas por el autor original.
Otros tutoriales Arduino recomendados:
- Arduino - Cosas de Mecatrónica es ahora tdrobótica.co
- Playlist Tutoriales de Arduino - YouTube en el Canal TecBolivia - YouTube
- Playlist Curso de Arduino - YouTube en el Canal CodigoFacilito - YouTube
- Playlist Arduino Starter Kit - Video Tutorials by Massimo Banzi
- Learn Arduino - Adafruit Learning System
Otra recomendación: Dar un rápido repaso a los fundamentos de electrónica tal como se muestra en esta presentación.
¡Empezando con Arduino! - Capítulo Cero
¡Hola mundo!
Actualizado 24/11/2012
¡Por favor únete a nosotros mientras aprendemos electrónica y Arduino! Juntos a través de esta serie de tutoriales (original) o a través de esta traducción me gustaría compartir contigo un viaje de aprendizaje, exploración y diversión con el sistema Arduino, y hacer algunas cosas agradables, útiles, interesantes, inútiles y prácticas. Estas entradas se publicarán de forma regular, sobre las otras entradas no-microcontrolador (N. del T.: el autor original publica sobre otros temas diferentes a microcontroladores en entorno Arduino). En lugar de escuchar a alguien hablando realmente rápido en un video, puedes leer y seguir a tu propio ritmo, ver ejemplos en acción, aprender mucho – e inspirarte para hacer algo por tu propia cuenta.
Así que empecemos…
Hay más de cincuenta capítulos en esta serie, sin embargo deberías empezar aquí (capítulo cero). Sin embargo hay un índice completo de artículos en este blog en la página Tutoriales Arduino, o los originales en inglés pueden encontrarse aquí. Una vez hayas cubierto el material en los capítulos cero a trece deberías estar listo para saltar a cualquier otro capítulo. Durante las primeras entradas, nos referiremos al libro:
- Getting Started with Arduino (Massimo Banzi) Versión en español.
y también asumiremos un conocimiento básico de electrónica. Para soporte o para tener tus preguntas respondidas, publica tu cuestionamiento en nuestro Google Group (en inglés) – un lugar amigable para tales discusiones.
Si prefieres un método de aprendizaje fuera de línea, o si te gustaría un libro excelente sobre el tópico – considera mi libro “Arduino Workshop (en inglés)” – es el mejor libro en el mercado para que un completo principiante aprenda Arduino.
En primer lugar, desglosemos el sistema completo en las partes básicas. Desde allí podemos construir un entendimiento de todo lo que es Arduino.
Arduino es una plataforma de computación física de fuente abierta basada en una simple tarjeta de entrada/salida y en un entorno de desarrollo que implementa el lenguaje Processing (www.processing.org). Arduino puede usarse para desarrollar objetos interactivos en solitario, o para conectarlos a software en tu computadora.[1]
Así pues, tenemos hardware y software. Nuestro hardware será una computadora personal que corre el software IDE Arduino (IDE: integrated development environment – entorno de desarrollo integrado); y el Arduino mismo y la electrónica que le acompaña.
Nuestro software es el IDE – software muy similar a un procesador de palabras, pero que puede enviar el programa Arduino (o “sketch”) al microcontrolador. Estos sketches son programas que son escritos en el lenguaje Processing – el cual es similar a C. Estos son interpretados por un cargador de arranque (boot loader) – software en el chip que le permite entender tu sketch. Como el sistema Arduino es open source, cualquiera puede comprar un microcontrolador en blanco y poner el cargador de arranque en él, o incluso escribir su propio cargador de arranque o modificar el original.
Ahora para el Arduino mismo. ¿Pero qué significa eso? Echemos un vistazo…
Lo que tenemos es un microcontrolador instalado en una tarjeta de circuitos con una interfaz USB, un socket de energía DC, y muchas líneas de entrada y salida (más de ellas más adelante). Además algunos LEDs para reportes de estado, y otros componentes misceláneos. Esta tarjeta es el Uno, y usa el microcontrolador ATMega328.
También hay tarjetas más grandes, más pequeñas, más viejas y en el futuro más nuevas – cada una diferente por su tamaño físico, tipo de interfaz, y sketches y memoria de datos disponible. Una mejora muy buena sobre las tarjetas Arduino están disponibles en Freetronics.
El propósito de la tarjeta es simplificar el acceso al microcontrolador en un grado considerable, y permitirte hacer interfaces fáciles con entradas, salidas y fuentes de poder, conectar a una PC para programar, y hablar con otros circuitos. Sin embargo la tarjeta es más para tu conveniencia, en tus propios diseños realmente puedes usar el microcontrolador programado sin la tarjeta.
Para hacer un sumario en este punto – con un Arduino puedes conectar varias formas de entrada y salida, y crear un programa para procesar y responder a las entradas y salidas. Por ejemplo, podrías crear una alarma de temperatura – cuando la temperatura de tu habitación suba arriba de una cantidad señalada, el Arduino podría sonar una alarma.
Las formas de entrada pueden incluir: botones, interruptores, sensores de movimiento, sensores de temperatura, sensores de luz, sensores de gas (!), diales que puedes girar (e.g. como un botón de volumen), receptores de datos inalámbricos, etc. Las formas de salida pueden incluir: luces, hacedores de ruido, motores, bombas, otros circuitos, despliegues de cristal líquido (LCDs – Liquid Cristal Displays), etc. Básicamente cualquier cosa que pueda encenderse o apagarse, o controlada por electricidad, puede controlarse con un Arduino.
Para hacer las cosas más fáciles, puedes comprar o construir lo que se llama un shield (N. del T. shield: escudo). Esta es una tarjeta interfaz que se coloca encima de tu Arduino, y tiene diversos tipos de circuitería con la cual puedes hacer interfaz. Por ejemplo, una conexión de red Ethernet, un joystick para juegos o para controlar un robot, o un LCD.
Así que eso significa que con el sketch correcto, y con la interfaz de hardware correcta, y tal vez con un shield, puedes hacer casi cualquier cosa.
¡Excelente!
Afortunadamente eso es casi todo lo que necesitamos aprender por el momento. Ahora es tiempo de realmente hacer algo. Necesitarás tres cosas:
- Una computadora personal corriendo Linux, MacOS o Windows con un puerto USB, con acceso a Internet. Entonces otra vez, si estás leyendo esto – estás en la red
- un cable USB que haga juego con el socket de tu tarjeta
- una tarjeta Arduino o compatible. La mayoría de tarjetas debería venir con un cable USB, revisa antes de comprar.
Actualización – 10/01/2013: He escrito estos tutoriales en un período que abarca más de dos años. Durante este tiempo varias versiones del IDE Arduino han sido publicadas. Sobre las próximas semanas me estoy esforzando en actualizar los tutoriales de tal manera que trabajen con el último IDE Arduino v1.0.1 (o más nuevo). Mientras tanto, puedes correr ambos v23 (viejo) y v1.0.1 (y más) en la misma máquina. Cualquier tutorial anotado como actualizado el 24/11/2012 o más tarde trabaja con el nuevo IDE. Cualquier pregunta – email john at tronixstuff dot com.
Y ahora para la preparación inicial – por favor instala tu software IDE Arduino usando las instrucciones aquí (en inglés) o aquí (en español). Si estás corriendo Ubuntu, aquí hay una excelente guía de instalación (en inglés).
¿Qué tal te fue? ¿Parpadeó tu LED? ¿Fuiste hipnotizado, mirando sin comprender toda esa belleza parpadeante? Está bien, puedes admitirlo – a todos nos pasó la primera vez.
Al trabajar a lo largo de esta serie de tutoriales, algunos de los archivos que bajarás terminarán con .pde o .ino. Ambos están bien, la extensión .pde se usaba para sketches escritos antes del IDE Arduino v1.0. Puedes cargarlos y trabajar con ellos normalmente.
En este punto espero que te hayas dado cuenta de que el Arduino puede energizarse con el puerto USB de tu computadora. Sin embargo, si deseas usar tu Arduino ya programado lejos de tu computadora, necesitarás un plugpack bien regulado o alguna otra fuente de poder.
Hay algunas cosas realmente básicas para empezar, sin embargo de acuerdo con los creadores de Arduino, favor de referirse al libro Getting Started with Arduino (aquí versión en español) hasta el final de la página 38. ¡Deberías ser capaz de hacer que ese LED parpadee por tu propia cuenta!
Ejercicio 0.1
Ahora a divertirnos con más parpadeos. ¡Recuerdas Knight Rider con David Hasselhoff? El personaje manejaba un Trans Am trucado con algunas luces en el capó, una fila horizontal con cada luz parpadeando en secuencia de izquierda a derecha y luego a izquierda…
Tu misión, es simplemente recrear esto con tu Arduino, usando no uno sino que ocho LEDs. Parpadéalos en un bucle sin fin en la secuencia 1-2-3-4-5-6-7-8-7-6-5-4-3-2-1-2-3-… con un retraso de un segundo.
Necesitarás:
- Tu equipo Arduino estándar (computadora, cable, Uno o compatible)
- 8 diodos emisores de luz (light emitting diodes - LEDs). Cualesquiera en tanto consuman menos de 40mA.
- 8 resistores de 560 ohm y 0.25 W. Son para reducir la corriente para proteger los LEDs
- un protoboard y cable de conexión
- una cámara (opcional) – ¡para documentar tu éxito!
Sugerencia – haz que el retraso sea una variable, así podrás modificarlo fácilmente.
De tu proyecto original de LED intermitente, en el libro se usó el pin digital 13. Esta vez, puedes usar los pines digitales 2 a 9. El lado del hardware es fácil – conecta un cable desde cada pin de salida digital al ánodo de un LED, entonces coloca un resistor de 560 ohm desde el cátodo de regreso a tierra. Mira el diagrama de abajo:
Y esto es lo que esperaríamos que se vea como resultado:
Y desde luego, aquí está en acción:
Ahora es tu turno de hacer algo – ¡escribe el código! Pero antes de hacer eso, planifica qué quieres hacer primero (algunos de la vieja escuela llamarían algoritmo al plan). Por ejemplo, para este ejercicio podrías escribir algo como…
plan del ejercicio 0.1
- configurar todos los pines que quiero usar como salidas
- crear una variable para almacenar la duración del retraso en milisegundos
- iniciar un bucle infinito
- encender el pin 2, esperar la duración del retraso, apagarlo
- encender el pin 3, esperar la duración del retraso, apagarlo
- repetir para los pines 4 a 9
- entonces hacer la misma cosa pero de regreso hacia el pin 3
- terminar el bucle infinito
¿Entonces qué tal te fué? ¿Funcionó la primera vez? Está bien si no fue así, ya que aprendes cometiendo errores y reparándolos. Recuerda – si tienes preguntas, deja un comentario al final de esta entrada y yo me comunicaré de vuelta (N. del T.: los comentarios en este blog serán revisados por el Traductor. Para comentar la publicación del autor original acceder aquí). Pero para ahorrarte tiempo, aquí está el sketch:
/*
exercise 0.1 - KITT emulator!
Created 02/04/2010
By John Boxall
http://tronixstuff.com...
Blinks LEDs from output pin 2~9 in a forwards<>backward motion
The circuit:
an LED is connected to each output pin from 2 to 8, thence to a 560 ohm resistor, then to ground (pin 4 on the bottom left of the Arduino Duemilanove).
based on an orginal by H. Barragan for the Wiring i/o board
*/
// The setup() method runs once, when the sketch starts
int del=100; // sets a default delay time, 100 milliseconds (one tenth of a second)
void setup()
{
// initialize the digital pins as outputs:
// later on there will be easier ways to do this
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(7, OUTPUT);
pinMode(8, OUTPUT);
pinMode(9, OUTPUT);
}
// the loop() method repeats indefinitely until you turn off the power
void loop()
{
digitalWrite(2, HIGH); // turn on LED on pin 2
delay(del); // wait (length determined by value of 'del')
digitalWrite(2, LOW); // turn it off
digitalWrite(3, HIGH); // turn on LED on pin 3
delay(del); // wait
digitalWrite(3, LOW); // turn it off
digitalWrite(4, HIGH); // turn on LED on pin 4
delay(del); // wait
digitalWrite(4, LOW); // turn it off
digitalWrite(5, HIGH); // turn on LED on pin 5
delay(del); // wait
digitalWrite(5, LOW); // turn it off
digitalWrite(6, HIGH); // turn on LED on pin 6
delay(del); // wait
digitalWrite(6, LOW); // turn it off
digitalWrite(7, HIGH); // turn on LED on pin 7
delay(del); // wait
digitalWrite(7, LOW); // turn it off
digitalWrite(8, HIGH); // turn on LED on pin 8
delay(del); // wait
digitalWrite(8, LOW); // turn it off
digitalWrite(9, HIGH); // turn on LED on pin 9
delay(del); // wait
digitalWrite(9, LOW); // turn it off
digitalWrite(8, HIGH); // turn on LED on pin 8
delay(del); // wait
digitalWrite(8, LOW); // turn it off
digitalWrite(7, HIGH); // turn on LED on pin 7
delay(del); // wait
digitalWrite(7, LOW); // turn it off
digitalWrite(6, HIGH); // turn on LED on pin 6
delay(del); // wait
digitalWrite(6, LOW); // turn it off
digitalWrite(5, HIGH); // turn on LED on pin 5
delay(del); // wait
digitalWrite(5, LOW); // turn it off
digitalWrite(4, HIGH); // turn on LED on pin 4
delay(del); // wait
digitalWrite(4, LOW); // turn it off
digitalWrite(3, HIGH); // turn on LED on pin 3
delay(del); // wait
digitalWrite(3, LOW); // turn it off
}
exercise 0.1 - KITT emulator!
Created 02/04/2010
By John Boxall
http://tronixstuff.com...
Blinks LEDs from output pin 2~9 in a forwards<>backward motion
The circuit:
an LED is connected to each output pin from 2 to 8, thence to a 560 ohm resistor, then to ground (pin 4 on the bottom left of the Arduino Duemilanove).
based on an orginal by H. Barragan for the Wiring i/o board
*/
// The setup() method runs once, when the sketch starts
int del=100; // sets a default delay time, 100 milliseconds (one tenth of a second)
void setup()
{
// initialize the digital pins as outputs:
// later on there will be easier ways to do this
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(7, OUTPUT);
pinMode(8, OUTPUT);
pinMode(9, OUTPUT);
}
// the loop() method repeats indefinitely until you turn off the power
void loop()
{
digitalWrite(2, HIGH); // turn on LED on pin 2
delay(del); // wait (length determined by value of 'del')
digitalWrite(2, LOW); // turn it off
digitalWrite(3, HIGH); // turn on LED on pin 3
delay(del); // wait
digitalWrite(3, LOW); // turn it off
digitalWrite(4, HIGH); // turn on LED on pin 4
delay(del); // wait
digitalWrite(4, LOW); // turn it off
digitalWrite(5, HIGH); // turn on LED on pin 5
delay(del); // wait
digitalWrite(5, LOW); // turn it off
digitalWrite(6, HIGH); // turn on LED on pin 6
delay(del); // wait
digitalWrite(6, LOW); // turn it off
digitalWrite(7, HIGH); // turn on LED on pin 7
delay(del); // wait
digitalWrite(7, LOW); // turn it off
digitalWrite(8, HIGH); // turn on LED on pin 8
delay(del); // wait
digitalWrite(8, LOW); // turn it off
digitalWrite(9, HIGH); // turn on LED on pin 9
delay(del); // wait
digitalWrite(9, LOW); // turn it off
digitalWrite(8, HIGH); // turn on LED on pin 8
delay(del); // wait
digitalWrite(8, LOW); // turn it off
digitalWrite(7, HIGH); // turn on LED on pin 7
delay(del); // wait
digitalWrite(7, LOW); // turn it off
digitalWrite(6, HIGH); // turn on LED on pin 6
delay(del); // wait
digitalWrite(6, LOW); // turn it off
digitalWrite(5, HIGH); // turn on LED on pin 5
delay(del); // wait
digitalWrite(5, LOW); // turn it off
digitalWrite(4, HIGH); // turn on LED on pin 4
delay(del); // wait
digitalWrite(4, LOW); // turn it off
digitalWrite(3, HIGH); // turn on LED on pin 3
delay(del); // wait
digitalWrite(3, LOW); // turn it off
}
Así que aquí lo tienes. Hoy has aprendido cómo configurar una computadora para programar tu Arduino, y has escrito algunos sketches para crear resultados basados en tu diseño. Aunque no es mucho, tenemos que empezar en algún lugar… pero seguirán cosas grandes. ¡Como el capítulo uno (aquí el original)!
Diviértete y sigue revisando tronixstuff.com. ¿Por qué no seguir en twitter, Google+, subscribirse para actualizaciones por correo o por RSS usando los vínculos de abajo, o unirse a nuestro Google Group – dedicado a los proyectos y a temas relacionados en el website original? Únete – es gratis, útil para todos – y todos podemos aprender algo.
Notas:
[1] de “Getting Started with Arduino” por Massimo Banzi (O’Reilly).
No hay comentarios.:
Publicar un comentario