Primeros pasos con Arduino, prctica 1: el

coche fantstico
By salva el 19 Mayo 2010 6 Comentarios
Arduino,
Electrnica,
Proyectos
Darle 5/5

D
arle 1/5
D
arle 2/5
D
arle 3/5
D
arle 4/5
D
arle 5/5
Su voto: Nada Average: 4.7 (6 votos)





Arduino es un sistema microcontrolado de hardware libre y cdigo abierto, multiplataforma, barato,
con un entorno de programacin sencillo y simple, basado en el microcontrolador ATMEGA en sus
diferentes versiones de Atmel. Existen diferentes versiones de las placas arduino, yo he usado la
llamada Arduino Duemilanove es la sucesin de la Arduino Diecimila, que monta el nuevo
procesador ATMega328.
Dispone de 14 pines de entada y salida digitales, de los cuales 6 se pueden usar como salidas
PWM (Pulse Width Modulation), 6 entradas analgicas, se conecta al puerto USB, (con un cable
como el de las impresoras), tambin dispone de un conector de corriente.
Todo lo que necesitamos saber sobre este estupendo sistema est en la web
oficial:http://www.arduino.cc/
En Tecnologa es un sistema ideal para controlar los proyectos que solemos realizar con nuestros
alumnos, control de puertas, barreras, semforos, ascensores,
En esta y sucesivas entregas iremos realizando prcticas bsicas basadas en este hardware:
Para comenzar necesitamos:
Descargar e instalar el entorno de programacin Arduino. No hace falta instalacin simplemente
descomprimimos el paquete en una carpeta y lanzamos el ejecutable arduino.
Conectar nuestra placa al PC. Si no detecta automticamente los drivers stos los podremos
encontrar en la carpeta arduino-xx/drivers/FTDI USB Drivers/
Arrancamos el entorno, y en el men Tools configuramos la conexin (serial Port) y nuestra placa
(en este caso Arduino Duemilanove).
La sintaxis del lenguaje es muy parecida al lenguaje C, la estructura bsica de cualquier programa
es la siguiente:
void setup()
{
//declaro variables, asigno PinMode o inicializo las comunicaciones serie.
}
void loop()
{
//se ejecuta a continuacin, incluye el cdigo que lee entradas, activa salidas...es el ncleo del
cdigo.
}
Os aconsejo leer el manual adjunto para ampliar un poco ms en el entorno Arduino, en l
encontrareis un apartado donde se describen la base de la programacin de este sistema, muy
fcil si tenemos conocimientos de programacin.
A partir de aqu podremos empezar con nuestras prcticas:
Prctica 1: El coche fantstico.

Necesitaremos 8 diodos LED, ocho resistencias de 220 Ohmios y una placa de prototipos y
conectamos el esquema como el de la figura. Los diodos leds se encendern y apagaran siguiendo
un patrn establecido en el cdigo, se muestran tres posibles opciones, podremos variar el tiempo
de encendido y apagado, modificando la variable timer. Aqu el cdigo:
/* Coche fanttico 1*/
int pinArray[] = {2, 3, 4, 5, 6, 7,8,9};
int count = 0;
int timer = 70;
void setup(){
for (count=0;count<8;count++) {
pinMode(pinArray[count], OUTPUT);
}
}
void loop() {
for (count=0;count<8;count++) {
digitalWrite(pinArray[count], HIGH);
delay(timer);
digitalWrite(pinArray[count], LOW);
delay(timer);
}
for (count=7;count>=0;count--) {
digitalWrite(pinArray[count], HIGH);
delay(timer);
digitalWrite(pinArray[count], LOW);
delay(timer);
}
}

/* El coche fantstico2*/
int pinArray[] = {2, 3, 4, 5, 6, 7,8,9};
int count = 0;
int timer = 15;
//timer marca como queremos que vaya de rpido la rfaga de encendido-apagado de los
LEDS
void setup(){
for (count=0;count<8;count++) {
pinMode(pinArray[count], OUTPUT);
}
}
void loop() {
for (count=0;count<7;count++) {
digitalWrite(pinArray[count], HIGH);
delay(timer);
digitalWrite(pinArray[count + 1], HIGH);
delay(timer);
digitalWrite(pinArray[count], LOW);
delay(timer*2);
}
for (count=7;count>0;count--) {
digitalWrite(pinArray[count], HIGH);
delay(timer);
digitalWrite(pinArray[count - 1], HIGH);
delay(timer);
digitalWrite(pinArray[count], LOW);
delay(timer*2);
}
}

/* Estrella fugaz
*---------------
* Este programa es una variante del ejemplo del coche
* fantstico. Muestra mediante un loop una estrella
* fugaz que es dibujada en una linea de LED-s
* directamente conectados a la placa Arduino
*
* Puedes controlar la velocidad a la que la estrella
* se mueve gracias a una variable llamada "waitNextLed"
*
* Tambin puedes controlar la longitud de la cola
* de la estrella a travs de la variable "tail length"
*
* @author: Cristina Hoffmann
* @hardware: Cristina Hofmann
*
*/
// Variable declaration
int pinArray [] = { 2,3,4,5,6,7,8,9,10,11,12 }; // Declaracin de los PIN-es mediante un array
int controlLed = 13; // LED de control
int waitNextLed = 100; // Tiempo antes de encender el siguiente LED
int tailLength = 4; // Nmero de LED-s que permanecen encendidos antes de empezar a
apagarlos para formar la cola
int lineSize = 11; // Nmero de LED-s conectados (que es tambin el tamao del array)
void setup() // Configuracin de los PIN-es como salida digital
{
int i;
pinMode (controlLed, OUTPUT);
for (i=0; i< lineSize; i++)
{
pinMode(pinArray[i], OUTPUT);
}
}
void loop()
{
int i;
int tailCounter = tailLength; // Se establece la longitud de la cola en un contador
digitalWrite(controlLed, HIGH); // Se enciende el LED de control para indicar el inicio del
loop
for (i=0; i<lineSize; i++)
{
digitalWrite(pinArray[i],HIGH); // Se encienden consecutivamente los LED
delay(waitNextLed); // Esta variable de tiempo controla la velocidad a la que se mueve la
estrella
if (tailCounter == 0)
{
digitalWrite(pinArray[i-tailLength],LOW); // Se apagan los LED-s en funcin de la longitud
de la cola.
}
else
if (tailCounter > 0)
tailCounter--;
}
for (i=(lineSize-tailLength); i<lineSize; i++)
{
digitalWrite(pinArray[i],LOW); // Se apagan los LED
delay(waitNextLed); // Esta variable de tiempo controla la velocidad a la que se mueve la
estrella
}
}
- See more at: http://www.tecnosalva.com/primeros-pasos-arduino-pr%C3%A1ctica-1-coche-
fant%C3%A1stico#sthash.R2hAwj0q.dpuf

Arduino: prctica n 2: Control mediante
pulsadores
By salva el 21 Mayo 2010 1 Comentario
Arduino,
Electrnica
Darle 4/5

D
arle 1/5
D
arle 2/5
D
arle 3/5
D
arle 4/5
D
arle 5/5
Su voto: Nada Average: 4 (1 vote)

Bien en esta segunda prctica usaremos unos pulsadores para controlar el encendido de un diodo
LED; cmo conectamos un pulsador? Usaremos un divisor de tensin, como se aprecia en la
figura, con una resistencia en Pull-down, de forma que cuando pulsemos la entrada digital tome el
valor alto.
Declaramos el pin como entrada y usamos la funcin DigitalRead() para leer el valor de dicha
entrada.

Se proponen tres ejercicios diferentes,
1. Este es el ms sencillo, al accionar el pulsador enciendo un diodo LED, al soltar se apaga:
int buttonPin = 2;
int ledPin = 13;
int estado = 0;
void setup() {
pinMode(ledPin, OUTPUT);
pinMode(buttonPin, INPUT);
}
void loop(){
estado = digitalRead(buttonPin);
if (estado == HIGH) {
digitalWrite(ledPin, HIGH);
}
else {
digitalWrite(ledPin, LOW);
}
}
2. Ahora con dos pulsadores, al accionar el pulsador 1, enciende el Diodo, al accionar el pulsador
2, apaga el diodo.
int ledPin = 13;
int inputPin1 = 2; // pulsador 1
int inputPin2 = 3; // pulsador 2
int p1;
int p2;
void setup() {
pinMode(ledPin, OUTPUT);
pinMode(inputPin1, INPUT);
pinMode(inputPin2, INPUT);
}
void loop(){
p1=digitalRead(inputPin1);
p2=digitalRead(inputPin2);
if (p1 == HIGH) {
digitalWrite(ledPin, HIGH);
} else if (p2 == HIGH) {
digitalWrite(ledPin, LOW);
}
}
3. Ahora usamos los pulsadores para iluminar ms o atenuar la luz del led, para ello debemos
cambiar la conexin del Led al pin 9, que usa la salida PWM, modulacin por ancho de pulso,
como si de una salida analgica se tratara.
int ledPin = 9;
int inputPin1 = 2; // pulsador 1
int inputPin2 = 3; // pulsador 2
int p1;
int p2;
int value = 0;
void setup() {
pinMode(ledPin, OUTPUT);
pinMode(inputPin1, INPUT);
pinMode(inputPin2, INPUT);
}
void loop(){
p1=digitalRead(inputPin1);
p2=digitalRead(inputPin2);
if (p1 == HIGH) { value--; }
else if (p2 == HIGH) { value++; }
value = constrain(value, 0, 255);
analogWrite(ledPin, value);
delay(10);
}
- See more at: http://www.tecnosalva.com/arduino-pr%C3%A1ctica-n%C2%BA-2-control-mediante-
pulsadores#sthash.zh4NPEAA.dpuf

Prcticas 3 y 4 con arduino: control de un
motor y un servomotor
By salva el 24 Mayo 2010 10 Comentarios
Arduino,
Electrnica
Darle 5/5

D
arle 1/5
D
arle 2/5
D
arle 3/5
D
arle 4/5
D
arle 5/5
Su voto: Nada Average: 4.5 (4 votos)




Vamos a controlar un motor, lo conectaremos segn el esquema adjunto al pin 9 de Arduino, para
poder modular el pulso, realizaremos varias prcticas:
1. Arrancamos el motor, esperamos un tiempo, despus apagamos el motor.
int motorPin = 9;
void setup()
{
pinMode(motorPin, OUTPUT);
}
void loop()
{
int onTime = 2500;
int offTime = 1000;
digitalWrite(motorPin, HIGH);
delay (onTime);
digitalWrite(motorPin, LOW);
delay (offTime);
}

2. Al igual que antes cambiabamos la iluminacin del led, ahora podemos controlar la velocidad
del motor con la funcin analogWrite(pin, valor).
int motorPin = 9;
void setup()
{
pinMode(motorPin, OUTPUT);
}
void loop()
{
int onSpeed = 200;
int onTime = 2500;
int offSpeed = 50; // a number between 0 (stopped) and 255 (full speed)
int offTime = 1000; //the number of milliseconds for the motor to turn off for
analogWrite(motorPin, onSpeed); // turns the motor On
delay(onTime); // waits for onTime milliseconds
analogWrite(motorPin, offSpeed); // turns the motor Off
delay(offTime); // waits for offTime milliseconds
}

3. Aceleramos y desaceleramos el motor, ahora usamos un bucle para acelerar y frenar el
motor, usando del mismo modo la funcin analogWrite(), que en el caso anterior.
int motorPin = 9;
void setup()
{
pinMode(motorPin, OUTPUT);
}
void loop()
{
int delayTime = 50;
tor
for(int i = 0; i < 256; i++){ //aceleramos
analogWrite(motorPin, i);
delay(delayTime);
}
for(int i = 255; i >= 0; i--){ //frenamos
analogWrite(motorPin, i);
delay(delayTime);
}
}


4. Usamos ahora un potencimetro para variar la velocidad del motor. El potencimetreo se
conecta de la siguiente forma, extremos a v+ y gnd y el pin de control al pin 0 de las entradas
anlogicas de Arduino.
Arduino dispone de 6 entradas analgicas, que tienen un voltaje de 0 a 5voltios que convertidas a
seales digitales tendramos de 0 a 1024, esto es 10 bits de resolucin. Por qu dividimos por 4
analogRead()?, pues porque esta funcin devuelve un valor comprendido entre 0 y 1024 (10 bits) y
la funcin analogWrite () toma valores comprendidos entre 0 y 255 (8 bits).
int motorPin = 9;
int potPin=0;
int potValue;
void setup()
{
pinMode(motorPin, OUTPUT);
}
void loop()
{
potValue = analogRead(potPin) / 4;
analogWrite(motorPin, potValue);
}

5. Control de un servomotor
#include <Servo.h>
Servo myservo; // creamos un objeto servo para controlar nuestro servo
int pos = 0; // variable para almacenar la posicin del servo
void setup()
{
myservo.attach(9); // attaches the servo on pin 9 to the servo object
}
void loop()
{
for(pos = 0; pos < 180; pos += 1) // avanza de 0 a 180 grados
{ // en saltos de un grado
myservo.write(pos); // mueve a la posicin de la variable 'pos'
delay(15); // espera 15ms
}
for(pos = 180; pos>=1; pos-=1) // va de 180 a 0 grados
{
myservo.write(pos);
delay(15);
}
}
- See more at: http://www.tecnosalva.com/pr%C3%A1cticas-3-y-4-arduino-control-motor-y-
servomotor#sthash.LVUgcSQu.dpuf

Cmo hacer un cubo de leds 4x4x4 con
Arduino
By salva el 22 Ene 2014 4 Comentarios
Arduino,
Proyectos

D
arle 1/5
D
arle 2/5
D
arle 3/5
D
arle 4/5
D
arle 5/5
Sin votos an

Este cubo LED utiliza un microcontrolador Arduino Uno para crear un espectculo de luces en
movimiento muy espectacular. Para realizar este proyecto con xito la paciencia es una de las
claves, si sigue el tutorial paso a paso no tendr ningn problema en desarrollarlo.
Por ltimo, lo ms importante en este proyecto es que te diviertas .
qu vamos a necesitar?
Arduino Uno (yo he usado Arduino Duemilanove)
Cable rgido para unir los diodos en el cubo
64 diodos led (yo us diodos leds azules)
16 resistencias de 220 Ohmios
Pinzas de cocodrilo
Un trozo de porexpan
Cables de conexin y placas Board para montar el circuito.
Alicates de corte y punta plana de precisin.
El diseo
Antes de comenzar la construccin, es importante tener una visin completa de cmo va a
funcionar, para que pueda improvisar e identificar los errores a medida que avanzas. Necesitamos
controlar los 64 leds del cubo con tan solo 20 pin de la placa de arduno, vamos a estar utilizando
una tcnica denominada multiplexacin. Rompemos el cubo en cuatro capas separadas por lo
que slo necesitamos pines de control para 16 LEDs - de modo para encender un LED especfico,
debemos activar tanto la capa , y el pin de control , que nos da una necesidad total de 16 +4 pines.
Cada capa tiene un ctodo comn - la parte negativa del circuito - as que todas las patas
negativas se unen entre s , y se conecta a un solo pin para esa capa .
En el lado (positivo ) de nodo , cada LED se puede conectar a la correspondiente LED en la capa
por encima y por debajo de ella . En esencia , tenemos 16 columnas de las patas positivas y 4
capas de la negativa. El siguiente diagrama en 3D muestra perfectamente la idea :


La construccin
Lo primero es tomar el trozo de porexpan y pegar en l la plantilla para poder armar el cubo. A
continuacin ya podemos ir doblando los ctodos (piernas cortas) de los LED 90 grados y luego
soldar a todos juntos para formar un ctodo comn. Cada una de las cuatro capas contar con un
ctodo comn y 16 nodos individuales (piernas largas).

Debes doblar todas los ctodos de los Leds de manera uniforme, yo me ha ayudado de unos
alicates de precisin pequeos, como los de la imagen. Con un poco de paciencia voy soldando de
cuatro en cuatro los catodos de los diodos.
El siguiente paso es utilizar un cable para conectar las cuatro filas juntos en una capa, se podra
utilizar cuatro tiras de alambre por capa, pero en realidad slo se necesitan dos iguales - una tras
la primera tira de LEDs y un segundo antes de la ltima tira de LEDs. Yo he usado tres tiras por
capa para dar una mayor sensacin de cubo unido, en la imagen de abajo podrs observar como
quedara cada capa con un ctodo comn y 16 nodos individuales.
Asegrese de recortar cualquier exceso de cable colgando sobre el borde de su cubo , tambin
puedes recortar los cuatro ctodos que sobresalen del borde de la capa.
Recuerda que en las soldaduras debes usar el menor contacto y tan poco de soldadura como sea
posible. Recuerde, ms estao en cada soldadura no es sinnimo de mayor fuerza en la unin, al
contrario podra dar problemas ms adelante.


Soldando las cuatro capas.
Ahora que tenemos las cuatro capas individuales, vamos a soldarlas entre si para formar el cubo.
Vamos a hacer esto al unir los 16 nodos de cada capa juntos para que nos quedamos con 16
nodos comunes y 4 ctodos comunes.
Lo primero que debe hacer es doblar el ltimo mm de cada nodo hacia el centro del LED, esto le
ayudar a unir las capas entre s. Slo tiene que hacer esto con tres de sus capas superiores.

A partir de aqu tendremos que darnos maa para completar la tarea, podeis usar:
1. Separdores de cartn entre capas para facilitar la tarea de soldar los 16 nodos.
2. Usar pinzas de cocodrilo para sujetar las capas mientras las sueldo.
Mi consejo es que soldar los nodos de las esquinas juntos primero. Repita esto para las dos
capas restantes y su cubo estar completo.

Conexionado y Programa en Arduino
Bueno vamos ahora al conexionado del cubo a la placa arduino y posterior programacin, Usamoa
las placas board para pinchar el cubo, y conectamos a cada uno de los 16 nodos cmunes una
resistencia de 220 Oh, que a su vez se conectarn a los puertos de Arduino, como se muestran en
el grfico siguiente. A su vez cada capa que forman los ctodos comunes se conectarn a los
puertos A2. A3, A4 y A5.


Una vez realizadas las conexiones me puedo descargar cualquiera de los dos programas adjuntos,
cada uno de ellos muestran animaciones diferentes.

Si usted desea hacer sus propias animaciones , sigue leyendo y voy a explicar cmo funciona.
As , cuando se abri el cdigo en el software de Arduino, te habrs dado cuenta de la gran bloque
de cdigo en el medio que pareca un poco a esto.

Este gran bloque de cdigo en el medio es donde se desarrollan los patrones de encendio de los
leds del cubo. La manera ms fcil de pensar en ella es como una animacin . Cada cambio en el
cubo representa un fotograma de la animacin, y cada lnea de cdigo representa un fotograma.
En cada lnea hay 64 bits de 1 y 0 , se dividi en 16 bloques de 4 bits cada uno, los cuatro primeros
nibbles (cuartetos de bits) corresponden a la capa 1, los siguientes a la capa 2 y asi hasta la
cuatro. Si hay un 1, entonces eso significa que un LED se encendi, si hay un 0, entonces no va a
lucir.
Por ejemplo si tenemos esta lnea:
B1000,B1000,B1000,B1000, B0000,B0000,B0000,B0000, B0000,B0000,B0000,B0000,B0000,B000
0,B0000,B0000, 10,
He separado por colores cada capa, de forma que el color negro corresponde a la capa 1(la
inferior), la rojo a la dos, verde tres y azul la cuarta capa. Bien en las capas 2, 3 y 4 todo est a
cero significa que todos los leds de esas capas estn apagados, sin embargo si observamos la
capa 1 (la inferior) vemos que est encendido el primer led de cada nibble (cuarteto), lo que quiere
decir que lucirn los leds de la fila inferior del fondo. El ltimo valor de la fila indica el tiempo que
permanece la secuencia.

Trata de probar con sus propias animaciones, mi consejo es utilizar los comentarios para darse un
recordatorio de lo que hace cada animacin. Usted puede escribir un comentario en el programa
escribiendo "/ /" y luego el comentario.

En esta web: http://www.robota.nl/en/blog/led-cube-4x4x4-pattern-designer/led-cube-si... puedes
hacerte tus propios patrones de encendido de los leds, con un poco de paciencia e imaginacin,
pueden quedar unos resultados espectaculares, si quieres en los comentarios puedes enviar los
tuyos para que los podamos probar.
Fuentes:
[http://www.techmadeeasy.co.uk/2013/01/21/make-your-own-4x4x4-led-cube-wi...
[http://www.makeuseof.com/tag/how-to-make-a-pulsating-arduino-led-cube-th.
- See more at: http://www.tecnosalva.com/c%C3%B3mo-hacer-cubo-leds-4x4x4-
arduino#sthash.4sKpcJB8.dpuf