Ejemplo 5 - El poder de destruir un planeta no es nada con el poder de Arduino

Bueno, pues tras un (bastante) largo periodo vacacional, volvemos a los tutoriales y a los ejemplos, y una novedad será que por fin se acabaron los tutoriales con los LEDs, al menos por ahora. Vamos a pasar a algo más entretenido, y posiblemente más espectacular.

Vamos a generar música.

Si, habéis leido bien, usando 1Kb de memoria (1024 bytes), y mucho menos de memoria RAM, vamos a hacer que nuestra placa genere música. Al usar un zumbador piezoeléctrico, lo que generemos tendrá un sonido de lo más retro, con lo que tendremos un sonido similar al de la Nintendo Game Boy, o al de las consolas chinas con el Tetris y demás.

Tan solo necesitamos un zumbador piezo eléctricos, dos cables y la placa. La imagen a continuación muestra como quedaría el circuito. (Conectado al pin D8 y al GND de las E/S digitales):

Y el código a ejecutar es el siguiente: http://tny.cz/e525c1b2

¿Que hace que suenen las notas? Como podemos ver, hemos definido las notas, y la duración. luego tenemos una sucesión de lo siguiente varias veces:

  tone(8,LA3,Q); 

Esto nos genera un tono en el pin 8, correspondiente a la nota LA3, y de duración Q. En las definiciones podemos tanto la duración como la frecuencia de la nota.

¿Qué otros ejemplos se pueden llevar a cabo? Por ejemplo, puedes ponerle otro piezo en serie y sonaría en estéreo, o activarle un segundo pin con su correspondiente piezo, y así tener una base y el piezo principal. El límite está en la imaginación.

Y hasta aquí este miniejemplo, la semana que viene volveremos con fuerza. Hasta entonces, que la fuerza os acompañe.

Ejemplo 04 - KITT entra en escena

Buenas y bienvenidos a la entrada habitual de los Lunes. Ya estamos acabando con los ejemplos basados en LEDs, así que iremos empezando a cerrar este capítulo con la creación de un "Escáner Larson", o, dicho de otro modo, las luces de KITT (O los Cylons de Battlestar: Galactica). Usaremos 8 LEDs para recrear dicho efecto, pero para liberar pines en nuestra placa, vamos a usar un micro denominado Shift Register (Desplazador de Registro), que nos permite aumentar el numero de pines digitales de que disponemos de manera que utilizando 3 pines de nuestra placa, obtendremos más de 10 pines extra, y por supuesto, podemos combinar todos los de desplazadores que queramos, con lo que podemos tener un número ilimitado de pines (Desgraciadamente, de memoria seguimos con la EEPROM de 32k).

Desplazador de registro 74HC595N

 Como siempre, empezaremos por el diagrama:

Aquí podemos observar que, tomando los pines D4, D5 y D6, sacamos 8 pines extra que denominaremos D1a, D2a, D3a, D4a, D5a, D6a, D7a y D8a. La entrada de 5V la conectamos directamente al desplazador, y la toma de tierra tanto del breadboard como del desplazador las dirigimos al mismo punto. Pasamos a la lista de materiales que utilizaremos:

Materiales: 8 resistencias de 200k Ω,  cables duPont, placa perforada de prototipado, 2 diodos LED verdes, 2 diodos LED amarillos, 4 diodos LED rojos, Desplazador de registro 74HC565N, Robotale UNO R3.

 Como siempre, empezamos por disponer la protoboard en una superficie plana, firme y con bastante luz, para evitar problemas de visión. (En mi caso suelo acercarme siempre una lámpara).

Uno a uno, vamos poniendo los LEDs sobre la protoboard, respetando la polaridad de cada uno, y de esta forma: Rojo, rojo, amarillo, verde, verde, amarillo, rojo, rojo. (Se realizó así por falta de diodos rojos):

Insertamos el 74HC595N en la breadboard, en el centro, aprovechando el hueco para insertar ICs que nos trae la breadboard. El lado con la hendidura en el centro es el lado por el que empezamos a contar (o dicho de otra forma, el que pondremos siempre mirando hacia arriba):

Poco a poco, vamos insertando las resistencias, con cuidado. Tienen que ir todas conectadas si o si al micro, ya que el micro es el equivalente al polo positivo:

ATENCIÓN: Pase lo que pase, que NINGUNA resistencia entre en contacto con la otra, ya que podemos FREIR EL CIRCUITO DE LA PLACA.

Comenzamos el cableado, conectando los cables amarillos en la breadboard, y dejando los referentes a D4 y D6 sin conectar:

Continuamos con los cables naranjas, dejando así los LEDs conectados al Desplazador, y el D5 libre:

 Conectamos los cables azules, referentes a la toma de tierra del Desplazador de Registros (usa dos tomas de tierra, una para el desplazador y otra para el resto del circuito):

Conectamos el cable blanco:

Y finalmente conectamos la salida de tierra y el de 5V en la breadboard:

Guiándonos del diagrama de Fritzing, conectamos los pines en la placa, como corresponde:

  Y entonces cargamos el Sketch, que podemos tanto descargarlo AQUI, como copiarlo:

int clockPin = 6; //D6
int dataPin = 4; //D4
int latchPin = 5; //D5

byte patterns[40] = {
B00000000, 100,
B00000001, 100,
B00000011, 100,
B00000110, 100,
B00001100, 100,
B00011000, 100,
B00110000, 100,
B01100000, 100,
B11000000, 100,
B10000000, 100,
B00000000, 100,
B11000000, 100,
B01100000, 100,
B00110000, 100,
B00011000, 100,
B00001100, 100,
B00000110, 100,
B00000011, 100,
B00000001, 100,
B00000000, 100,
};

int index = 0;
int count = sizeof(patterns) / 2;

void setup() {
pinMode(latchPin, OUTPUT);
pinMode(clockPin, OUTPUT);
pinMode(dataPin, OUTPUT);
}

void loop() {
digitalWrite(latchPin, LOW);
shiftOut(dataPin, clockPin, MSBFIRST, patterns[index * 2]);
digitalWrite(latchPin, HIGH);

delay(patterns[(index * 2) + 1]);

index++;
if (index >= count){
index = 0;
}
}

¿Cómo funciona el código? Lo primero que hace es identificar los 3 pines referentes al Desplazador, y acto seguido lee la progresión de los LEDs a la hora de encenderse. Luego activa los 3 pines del Desplazador como pines de salida, y luego con la instrucción shiftOut va desplazandose, de forma que va activando los pines que necesitamos sin tener los 8 pines ocupados, aliviandonos un poco el número de pines que utilizamos. El código por supuesto se puede simplificar más, por ejemplo, creando un bucle For para controlar las luces.

El vídeo no he podido tenerlo a tiempo para complementar la entrada, aunque mañana sin falta estará aquí subido el video.

La semana que viene continuaremos cerrando el capitulo referido a los LEDs, hasta entonces, no dejeis de revisar el blog.

Miércoles especial - Limpiando la memoria EEPROM

Buenas, al final, la entrada de los miércoles será algo esporádico, dónde explicaré algún asunto en especial, o comentaré algo. Para inaugurarla, hablaré de una función que si bien es algo inútil, puede librarnos de más de un apuro a la hora de cambiar el proyecto a realizar. Me refiero a limpiar la EEPROM, la memoria de la placa.

Las placas Arduino, así como las basadas en estas mismas, tienen una memoria muy básica, solo 1 Kilobyte (1024 bytes de capacidad solamente), con lo que los programas deben ser lo más optimizados posible. Además, si vamos cambiando de proyecto a proyecto con frecuencia, como suelo hacer en este blog, puede ocurrir que nos dejemos un programa cargado en la memoria, y al conectar, en un pin en el que tuviesemos una resistencia no la tengamos, y friamos el led conectado. Así que será lo recomendable usar el sketch de borrar la EEPROM. Este sketch viene integrado en el IDE de Arduino, así que no será necesario copiarlo. Simplemente seguíd las instrucciones de la imagen:

Archivo > Ejemplos > EEPROM > eeprom_clear, y le damos a "Cargar".

¿Cómo funciona este Sketch? Símplemente escribe toda la EEPROM, llenándola de 0s, y para acabar enciende el led correspondiente al D13 cuando se ha completado con éxito.

Y hasta aquí la entrada del Miércoles. Nos vemos el Lunes con otro ejemplo práctico.

Ejemplo 03 - Semáforo

Buenas a todos. En primer lugar, disculparme por no haber hecho la entrada del miércoles. Dicha entrada no pude realizarla por falta de material de nivel básico para hablar de las resistencias. En su lugar, habrá entrada doble. Dicho esto, comenzamos.

En el ejemplo de hoy, crearemos un semáforo doble, para peatones y coches, que tendrá a su vez un interruptor que activará el semáforo de los peatones y, al paso de unos segundos, activará el de coches de nuevo. Pasamos a la lista de materiales que usaremos:

Materiales: 5 resistencias de 200k Ω, 1 resistencia de 10k Ω, 10 cables duPont, placa perforada de prototipado, 2 diodos led verdes, 2 diodos led rojos, 1 diodo led ámbar, Robotale UNO R3.

Como novedad, incluiremos un esquema a partir de ahora, realizado en Fritzing, de como debería quedar (más o menos) nuestro proyecto una vez terminado. El resultado debería ser el siguiente:

Usaremos los pines 5V y GND para dar corriente a toda la placa, y luego los pines del D8 al D12 para los leds, y el D2 para el interruptor.

Empezamos el montaje, por los leds, recordando en todo momento la polaridad de los mismos para no liarla a la hora de encenderlo. Los organizamos tal que así, dejando un amplio espacio entre los leds correspondientes al semáforo de coches, y entre los leds del semáforo de peatones, ya que ahí colocaremos más adelante el interruptor:

 El siguiente paso será el de colocar las resistencias de 200k Ω en el polo negativo de los leds, como muestra la fotografía siguiente (Tened cuidado con las patillas de las resistencias, son muy maleables y es posible que se rompan con facilidad):

Seguidamente, agregamos el interruptor, colocándolo como muestra la fotografía en el hueco que le hemos dejado en la placa. Dejamos un poco más de hueco a la derecha, para...

...hacele hueco a la resistencia de 10k Ω que usaremos para evitar freir el interruptor.  Lo ponemos en el pin correspondiente al polo negativo. (Las resistencias siempre las pondremos en el polo negativo)

Ahora, conectamos dos cables DuPont, que irán del polo positivo del interruptor al positivo de la placa, y del negativo de la resistencia al negativo de la placa. Para diferenciar los cables sin problema alguno, usaremos cables naranjas para la corriente del interruptor.

Conectamos un cable DuPont amarillo en el pin D2 de nuestro Arduino UNO/Robotale UNO. Este es el cable que usaremos para leer la señal del interruptor. Solo ponemos un extremo, por ahora.

Acto seguido, conectamos a los pines D8 y D9 dos cables (En este caso, azules), que usaremos para controlar los leds del semáforo de peatones. igual que el anterior, no lo conectamos a los leds aún.

Y conectamos los DuPont blancos a los pines D10, D11 y D12, que corresponden al semáforo de coches.

Conectamos los cables de nuestra Robotale donde corresponde en la placa de prototipado. Comprobamos que ambas terminaciones (Robotale y placa) estan bien situadas, y pasamos al siguiente punto.

 

 Conectamos un cable rojo al pin 5V, y uno negro al GND justo debajo, y estos los ponemos donde están + y - en la placa de prototipado. Así nos aseguramos de alimentar el interruptor y de tener un circuito de corriente siempre circulando por la placa, en el caso de que sea necesario, así como una toma de tierra para proteger tanto los leds como las resistencias.

Continuamos por arrancar nuestro IDE y cargamos el sketch a descargar AQUI, o bien escribimos el código:

/*
  Ejemplo de semáforo de coches con módulo de peatones
 
  Este ejemplo, correspondiente al Ejercicio 3, simula un semáforo para coches,
  con un módulo para peatones que se activa pulsando el botón.
 
  Necesario:
  2 LEDs rojos
  2 LEDs verdes
  1 LED ámbar
  1 Interruptor
  5 resistencias de 220k
  1 resistencia de 10k
  10 cables DuPont
 
 */

//Creamos una variable global que mantendrá la información
//sobre como está el interruptor, esta variable será 
//persistente durante todo el programa. Al interruptor le
//hemos asignado el pin D2, usando del D8 al D12 para los LEDs
int cRoj= 12;                  
int cAmb = 11;                 
int cVer = 10;                 
int pRoj = 9;                   
int pVer = 8;                 
int pBtn = 2;                   
int var = 0;                       

//Especificamos que los pines asignados a los diodos sean de salida, y
//El pin asignado al boton de entrada.
void setup() {                     
  pinMode(pRoj, OUTPUT);        
  pinMode(pVer, OUTPUT);      
  pinMode(cRoj, OUTPUT);        
  pinMode(cAmb, OUTPUT);       
  pinMode(cVer, OUTPUT);      
  pinMode(pBtn, INPUT);      
}

// Al iniciar el programa, está la luz para peatones en rojo, y la de coches en verde,
//así como la variable del interruptor en 0, pero a la espera de cambiar a HIGH en función
//de la lectura que de el pin D2, la cual se detecta mediante la función "digitalRead"
void loop(){                  
  digitalWrite (pRoj, HIGH);    
  digitalWrite (cVer, HIGH);
  var = digitalRead(pBtn);   

//Una vez detecta que el pulsador ha sido utilizado, comienza la secuencia del semáforo, cambiando
//entre los colores durante 3 segundos, hasta encender la luz roja para coches y la verde para peatones,
//que se mantiene durante 10 segundos. Luego, enciende la luz de peatones roja, la apaga, reiniciando
//la secuencia inicial desde 0.
  if (var == HIGH) {               
    delay(2000);                   
    digitalWrite(cVer, LOW); 
    digitalWrite(cAmb, HIGH); 
    delay(3000);                  
    digitalWrite(cAmb, LOW);  
    digitalWrite(cRoj, HIGH);  
    delay(3000);                   
    digitalWrite(pVer, HIGH); 
    digitalWrite(pRoj, LOW);   
    delay(10000);          
    digitalWrite(pVer, LOW); 
    digitalWrite(pRoj, HIGH);   
    delay(3000);
    digitalWrite(cRoj, LOW);  
  }                    
}

 
 ¿Cómo funciona el código? Al iniciarse, tanto la luz verde de coches, como la roja de peatones están encendidas siempre, esperando la entrada del interruptor que, una vez pulsado, inicia una secuencia que apaga la luz verde de coches y enciende la ámbar de coches, a los 3 segundos apaga esta y enciende la roja de coches, a los 3 segundos apaga la roja de peatones, enciendiendo la verde de peatones durante 10 segundos, y luego apaga esta, volviendo a la luz roja de peatones, y a los 3 segundos apaga la roja de coches, encendiendo de nuevo la verde de coches. En el video a continuación se puede comprobar mejor.

https://www.youtube.com/watch?v=ZVMj4XG3DSc (A la espera de que se pueda enlazar correctamente)

Y con esto terminamos el capítulo de hoy. La semana que viene subiremos el listón para celebrar la entrada 5ª del blog y 4ª de tutoriales con un ejemplo apto para nostálgicos.

Atención: En la conexión del interruptor, hay un error de instalación. Si se coloca como especifican las fotografías de los ejemplos no funcionará. Se recomienda instalarlo como en la fotografía a continuación, para asegurarse de que funciona correctamente:

o

Ejemplo 02 - Led Externo

En el ejemplo de hoy, vamos a realizar un sketch y prototipo similar al del primer ejercicio, solo que esta vez usaremos un pin diferente al 13, con lo que tendremos que usar la llamada placa de prototipado, así como un diodo LED y una resistencia.

Aquí se pueden ver los componentes: Placa, cable DuPont, LED Verde, resistencia y Arduino

Como resistencia, me he decantado por una de 220 Ω, para ir sobre seguro. Las resistencias son neutras de por sí, con lo cual no tienen polaridad definida (es decir,  pueden poner tanto en el polo positivo como en el negativo)

El diodo LED irá conectado a la resistencia, dado que el voltaje entregado por la placa puede ser fatal para el diodo, fundiéndolo.

Bueno, pasamos al montaje. Disponemos la placa de montaje y nuestra Arduino como la fotografía a continuación:

Seguidamente, procedemos a conectar ambos cables de corriente. Donde estan los 8 pines del grupo "POWER", insertamos el cable negro en el GND que está justo al lado del pin de 5V, y el rojo en el pin D12 (Grupo Digital, Pin 12) . No conectamos en el pin 5V, ya que si no, no podríamos controlar si encendemos o apagamos el LED:

Insertamos el diodo LED como podemos comprobar en la imagen. (IMPORTANTE: Los diodos LED tienen polos positivo y negativo, siendo el negativo (Cátodo) la patilla más corta, o la que está situada en el lado plano):

Una vez conectado el LED, conectamos la resistencia como podemos comprobar:

 Cuando hayamos terminado de montar la placa tal y como muestra la imagen, abrimos el IDE Arduino, y cargamos el ejemplo descargado, o copiamos el código siguiente.


/*
LED Externo

 Ejemplo de como encender un LED conectado al pin D12 de Arduino
 y hacer a este parpadear.

 Este ejemplo ha sido extraido de adafruit.com

 */

// El pin 13 suele tener conectado un diodo LED en la mayoría de las placas, de manera
// que veríamos ambos diodos (el integrado y el conectado) encenderse.
// Con lo cual, moveremos el pin asignado al D12, para no interferir entre los diodos.
// con la siguiente instrucción al pin D12 le damos el nombre "ledext", y al
// pin D13 el nombre "ledext":
int ledext = 12;
int ledint = 13;

// La rutina Setup se inicia cada vez que se utiliza el botón RESET o encendemos la placa:
void setup() {               
  // inicia el pin digital como salida.
  pinMode(ledext, OUTPUT);
  pinMode(ledint, OUTPUT); 
}

// La rutina loop controla que el proceso se repita una y otra y otra vez:
void loop() {
  digitalWrite(ledint, LOW);   // Enciende el LED del pin 13 (HIGH se corresponde con el voltaje)
  digitalWrite(ledext, HIGH);   // Enciende el LED del pin 12 (HIGH se corresponde con el voltaje)
  delay(500);               // Espera medio segundo
  digitalWrite(ledext, LOW);    // Apaga el LED del pin 12 ajustando el voltaje a LOW
  delay(500);               // Espera medio segundo
}

//(c) 2014 Bicheando con Arduino

¿Qué hace el Sketch? En resumidas cuentas, lo primero que hace es asignarles a los pines D12 y D13 un nombre, la rutina setup los inicia como salida, y la rutina loop controla que se quede apagado D13, y D12 se encienda y apague cada medio segundo, como podemos ver en el video siguiente:

Y eso es todo por hoy, el Miércoles nos vemos con la primera entrega de teoría, y el Lunes que viene, tendremos el primer ejercicio bastante más complicado, cuando añadamos un interruptor, varios LEDs, y construyamos un ejemplo de Semáforo de competición tipo Formula 1. Hasta entonces, seguid practicando.

Modificación del Miércoles

Debido a falta de tiempo para aprender su funcionamiento, la entrada sobre el USB Host se pospone hasta más adelante, con lo que el Miércoles tendremos una entrada sobre teoría, exáctamente sobre las resistencias.

Especial el Miercoles 6 y actualización.

Me han cedido un Shield USB Host, así el Miércoles 6 haré una entrada especial de review de este host, pero el Lunes habrá tutorial. Me estoy planteando los Miércoles hacer una minientrada de teoría de electrónica (cosa para la que me apoyaré con Internet), o algun tutorial o algo relacionado con Arduino, o dedicarle uno o dos Miércoles a Fritzing. Ya más adelante, si tengo suerte y me hago con una impresora láser, en ese caso habría tutoriales sobre PCBs a medidas y soldaduras (aunque de soldaduras tengo que aprender demasiado.