Y me quedé maravillado de lo que vi, unas asombrosas “plantillas” para descarga gratuita en PDF con esquemáticos y ejemplos de conexiones básicas que podemos hacer con nuestros Arduinos, ya sea desde conectar un simple potenciómetro, unos leds, motores, displays LCD, un micrófono, servomotor, pasando por conexión de un Triac a un Arduino para control de una bombilla a 220VAC, etc.

Este último ejemplo:

Todo muy genérico y diseñado de forma divertida, con explicaciones y dibujos, que vale tener a mano siempre que trabajemos con Arduino, ya que serán la gran mayoría de circuitos que utilizaremos a la hora de realizar nuestros proyectos DIY

Por tanto, aquí quiero dejar dicha web que además dispone de diferentes esquemáticos electrónicos, y otros archivos PDF con el Pinout de los microcontroladores de ATMEL, de las diferentes versiones de Arduino, además de proyectos, herramientas para cálculos electrónicos, etc, todo para descargar gratuitamente desde la web en formato PDF o bien podemos acceder a versiones modificables realizando una pequeña donación.

Otro ejemplo de dichos Pinouts:

WEB: PIGHIXXX

Aquí hay un extracto:

Unos 55,000 turistas visitan a Liechtenstein cada año. Este blog ha sido visto cerca de 210.000 veces en 2012. Si fuera Liechtenstein, se necesitarían alrededor de 4 años para que todos lo vean. Tu blog tuvo más visitas que un pequeño país en Europa!

¡Muchas gracias a todos y Feliz año 2013!

Haz click para ver el reporte completo.

y un Próspero Año 2013

¡Que el próximo año nos traiga a todos salud y muuuchos proyectos electrónicos!

El objeto del proyecto es el diseño de un sistema μControlado de alarmas con reloj a tiempo real, pantalla para visualización de datos y actuadores para configuración.

Un sistema automático definido de forma que permita la configuración de la fecha y la hora, así como diferentes alarmas a diferentes horas del día, efectuando cambios en la configuración del sistema a través de pulsadores, obteniendo una representación visual de los datos en el módulo LCD instalado.

El sistema podrá ser configurado para la actuación sobre una sirena externa automáticamente o permitirá la acción manual sobre dicha sirena.

Antes de empezar, lo que haremos será elegir los elementos con los que vamos a realizar el proyecto, ya que es un proyecto muy versátil y existen muchas combinaciones de elementos que darían lugar al mismo resultado final.

Este es un proyecto bastante sencillo de realizar para el cuál se necesitan conocimientos de Arduino y su programación y nociones de electrónica analógica.

Vamos al lío, sigue leyendo! 

Como he dicho antes, existen muchas maneras de realizar este proyecto, yo personalmente me decidí por utilizar los siguientes componentes principales:

- μControlador ATmega328P: Es el microcontrolador que poseen las placas Arduino UNO y nos permite programarlo mientras está insertado en la placa de Arduino y luego retirarlo y colocarlo en cualquier otra placa que hayamos diseñado. Funcionará como controlador principal del proyecto ya que será el encargado de procesar y manejar el reloj a tiempo real, la pantalla LCD, y actuar sobre el relé que activará la sirena.

- RTC DS1307: Una forma económica de obtener una base de tiempo con un microcontrolador, es un reloj a tiempo real. El RTC DS1307 es económico, muy sencillo de utilizar y tan solo nos ocupará el puerto I2C de nuestro microcontrolador, por tanto, solo 2 pines.

- Sirena 220V AC: Esta sirena (Modelo E2S A105N) donación de @CuninganLostPwd (Gracias!) y es ideal para el proyecto, puesto que al ser de 220V AC nos permite tener que mezclar en el proyecto corriente continua para la alimentación de la placa y los componentes, y corriente alterna para la alimentación de la sirena.

- Relé 5V 8A: Para activar la alarma usaré un dispositivo electromecánico, un relé, que conmutará para encender o apagar la sirena.

- Display LCD 16×2: De los modulos visualizadores para trabajar con Arduino, los displays LCD 16×2, son económicos y muy simples de utilizar gracias a las librerías de Arduino.

Teniendo los componentes principales elegidos, pasamos al diseño del proyecto, es decir, esquemas electrónicos y conexiones.

Salvo que vayamos a utilizar un transformador comercial de los de tipo “cargador de móvil” debemos buscar una manera de transformar y reducir los  220V corriente alterna que tenemos en casa, a 5V corriente continua para poder alimentar nuestro circuito, debido a que tanto el ATmega328, el RTC DS1307 como el relé, trabajarán a esta pequeña tensión, así que manos a la obra.

Rebuscando en casa, encontré un pequeño transformador de 220V – 9V, pero esto nos dará 9V en corriente alterna, por lo que habrá que rectificar, rizar y regular la señal alterna hasta conseguir una señal de 5V corriente continua:

El esquema que he utilizado es el siguiente:

El transformador conectado en “J3″ nos dará 9V en corriente alterna mientras que el puente de diodos rectificará dicha corriente alterna hasta obtener una señal pulsatoria de 7,6V aproximadamente puesto que tendrá una caída de tensión de 1,4V.  El condensador C1 se encargará de rizar la señal mientras que el regulador de tensión LM7805 regulará la tensión de los 7,6V a 5Vcc. De este modo obtenemos una fuente de alimentación de 5Vcc. El diodo D2, está colocado para proteger al regulador de tensión.

Con la alimentación, pasamos a diseñar el circuito que controlará todo el proyecto, yo personalmente siempre realizo los circuitos en una protoboard y una vez comprobado que todo está correctamente y funciona, paso al diseño del esquema electrónico y posterior placa de circuito impreso.

Proyecto montado en protoboard para su programación y verificación de funcionamiento.

Veamos mi esquema una vez terminado. El esquema es todo uno entero, solo que lo he dividido en bloques que realizarán cada uno su “parte” del proyecto.

Esquema electrónico dividido en bloques

Bloque 1: El μControlador ATmega328 será el encargado de controlar todo el proyecto, y como todo μControlador necesita de un cristal de cuarzo con sus correspondientes condensadores. En este caso el Atmega328 funcionará a 16Mhz . Así mismo, tendremos que alimentarlo, de modo que conectamos los 5Vcc y GND obtenidos de la fuente diseñada anteriormente a los pines correspondientes (Siempre comprobar el pinout del circuito integrado en su Datasheet para asegurarnos de no conectar los pines equivocados). También es conveniente colocar un condensador entre los pines de VCC y GND del circuito integrado que funcionen a modo de filtro, en el esquema serían C6 y C7.

Bloque 2: Este bloque corresponde a la botonera del proyecto que utilizaremos para configurar la hora, alarmas y “movernos” por los menús del proyecto que podremos visualizar en la pantalla LCD. En mi caso he utilizado 5 pulsadores normalmente abiertos, cada uno con su resistencia Pull-down necesaria para evitar valores aleatorios al leer el pin de cada pulsador, de modo al presionar el pulsador obtengamos una señal lógica HIGH (5V) en el pin donde esté conectado. Este bloque va a discreción de cada uno tanto los pines de conexión de cada pulsador así como la cantidad de pulsadores.

Bloque 3: Opcionalmente podemos añadir este pequeño bloque, al igual que la gran mayoría de productos electrónicos, yo he añadido un led conectado a los 5Vcc de la fuente de alimentación, que indique de modo visual que la fuente de alimentación esté encendida. Calculamos la resistencia para evitar quemar el led aplicando la ley de Ohm: R = V/I = 5Vcc/0,020 mA = 250 Ω. Un valor estándar sería  270 Ω.

Bloque 4: El RTC DS1307 podemos comprarlo en muchas tiendas electrónicas montado en una pequeña plaquita listo para conectar, en mi caso, compré todas sus partes por separado para poder integrarlas en la placa de circuito del proyecto. El pequeño circuito integrado de 8 pines necesita de un cristal de cuarzo de 32.768 Khz, así como alimentación 5Vcc y GND que obtendremos de la fuente. Utiliza el bus I2C para comunicarse con un μControlador, por tanto los pines SDA y SCL del DS1307 los conectaremos al bus I2C de nuestro μControlador. Por último, para evitar perder la hora y fecha programadas al cortar el suministro eléctrico, se conecta una pequeña pila de botón tipo CR2032 de 3V el pin correspondiente (Comprobar siempre el datasheet).

Bloque 5: Siempre digo que los LCD son de los elementos que no deben faltar en un proyecto electrónico. El bloque 5 corresponde al esquema de conexión de un display LCD 16×2 con el μControlador. Esto es opcional y los pines de conexión pueden variar a elección de cada uno puesto que los podremos configurar posteriormente en el código.

Bloque 6: Este bloque es de los más importantes del circuito, ya que nos permitirá encender o apagar la sirena cuyo funcionamiento es a 220V de corriente alterna, con tan solo una pequeña señal de 5V de corriente continua enviada desde el μControlador. Para esto utilizamos un relé.

¿Pero… qué es un relé?
Un relé es un dispositivo electromecánico que funciona a modo de interruptor.
Para entender el funcionamiento de un relé, una imagen vale más que mil palabras.
En la Wikipedia vemos el siguiente gif:

Funcionamiento de un relé

El relé está formado por un electroimán, un núcleo de hierro dulce rodeado de una bobina de hilo de cobre (Cilindro amarillo en la izquierda del gif) que al ser atravesada por una corriente eléctrica creará un campo magnético que magnetizará dicho núcleo de hierro, atrayendo un “inducido” de hierro (Pieza con forma de L que se ve en el gif) que a su vez accionará uno o varios contactos libres de potencial (Los 3 “palitos” amarillos de la derecha) para abrir o cerrar un circuito independiente conectado a estos contactos.

Los contactos del relé por la posición en la que se encuentran cuando está en reposo serán:

- Contacto normalmente cerrado: El “palito amarillo” de más a la izquierda.
- Contacto común: El “palito amarillo” del centro.
- Contacto normalmente abierto: El “palito amarillo” de la derecha.

De modo que con una pequeña señal, en mi caso 5Vcc procedente de uno de los pines digitales ATmega328, podemos cerrar el circuito de alimentación de la sirena que funcionará a 220V AC.

Conectamos uno de los polos de tensión 220V AC al contacto común del relé y el otro polo de tensión lo conectaremos a uno de los hilos de alimentación de la sirena.

SIEMPRE DESCONECTADOS DE LA CORRIENTE, NUNCA TOCAREMOS LOS CABLES DE TENSIÓN ESTANDO ESTOS CONECTADOS A LA PARED, ESTAMOS HABLANDO DE 220v DE CORRIENTE ALTERNA Y ES PELIGROSO. REALIZAR ESTE PASO BAJO LA SUPERVISION DE ALGÚN PROFESIONAL CUALIFICADO O CON LA PROTECCIÓN ADECUADA. 

Al contacto normalmente abierto del relé conectaremos el hilo de alimentación restante de la sirena, de modo que al accionar el relé, el contacto común cierre el circuito con el contacto normalmente abierto, permitiendo que la sirena quede alimentada a 220V y comience a funcionar.

Para terminar de analizar el bloque 6, vemos que no podemos conectar directamente el relé a los pines de un μControlador directamente, ya que estos no proporcionan la corriente suficiente para poder excitar el bobinado del relé, por lo que tendremos que hacerlo a través de un transistor.

En mi caso, como se ve en el esquema utilicé un transistor NPN 2N3904 el cuál tendrá su base conectada al pin digital del ATmega328, con la resistencia adecuada previamente calculada (R1) mediante la ley de Ohm para obtener la corriente necesaria para asegurar la saturación del transistor. Conectaremos el emisor del transistor a masa/GND y el colector irá conectado ánodo de un diodo y a uno de los pines del bobinado del relé. El cátodo del diodo lo conectaremos tanto a 5Vcc como al pin restante del relé.  

Así, al aplicar corriente a la base del transistor, este entrará en estado de saturación, permitiendo el paso de corriente entre colector y emisor, corriente que previamente atravesará la bobina del relé, activándolo. El diodo protegerá la bobina del relé de un cortocircuito.

Con eso, terminamos el “análisis” del circuito del proyecto.

- – - – - – - – - – - – - – - – - – - – - – - – - – - – - – - – - – - – - – - – - – - – - – - – -

El siguiente paso será diseñar PCB  en algún software de diseño electrónico y para cuya realización puedo proponer él método casero de realización de placas de circuito impreso a la plancha. Esto a elección de cada uno, yo utilicé el OrCAD y realicé la placa de forma casera obteniendo los siguientes resultados:

Fotolito adherido al cobre mediante el método de la plancha.	PCB previamente atacada con ácido y lista para agujerear.
PCB montada y lista para conectar y probar.	Proyecto montado listo para programar y usar.

Una vez montado y comprobado que todo funciona correctamente, el paso final será programar el ATmega328.
Este paso es “personal”, cada uno puede programar el ATmega para funcionar del modo que le parezca mejor o más efectivo.

Por esta razón, no voy a colgar todo el código de mi proyecto, sino que haré al igual que el esquema, una serie de bloques de código de algunas partes importantes del funcionamiento del proyecto:

- Visualización de la hora y fecha del RTC DS1307 en el LCD: 

#include <LiquidCrystal.h> // Libreria para control del LCD
#include <DS1307.h>        // Libreria del reloj DS1307
#include <Wire.h>          // Libreria de comunicacion I2C

LiquidCrystal lcd(12, 7, 11, 10, 9, 8);  // Declaracion de los pines del LCD</pre>

#define botonUno 2
#define botonDos 3
#define botonTres 4
#define botonCuatro 5

char fechaActual[20], horaActual[20]; //Variable para formateo de fecha y hora
int RTCValues[7];                     //Variable para el almacenaje de fecha y hora

void setup()
{
for(int a = 2; a <=5; a++) pinMode(a,INPUT); //Declaramos los botones como entradas
  lcd.begin(16, 2); // Iniciamos LCD 16 caracteres x 2 filas
  DS1307.begin();   // Iniciamos el Reloj
}

void loop()
{
    mostrarHora(); // Mostramos hora y fecha en el LCD
}

void mostrarHora()
{
 do{

     DS1307.getDate(RTCValues);                          // Obtenemos la hora y fecha

     sprintf(horaActual, "%02d:%02d:%02d", RTCValues[4], // La formateamos
             RTCValues[5], RTCValues[6]);

     sprintf(fechaActual,"%02d-%02d-%02d", RTCValues[2],
	     RTCValues[1], RTCValues[0]);

     lcd.setCursor(4, 0); lcd.print(horaActual);     // Y mostramos por pantalla
     lcd.setCursor(0, 1); lcd.print(diaSemana(RTCValues[3]));
     lcd.setCursor(8, 1); lcd.print(fechaActual);

  } while(digitalRead(botonCuatro) != HIGH);         // Hasta que se pulse el boton 4
}

- Activación manual de la alarma:

#include <LiquidCrystal.h> // Libreria para control del LCD

#define rele A3 // Definicion de pines de pulsadores y rele
#define botonUno 2
#define botonDos 3
#define botonTres 4
#define botonCuatro 5

LiquidCrystal lcd(12, 7, 11, 10, 9, 8); // Declaracion de los pines del LCD

byte estado = 0, ultimoestado = 0; // Variables para el control de los pulsadores

void setup()
{
 lcd.begin(16, 2); // Iniciamos LCD 16 caracteres x 2 filas

for (int a = 2; a <=5; a++) pinMode(a, INPUT); // Declaramos los pines de salida
 pinMode(rele, OUTPUT);
}

void loop()
{
 estado = digitalRead(botonTres);
 if (estado != ultimoestado && estado==HIGH) activacionManual();
 ultimoestado = estado;
}

void activacionManual()
{
 lcd.setCursor(3, 0); lcd.print("Activacion"); // Mostramos el texto de activacion manual
 lcd.setCursor(5, 1); lcd.print("manual");

// Pulsando el boton 3 exitamos la base del transistor
// que encenderá el relé y hará sonar la alarma

 do{
 digitalWrite(rele, HIGH);               // Saturamos el transistor
 }while(digitalRead(botonTres) == HIGH); // mientras el botón 3 esté pulsado.

 digitalWrite(rele, LOW); //"Apagamos" el relé al soltar el botón 3
}

- Creación y visualización de 3 menús accesibles por pulsador:

#include <LiquidCrystal.h> // Libreria para control del LCD

#define rele A3 // Definicion de pines de pulsadores y rele
#define botonUno 2
#define botonDos 3
#define botonTres 4
#define botonCuatro 5

LiquidCrystal lcd(12, 7, 11, 10, 9, 8); // Declaracion de los pines del LCD

byte estado = 0, ultimoestado = 0; // Variables para el control de los pulsadores
byte seleccion = 0;

#define borraLCD lcd.clear(); // Define de la funcion clear() del LCD

void setup()
{
lcd.begin(16, 2); // Iniciamos LCD 16 caracteres x 2 filas

for (int a = 2; a <=5; a++) pinMode(a, INPUT); // Declaramos los pines de salida
pinMode(rele, OUTPUT);
}

void loop()
{
menuPrincipal(); // Mostramos el menu principal y esperamos seleccion
}
void menuPrincipal()
{

lcd.setCursor(0, 0); lcd.print("1- Hora/Fecha"); //Mostramos el menu en el LCD.
lcd.setCursor(0, 1); lcd.print("2- Alarmas");
lcd.setCursor(12, 1); lcd.print("3-");

// Leemos constantemente los botones, si alguno es pulsado, cambia el valor de "seleccion"
 // que después hará la llamará a la función asignada a dicho valor.

estado = digitalRead(botonUno);
if (estado != ultimoestado && estado==HIGH) seleccion = 1;
ultimoestado = estado;

estado = digitalRead(botonDos);
if (estado != ultimoestado && estado==HIGH) seleccion = 2;
ultimoestado = estado;

estado = digitalRead(botonTres);
if (estado != ultimoestado && estado==HIGH) seleccion = 3;
ultimoestado = estado;

estado = digitalRead(botonCuatro);
if (estado != ultimoestado && estado==HIGH) seleccion = 4;
ultimoestado = estado;

switch(seleccion) // Dependiendo del boton pulsado, realizamos una accion u otra.
{
case 1: borraLCD;
menuUno(); // BOTON 1 --> Menu 1
borraLCD;
break;

case 2: borraLCD;
menuDos(); // BOTON 2 --> Menu 2
borraLCD;
break;

case 3: borraLCD;
menuTres(); // BOTON 3 --> Menú 3
borraLCD;
break;

case 4: menuPrincipal(); // BOTON 4 --> Vuelve al menú principal
break;
}
}

void menuUno()
{
do{

// Código de las acciones del menú Uno.

}while(digitalRead(botonCuatro) != HIGH);
}

void menDos()
{
do{

// Código de las acciones del menú Dos.

}while(digitalRead(botonCuatro) != HIGH);
}

void menuTres()
{
do{

// Código de las acciones del menú Tres.

}while(digitalRead(botonCuatro) != HIGH);
}

Estos son códigos generales, están puestos para utilizar de forma individual cada bloque, pero combinándolos entre todos yo obtuve el código final del proyecto.

Y ya por último… un vídeo de funcionamiento!

Los ATtiny son pequeños µControladores de 8 bits con poca memoria flash y EEPROM, limitados en comunicaciones y encapsulados que van desde los 6 pines el más pequeño hasta los 32 pines el más grande, lo que los convierte en los cerebritos ideales para pequeños proyectos de pocas características y cuyo objetivo sea ser de bajo coste y pequeño tamaño.

Podemos ver toda la gama de ATtinys en la web oficial: ATmel tinyAVR

Pero para poder utilizarlos, necesitaremos de una forma de poder programarlos.
Tenemos dos opciones:
- Comprar un programador ISP y programarlos mediante el software AVR Studio.
- Convertir un Arduino en programador ISP (In-System Programmer).

Esta última opción, es la que voy a intentar explicar paso a paso para poder programar uno de estos pequeños mediante una placa Arduino.

Antes de ver como programar un ATtiny con un Arduino, debemos conocer en qué vamos a convertir el Arduino, es decir, el programador ISP y el método de programación ”In-System Programming”.

Un poco de historia
Este método ISP utilizado por Atmel para la programación de los dispositivos AVR se diseñó para poder programar los µControladores y demás dispositivos programables una vez instalados en un sistema completo, es decir, poder programar los chips sin la necesidad de tener que retirarlos de la placa de circuito donde se encuentren.

La ventaja de este sistema, es que permite a los fabricantes, poder integrar el proceso de instalación y programación en una misma fase dentro de la producción de dispositivos, en lugar de necesitar una etapa de programación de los circuitos integrados antes de la instalación en las placas.

Esto ahorra muchos costes ya que permite a los desarrolladores tanto programar los circuitos integrados en lugar de tener que comprarlos pre-programados por otras partes, como realizar cambios en el código durante la fase de producción.

¿Cómo funciona?
El método “In-System Programming” utiliza el protocolo de comunicación SPI “Serial Peripheral Interface”.

Este bus SPI (Explicado en este post anteriormente) consiste en 3 líneas de datos:
- Serial Clock (SCK)
- MasterIn-SlaveOut (MISO)
- MasterOut-SlaveIn (MOSI)

Al programar un dispositivo AVR, el programador funcionará como dispositivo “maestro” y el circuito integrado a programar, como dispositivo “esclavo”, por lo que en nuestro caso, el Arduino será el “maestro” y el ATtiny será el “esclavo” .

El programador ISP (Nuestro Arduino) provee una señal de reloj a través de la linea SCK. En cada pulso de reloj, se transmite un bit de comunicación desde el maestro al esclavo, a través de la línea MOSI y simultáneamente en cada pulso de reloj, se transmite un bit de comunicación desde el esclavo al maestro, a través de la línea MISO. De este modo se realiza la comunicación.

En el siguiente esquema podemos ver las distintas partes del sistema:

Donde el “PC 9-PIN Serial Port” se corresponde al puerto serie del PC (USB en nuestro caso) conectado al “In-System Programmer” que será nuestra placa Arduino y conectado a este último el “Target AVR MCU” que corresponderá al microcontrolador que queramos programar, en nuestro caso, el ATtiny.

Como se ve en el esquema, programador y programado, deben tener masa común.

En este documento AVR910: In-System Programming, se explica detalladamente todo el método de programación ISP así como el protocolo de comunicación SPI y un esquema electrónico para la realización de un programador ISP de bajo coste.

Convertir un Arduino en programador ISP
Podríamos realizar el programador ISP de bajo coste que viene en el PDF del link anterior, pero pudiendo convertir el Arduino en un programador ISP, todo eso que nos ahorramos.

Vamos por pasos:

1.- Para empezar, vamos a realizar un pequeño esquema para poder visualizar el estado del programador ISP, añadimos 3 leds con sus respectivas resistencias (220 Ω/270 Ω) a los pines digitales 7, 8 y 9.

2.- Acto seguido, debemos descargar los archivos correspondientes a los “núcleos” de los microcontroladores ATtiny para poder trabajar con Arduino. Procedemos a descargar estos archivos desde el siguiente repositorio: Arduino-tiny.

Descargado, descomprimimos, y tendremos dos carpetas llamadas “tiny” y “tools”.
Dentro de la carpeta por defecto que Arduino establece para los sketchs, (en Windows suele ser Mis Documentos>Arduino) crearemos una carpeta llamada “hardware”, y dentro de esta carpeta, colocaremos las carpetas “tiny” y “tools”, de modo que las rutas queden así:
- Mis Documentos>Arduino>hardware>tiny
- Mis Documentos>Arduino>hardware>tools  

3.-  Conectamos nuestro Arduino al PC y arrancamos el IDE de Arduino 1.0.
Vamos a Files>Examples>ArduinoISP y abrimos dicho sketch.

En la web de Arduino, nos recomiendan que busquemos la función “heartbeat()” dentro del skech y cambiemos el delay(40); que tiene dicha función por un delay(20);.
Finalmente, cargamos el sketch en la placa Arduino.

Una vez cargado el sketch, se encenderán los leds uno a uno parpadeando varias veces, para terminar manteniendo en parpadeo suave el led conectado al pin 9, el led verde en mi caso, como se puede observar en el vídeo siguiente:

4.- Una vez que tengamos el Arduino en modo programador ISP y el led verde parpadeando suavemente, ya podemos conectar el ATtiny para programarlo, utilizando las líneas de datos vistas anteriormente.

- SCK —–> Pin digital 13 de Arduino
- MISO —> Pin digital 12 de Arduino
- MOSI —> Pin digital 11 de Arduino
- RESET —> Pin digital 10 de Arduino

Si observamos el pinout del ATtiny2313, veremos cuales son dichos pines y procedemos a conectarlos:

Por último debemos añadir 2 elementos más, importantes, que son, una resistencia de 10 kΩ en el Pin Nº1 del ATtiny hacia Vcc y un condensador de 10 uF entre GND y el pin de RESET del Arduino. Este condensador es muy importante, ya que evitará que se reinicie el Arduino al cargar el sketch correspondiente a la programación del ATtiny, por lo que debemos conectarlo después de cargar el sketch ArduinoISP, es posterior al Paso 3.

Así quedará el esquema completo:

En el esquema anterior, he añadido un led conectado al pin PB4 del ATtiny, ya que para comprobar el funcionamiento, cargaremos el sketch “blink” de Arduino, y el pin PB3 del ATtiny2313 se corresponde con el pin digital 12 de Arduino.

5.- Con todo conectado, nos queda la programación del ATtiny, pero debemos realizar un último paso, que es seleccionar en el IDE de Arduino, el ATtiny que vayamos a programar, en nuestro caso, el ATtiny2313 a 1MHz interno, es decir, no necesitará cristal externo.
Por tanto, abrimos el ejemplo “Blink” y nos vamos a Tools>Board>ATtiny2313 @ 1MHz 

Y seleccionamos el método de programación del ATtiny, por lo que nos vamos a Tools>Programmer>Arduino as ISP

6.- Hecho esto, solo nos resta darle a “UPLOAD” como si de cualquier sketch de Arduino se tratase, y veremos como, si todo está correcto, se enciende el led conectado al Pin digital 7 durante el tiempo que el Arduino esté programando al ATtiny. Y Fin! 
El ATtiny se programará y comenzará a funcionar!

Ya solo nos queda conocer los correspondientes pines del ATtiny para poder realizar la programación de todos ellos. Aún siendo uno de los pequeños de Atmel, el ATtiny2313 dispone de puerto serie, bus I2C, bus SPI, 18 pines de entrada/salida programables.

En la siguiente imagen de Akafugu.jp podemos ver todos los pines de todos los ATtiny y los correspondientes al ATtiny2313 que corresponden con la programación para los núcleos anteriormente descargados del projecto Arduino-tiny.
En letra pequeña podemos leer que los pines con PWM son los que están marcados con un asterisco.

Un vídeo de funcionamiento!

Uno de los métodos más sencillos, baratos y rápidos en mi opinión, es el método de la plancha. (Sí, la de planchar la ropa)

Este método es un método casero muy eficaz para hacer placas de circuito impreso, pero como todo en esta vida, tiene algunas desventajas y complicaciones.

Veamos tras el salto la lista de materiales que necesitamos para realizar placas con la plancha paso a paso y las ventajas y desventajas que tiene este método:

Ver como realizar las placas con la plancha

Los materiales y herramientas necesarios para hacer PCB con el método de la plancha son:

-  Placa de cobre virgen (Puede ser simple o doble cara)
-  Plancha de ropa (Preferiblemente > 2200 Watios)
-  Papel fino satinado (Estilo folleto de supermercado)
-  Folio común
-  Impresora LÁSER

Bien, veamos paso a paso como utilizarlos para crear una PCB a simple cara:

1) Para empezar, una vez diseñado el fotolito de la placa, imprimiremos en blanco y negro con la impresora láser sobre el papel satinado fino del estilo de los folletos del supermercado, que cuánto más fino sea mejor, sin importar las inscripciones que haya en el papel siempre y cuando sea satinado, es decir, que tenga brillo.

Sin escatimar en gasto de tóner, recomiendo realizar el plano de masa a la placa ya que aumentará las posibilidades de que la placa salga correctamente al tener más superficie de tóner que se adhiera al cobre.

Paso 1: Fotolito impreso en papel de folleto
Sin plano de masa (No recomendado)

2) Una vez impreso el fotolito en el papel satinado, lo recortaremos y procederemos a limpiar correctamente la placa y a pre-calentarla, situando la plancha encima de ésta directamente y manteniéndola durante unos segundos (30/45 apróx.), hasta que la placa queme, y no seamos capaces de agarrarla con los dedos sin quemarnos.

Además veremos como el cobre cambia un poco su color por un tono algo más oscuro.
No mantener demasiado tiempo la plancha sobre la placa de cobre directamente porque se levantará el cobre del propio calor y la placa se volverá inservible.

Paso 2: Limpieza de la placa de cobre

3) Pre-calentada la placa, retiramos la plancha y procedemos a colocar el papel impreso con el fotolito con la tinta de cara al cobre, de forma cuidadosa de modo que quede lo más estirado posible, ya que al estar caliente el cobre, el papel tenderá a pegarse y adherirse al cobre mediante la acción del calor y el tóner.

Hecho esto, colocaremos un folio blanco cobre la placa+fotolito, y plancharemos despacio hasta observar que toda la superficie del papel está pegada al cobre de un modo uniforme sin burbujas ni rugosidades.

Procedemos al planchado moviendo la plancha para asegurar la distribución de calor y presión en toda la superficie de la placa, durante unos minutos, en mi caso, con la plancha al máximo de calor, 3/4 minutos son suficientes.

El tiempo de planchado dependerá de varios factores, entre ellos está la potencia de la plancha, el papel utilizado y el tóner, recomiendo hacer pruebas antes de realizar una placa, para determinar los tiempos y obtener los mejores resultados. Se puede decir que este método se basa en el sistema ensayo-error, hasta dar con los tiempos exactos. 

Una vez terminado el tiempo de planchado, si observamos la placa de cerca, debemos ver como se transparentan las pistas a través del papel, tal y como se ve en la imagen siguiente:

Paso 3: Pistas transparentándose a través del papel

4) El siguiente paso, será introducir la placa tal y como está en agua fría, dejándola empaparse durante un minuto y procediendo con cuidado a pasar el dedo lentamente sobre el papel mojado (dentro del agua) para asegurar la desintegración del papel.

Paso 4: Placa en agua, empapando el papel

No es recomendable tirar del papel, ni intentar retirarlo a la fuerza ya que probablemente además del papel, despeguemos las pistas y tendremos que empezar el proceso nuevamente.

Al cabo de unos minutos veremos como el papel se desintegra dejando el tóner pegado al cobre listo para el atacado con ácido.

Paso 4: (Final) Papel desintegrándose al pasar el dedo lentamente sobre él metido en agua

Como se observa en la imagen anterior, el papel se desintegra poco a poco dejando una fina capa de papel sobre el tóner, que deberemos seguir retirando lentamente hasta visualizar el cobre limpio en las zonas donde NO haya pistas, es decir, las zonas que el ácido atacará posteriormente.

5) Proceder al atacado con ácido. Y tendremos la placa lista para agujerear y soldar!

Además de los productos atacadores de PCB comerciales que se venden, podemos atacar la PCB con una mezcla de productos de limpieza que seguramente todos tengamos en casa: Salfumán + Agua oxigenada.
Recomiendo la lectura del siguiente post para realizar las mezclas correctamente:  Atacador.

Paso 5: PCB atacando con Agua Oxigenada + Salfumán

- – - – - – - – - – - – - – - – - – - – - – - – - – - – - – - – - – - – - – - – - – - – - – - - 

El método de la plancha, tiene varias ventajas y varias desventajas, veamos cuales son:

Ventajas:

- Método barato, sencillo y  rápido.

- No requiere demasiado esfuerzo y con muy pocas herramientas podemos hacer una buena PCB.

- Una vez determinados los tiempos, se puede hacer una PCB en aproximadamente 10 minutos.

- Se pueden hacer con placas de cobre virgen sin necesidad de ser fotosensibilizadas ni de utilizar ningún tipo de material especial.

- Si el proceso antes del atacado con ácido sale mal, se puede limpiar el cobre con un cepillo de alambres y comenzar de nuevo, sin tener que desechar una placa porque haya salido mal, es decir, es un proceso “reciclable”.

Desventajas:

- Solo se pueden realizar placas a simple cara.

- Una de las desventajas principales de este sistema, es la necesidad de tener una impresora láser para poder imprimir el fotolito. Es importante que sea una impresora de tipo LÁSER, no es válida una impresora de chorro de tinta normal ya que no se despegaría la tinta del papel para adherirla al cobre.

- Si no se realizan los pasos correctamente en el tiempo necesario, es probable que el fotolito no se adhiera bien al cobre, y por tanto, el fotolito no servirá más y tendremos que imprimir uno nuevo.

- Si el proceso se realiza con prisas, es probable que se terminen levantando muchas pistas a la hora de despegar el papel del cobre, por lo que es un proceso en el que necesita paciencia y suavidad.

- Si nos pasamos de tiempo o temperatura en el planchado, aunque el tóner se adhiera al cobre debido a la acción del calor, las pistas se ensancharán llegando incluso a tener el doble de tamaño del que deberían, por lo que en muchos casos habrá que realizar “arreglos” en el tóner antes de proceder al atacado con ácido, por lo que no es un proceso “perfecto”.

- Es un proceso en el que el tamaño de la placa está determinado por el tamaño de la plancha, es decir, placas pequeñas no mayores de 250 cm².

- – - – - – - – - – - – - – - – - – - – - – - – - – - – - – - – - – - – - – - – - – - – - – - - 

Dicho esto, solo puedo añadir que a mi personalmente, con mucha suerte siempre me han salido las placas con el método de la plancha muy bien. Al principio puede ser desesperante pero una vez determinados los tiempos de calentado y planchado, salen muy buenas PCB.

PCB Terminada:

PCB terminada

Un vídeo del proceso de una PCB pequeñita:

Nota: El fotolito de la foto Nº1 no se corresponde con el resto del proceso ni con el vídeo.
Se realizó un nuevo fotolito con plano de masa pero no se fotografió.

Yo asistí al concurso junto con el instituto y mis compañeros de clase donde presentamos varios robots en distintas pruebas.

Detrás del salto dejo imágenes y explicación y vídeos del funcionamiento de los robots.

Ver los robots!

Robot Bípedo “ATOM” – Prueba Libre:  Mi robot bípedo casero con estructura de aluminio,  6 servomotores analógicos,  gobernado mediante un Atmega328P y control de movimientos por infrarrojos con mando a distancia. Creador: Yo, iPadNano

ATOM

Robot Tetrápodo “CangreBot” – Prueba Libre: Robot tetrápodo casero con estructura de aluminio, 8 servomotores analógicos, sensor de ultrasonidos para detección de obstáculos y control de movimientos por infrarrojos con mando a distancia. Gobernado mediante un ATmega328P. Creador: Antonio F.

CangreBot

Exposición en GranaBot 2012: 2do Puesto prueba Libre “CangreBot”

Robot Rastreador “Come-Rayas” – Prueba Rastreadores: Robot seguidor de línea con sensores CNY70 y micromotores Pololu gobernado mediante un ATmega328P.
Creador: @Cuningan (Simplificate 2.0)

Come-Rayas

Robot Velocista “Rapidillo”  - Prueba Velocistas: Robot velocista seguidor de líneas con sensor array QTR-8RC y micromotores Pololu gobernado mediante un ATmega328P. Creador: Jesús C.

Rapidillo

Robot Rastreador “NoesBot” – Prueba Rastreadores: Robot seguidor de líneas con sensor array QTR-8RC y micromotores Pololu, gobernado mediante un ATmega328. Creador: Noelia B.

NoesBot

Robot MiniSumo – “Zumor” – Prueba Minisumo: Robot minisumo luchador de tipo orugas con servomotores de giro 360º y sensor de ultrasonidos. Gobernado mediante un ATmega328P. Creador: Roberto C.

Zumor

Robot resuelve-laberintos “Alikibambot2000″ – Prueba Laberinto: Robot resuelve-laberintos con micromotores Pololu y 2 sensores de ultrasonido HC-SR04. Gobernado mediante un ATmega328P. Creadores: Luis U. y Kevin V.

Alikibambot 2000

La organización ha hecho un trabajo impecable tanto en la realización del evento (Aunque se echó de menos poder testear los robots en los circuitos, laberintos oficiales antes de las pruebas) como posteriormente, habiendo colocado ya en la web oficial las fotos de todos los robots y los participantes, en este link que dejo a continuación:

- GranaBot 2012 – Fotos oficiales 

Este mando además de los botones y el mando analógico, tiene un acelerómetro de 3 ejes dentro, que es lo que lo convierte en una herramienta bastante útil y ahora veremos porque.

Muchos no sabrán lo que es un acelerómetro a pesar de que aquellos con smartphones y móviles de gama alta los utilizan a diario.
Entonces, lo primero que hay que preguntar es: ¿Qué es un acelerómetro? (¿Lógico, no? )

Pues sigue leyendo para saberlo! 

Tiramos de Wikipedia y vemos:

“Se denomina acelerómetro a cualquier instrumento destinado a medir aceleraciones.”

Bien, me quedo igual que antes, ¿eso que significa?

Existen varios tipos de acelerómetros con diferentes usos, pero a nosotros solo nos interesa el uso del acelerómetro que tiene dentro el mando Nunchuk y que se utiliza para determinar la posición de un cuerpo (del mando en este caso), midiendo la aceleración y conociendo la posición inicial y velocidad con la que se desplaza, podemos calcular la posición final. 

Nosotros no calcularemos nada, lo hará acelerómetro del mando, el LIS3L02AL (Datasheet), que es un acelerómetro de 3 ejes, y por tanto, nos dirá en qué posición se encuentra el mando en un plano de coordenadas X, Y, Z, como se puede ver en la siguiente imagen:

Hablando claro, el acelerómetro nos dirá en que posición del Eje X, Y y Z se encuentra el mando cuando lo giramos a la derecha, a la izquierda, hacia adelante, hacia atrás, si está del revés o del derecho.

Todo esto sumado a que además del acelerómetro, el mando dispone de 2 botones y un joystick analógico de 2 ejes, y que en conjunto, su precio es bastante más reducido que comprarlo todo por separado.

Por si fuera poco, y esto es de lo más interesante, todo el conjunto se puede controlar con tan solo 2 pines de nuestro Arduino más la alimentación, así que, pasemos a ver como se conecta y utiliza, ¿No?

El mando se conecta mediante el bus I2C y funciona a 3,3V, y puestos a facilitarnos las cosas, en la web de Arduino hay una librería para poder controlarlo con muy pocas líneas de código.

El pinout del conector del mando (Pragprog):

Donde Clock sería el pin SCL, y Data el pin SDA,  del bus I2C correspondientes a los pines analógicos A5 y A4 del Arduino respectivamente.

Yo opté por conectarlo insertando unos cables en el conector y en el Arduino, aunque existe un adaptador específico diseñado para conectar el mando al Arduino, que podemos comprar en muchas tiendas online.

Dicho esto, no hay más que conectarlo de acuerdo a lo visto anteriormente y comenzar a utilizarlo! Para ello, descargamos la librería WiiChuck de la web de Arduino o de aquí mismo Librería WiiChuk (Para la versión de Arduino 1.0) y veamos como mostrar por el puerto serie los valores de todos los elementos del mando, mediante el siguiente sketch:

#include "Wire.h"       //Libreria I2C
#include "WiiChuck.h"   //Libreria WiiChuck

WiiChuck chuck = WiiChuck();  //Instancia de WiiChuck

void setup()
{
Serial.begin(9600);    //Iniciamos comunicacion serie
chuck.begin();         //Iniciamos WiiChuck
}

void loop()
{
chuck.update();        //Actualizamos los valores y los imprimimos por pantalla.
Serial.println("-----------------------");
Serial.print("Eje X: "); Serial.print((int)chuck.readAccelX()); Serial.println();
Serial.print("Eje Y: "); Serial.print((int)chuck.readAccelY()); Serial.println();
Serial.print("Eje Z: "); Serial.print((int)chuck.readAccelZ()); Serial.println();
Serial.println();
Serial.print("Joystick X: "); Serial.print((int)chuck.readJoyX()); Serial.println();
Serial.print("Joystick Y: "); Serial.print((int)chuck.readJoyY()); Serial.println();
Serial.println();
Serial.print("Boton Z: "); Serial.print((int)chuck.zPressed()); Serial.println();
Serial.print("Boton C: "); Serial.print((int)chuck.cPressed()); Serial.println();
Serial.println();
Serial.println("-----------------------");
delay(2000);
}

Si conectamos y cargamos correctamente, debemos ver por el puerto serie, cada 2 segundos, los valores correspondientes a los ejes X, Y y Z del acelerómetro, los ejes X e Y del joystick analógico y los valores de los botones C y Z, así:

Llegados a este punto, controlando todos los elementos del mando, la imaginación de cada uno y los proyectos que realicen determinarán el uso que le demos, sin duda se pueden hacer muchas cosas.

Yo para hacer algunas pruebas, he conectado el mando y 14 leds a los pines digitales del Arduino, para ir encendiendo y apagando los leds de acuerdo a la posición lateral del mando, mapeando el valor del eje X del acelerómetro.

Aquí dejo la forma de conectarlo, el sketch y un pequeño vídeo de funcionamiento :

Sketch: WiiChukLeds.ino (Para la versión de Arduino 1.0)

Vídeo funcionando!

Uno de los usos más interesantes que podemos darle, es el de controlar los movimientos de un robot, como ha hecho Alex (@TCRobotics) y podemos ver en el siguiente vídeo como controla todos los aspectos de su robot “Orugas” mediante el mando Nunchuk:

Encuesta cerrada. ¡Gracias por votar!

Con un total de 77 votos, suben al podio:

1º Lugar: Cadence OrCAD (15 votos)
2º Lugar: CadSoft Eagle (14 votos) 
3º Lugar: Otro: Muchos coincidieron en “DipTrace” (12 votos)

]]> http://electronicavm.wordpress.com/2012/02/17/encuesta-software-de-diseno-electronico-3/feed/ 4 ipadnano http://electronicavm.wordpress.com/2012/02/16/automatas-grafcet/ http://electronicavm.wordpress.com/2012/02/16/automatas-grafcet/#comments Thu, 16 Feb 2012 20:17:08 +0000 iPadnano http://electronicavm.wordpress.com/?p=1433 ]]> Aquí dejo apuntes de introducción a los autómatas programables: Grafcet.

1) Introducción a Autómatas – Grafcet.
2) Ejercicios Autómatas.
3) Bomba pozo.
4) Motor trifásico variador.
5) Neumática.
6) Pantalla Táctil.
7) Planta neumática
8) Regulador de luz a triac
9) Triac optoacoplado

]]> http://electronicavm.wordpress.com/2012/02/16/automatas-grafcet/feed/ 4 ipadnano S200