Txapuzas electrónicas

Bienvenido!!

2010-12-13T21:00:00.022+01:00

Esta página es un índice de los distintos proyectos desarrollados en el blog Txapuzas Electrónicas (Botxed Electronic Projects).
Cada proyecto tiene una hoja resumen imprimible cuya imagen es la que ves aquí.

Si pulsas sobre la imagen accedes a la página Web de cada proyecto.
Si haces click con el botón derecho sobre cada imagen y seleccionas la opción del menú desplegable "ver imagen" accederás a una imagen de mayor resolución.

Paperduino Leonardo: Clon de Arduino Leonardo en un PCB de una sola cara

2009-12-12T12:31:00.000+01:00

Descripción

El presente proyecto es realizar un clon de Arduino Leonardo de una manera sencilla. Es por eso que la distribución de las patillas no coincide con las standard de Arduino (habría que hacer muchos puentes en la placa o usar las dos caras). No obstante, la mayoría de las características de Arduino Leonardo se mantienen.
El circuito está protegido con un fusible de rearme automático (PTC) de 500 mA para evitar que en un descuido nos carguemos el puerto USB.
La selección de la alimentación no se realiza de forma automática, sino que hemos de seleccionarla manualmente mediante un puente (Alimentación externa / USB).
El circuito está "basado" en el realizado por J.M. en Probando el ATmega(32/16)u4 al que simplemente he añadido un regulador de tensión, un fusible de protección y la numeración de las patillas de Arduino Leonardo según el siguiente documento.

NOTA: Este proyecto está realizado con una versión provisional del Entorno Arduino, la Arduino-1.0RC2, en poco tiempo los chicos de Arduino han sacado la versión definitiva 1.0, en la que han realizado una serie de modificaciones:

Han eliminado del menú "Board" la opción "Leonardo", pero puedes activarla eliminando los comentarios en el archivo Arduino-1.0/Hardware/Arduino/boards.txt.

Han modificado el mapeo de pines, más concretamente han intercambiado la patilla D14 por la D17 (señal MISO y la SS). Como las señales MISO y SS vienen definidas por hardware, quizás sea un error. Es decir en la versión 1.0 la señal MISO es en la patilla D14 - PB3 y la SS en D17 - PB0. Gracias Hilo90Mz. (La definición de patillas la tienes en el archivo Arduino-1.0/hardware/arduino/variants/leonardo/pins_arduino.h)

De momento, ante la posibilidad de nuevas modificaciones, (hasta que salga la placa Arduino Leonardo Oficial), no voy ha corregir las modificaciones.

Nota: El conector de alimentación externa no tiene polaridad y el circuito no tiene diodo de protección contra la inversión de la polaridad, por lo que cuidadín a la hora de conectar la pila!!

Esquema

Como Leonardo utiliza el chip ATmega32U4, no es necesario un chip conversor USB, ya que éste chip lo tiene internamente, simplificándose el circuito. (tampoco será necesario un cable FTDI como en los otros Paperduinos).
El esquema de nuestro circuito es bastante sencillo:

NOTA: Al realizar la placa me he dado cuenta de que los LEDs Rx(8) y Tx(22) están invertidos, es decir, permanecen encendidos constantemente y se apagan al recibir y emitir datos. Esto no afecta el funcionamiento del circuito, pero de todas formas si quieres modificarlo, habría que invertir los diodos LED y conectarlos a 5 voltios. A la espera de que la gente de Arduino realice alguna modificación, de momento no voy a corregir este pequeño defecto, y esperaré a que salga la versión definitiva de Leonardo.

En la parte inferior izquierda vemos el regulador 7805 con sus condensadores asociados, que nos permitirá alimentar nuestro Paperduino con una tensión comprendida entre 7v y 14v en el conector J1. También vemos el puente J5 de selección de alimentación, bien a través del 7805 o bien a través del conector USB. Mediante el led D1 comprobamos que el circuito recibe una tensión correcta.

En la parte izquierda del esquema vemos el conector J2, que dispone en la parte superior de cuatro terminales con 5v para su uso en nuestros circuitos. Después tenemos conexión directa a los pines del chip, teniendo la patilla PB0 un led indicador de recepción por el puerto serie con su resistencia de polarización, y la patilla de RESET un pulsador a masa y una resistencia Pull-Up.

En la parte superior vemos los condensadores de estabilización del chip.

En la parte derecha del esquema tenemos el conector J3, que dispone en su parte superior 4 terminales a masa para utilizarlos en nuestros circuitos, después nos da acceso a los pines de entrada/salida del chip, y desde luego tiene un diodo led en el pin 13!!.

En la parte inferior del esquema vemos el cristal con sus condensadores asociados, el conector mini USB, con el fusible de protección. En la patilla 22 tenemos el diodo LED indicador de transmisión de señal por el puerto serie. Y la 33 la llevamos a nivel bajo para impedir tener acceso al bootloader.

Componentes

IC1 Regulador LM7805
IC2 Microcontrolador ATmega32U4-AU
X1 Cristal 16 MHz.
C1,C2 Condensador electrolítico 100 uF 24v
C3-C7 Condensador SMD(1206) 100nF
C8,C9 Condensador SMD(1206) 18 pF.
C10,C11 Condensador SMD(1206) 1 uF.
R1,R2,R4,R6 Resistencia SMD(1206) 680 Ohmnios.

R3 Resistencia SMD(1206) 10K.
R5 Resistencia SMD(1206) 3K9. 
R7,R8 Resistencias SMD(1206) 22 Ohmnios.
R5 Resistencia SMD(1206) 3K9.
P1 Pulsador Reset
F1 Fusible Rearmable 500mA (PTC)

D1 DiodoLED 3mm verde
D2 Diodo LED 3mm naranja 
D4 Diodo LED 3mm amarillo
D3 Diodo LED 3mm rojo
J1 Tira de pines Hembra (x17)
J2 Tira de pines Hembra (x17)
J3 Conector Mini USB SMD
J4 Tira de pines Hembra (x2)
J5 Tira de pines Macho (x3)

una placa virgen de circuito impreso (y material para fabricación del PCB)

y una impresora para imprimir el PaperDocumento!!  ;-)

Realización

El circuito está realizado con Inkscape , y tienes el documento imprimible al final de esta página, en el apartado de descargas.

Una vez descargado el documento, y descomprimido, puedes imprimir el documento PaperduinoLeonardo.pdf (sin aplicar ningún tipo de escala), para ello comprobaremos que la impresión se ha realizado a la escala correcta con la ayuda de la regla impresa situada en el lateral izquierdo de la hoja. Al colocar a su lado un regla en centímetros deberán coincidir las marcas.

En la parte inferior del documento tienes la placa PCB (espejo) preparada para su transferencia a la capa de cobre (bien por el método de la plancha, o por fotosensibilización).

Para la realización de la placa he utilizado el método de la plancha, con la ayuda de unas hojas de transferencia térmica (las tenía por casa desde hace años), pero puedes utilizar cualquier sistema.
Para ello he impreso la hoja del paperdocumento en una hoja en blanco, para tener una referencia de la posición del circuito impreso. Después he colocado una hoja en blanco encima de la hoja impresa, y he recortado un trozo de plástico de transferencia térmica, pegándolo encima del lugar donde se imprimirá el circuito impreso. Después he metido la hoja en la impresora y al imprimir el paperdocumento en esta hoja, el circuito quedará impreso en el transferible:

Aplicando calor con una plancha, transferimos el circuito sobre la placa y obtenemos el siguiente resultado:

Taladramos los agujeros con una broca de 0,7 mm.

Ahora podemos hacer la PaperEtiqueta, primeramente la protejemos con plástico transparente autoadhesivo (Aironfix):

Y lo recortamos

Aplicamos en la parte trasera adhesivo (he utilizado cinta de doble cara) y recortamos

Con ayuda de una aguja posicionamos la paperetiqueta sobre la placa

Una vez colocada, perforamos todos los agujeros

Y ya podemos soldar todos los elementos, primeramente he soldado los convencionales (no SMD), debes prestar atención a la polaridad de los diodos LED, los condensadores y la posición del regulador (7805).

Posteriormente soldaremos los componentes SMD, empezando por los menos sensibles al calor (resistencias y condensadores).

Yo he utilizado el truco del "Loctite", es decir, primeramente pongo una muy pequeña cantidad de adhesivo en la placa, con mucho cuidado y con ayuda de unas pinzas coloco el componente en posición, y una vez fijo, sueldo con tranquilidad.

Te puedes ayudar de la imagen del paperdocumento:

NOTA: Debido a que las pistas están muy cerca unas de otras es bastante fácil que se produzca algún cortocircuito, por lo que es conveniente ir comprobando con el tester el aislamiento, e incluso de vez en cuando alimentar el circuito con una pila de 9v y comprobar que el regulador no se calienta.

Para soldar el conector miniUSB, primeramente cargamos de soldadura las pistas, después con ayuda de una trenza de desoldar eliminamos casi todo el estaño:

Hacemos lo mismo con el conector, cargamos de soldadura...

Eliminamos la soldadura sobrante:

quedando los terminales con un poquito de soldadura, listos para ser soldados

Ahora lo colocamos en posición y aplicando calor con la punta del estañador sobre las pistas lo soldamos.

Previamente es necesario aislar la el conector de la pista que pasa por debajo de él, lo podemos hacer con un trocito de cinta aislante:

Para soldar el microcontrolador utilizaremos un método similar, aplicamos estaño:

Eliminamos el estaño sobrante:

Colocamos con mucho cuidado el chip en la placa alineándolo perfectamente con las pistas (he utilizado un alicate de puntas para mantenerlo en posición)

Y aplicamos estaño a cada una de las patas (primeramente las cuatro esquinas, comprobando que no se haya desplazado el chip)

No te preocupes si se te unen algunas vías,ya que con ayuda de la trenza de desoldar, puedes eliminar fácilmente el sobrante.

Y ya tenemos nuestro circuito listo!!

Carga del Bootloader utilizando ArduinoISP

Para convertir nuestra placa en una "Arduino compatible" y así poder utilizar el entorno de programación Arduino, deberemos cargar en el chip el bootloader del ATMega32U4.
En la fecha de realización de este documento (noviembre de 2011), la versión Arduino1.0 no permite grabar el bootloader utilizando Arduino as ISP, debido a un error. Existe un archivo ArduinoISP_04.zip (gracias Flico) que corrige este error, pero que no podemos compilar en el nuevo entorno Arduino1, por lo que es necesario utilizar una versión anterior para cargar el sketch Arduino as ISP, yo he utilizado la 22, donde sustuituiremos la carpeta Examples/ArduinoISP por la contenida en este archivo. Bueno vamos a exolicar este proceso detenidamente:

0 Cerramos todos los entornos Arduino que tengamos abiertos

1 Primero descargamos el archivo el parcheado ArduinoISP_04.zip

2 Si no utilizas el entorno 022 de Arduino lo puedes descargar de aquí

3 Buscamos en la carpeta Examples el directorio ArduinoISP, lo renombramos por ejemplo como "ArduinoISPOriginal"

4 Descomprimimos el directorio "ArduinoISP" del archivo comprimido que hemos descargado en el directorio examples.

5 Abrimos el entorno Arduino_022 y seleccionamos File/Examples/ArduinoISP.

y el IDE nos abrirá una nueva ventana con el sketch que convierte al arduino en un programador.

6 Seleccionamos el tipo de arduino que estamos utilizando como programador, en mi caso una duemilanove: Tool/Boards/Arduino Duemilanove w/ATMega328.

7 Conectamos la placa Arduino (no la Leonardo) mediante USB al PC

8 Seleccionamos el puerto serie que utiliza nuestra placa (quizás tengas que esperar un poco a que el PC reconozca el Arduino).

9 Apretamos el botón de "Upload" y cargamos el Sketch en el Arduino.

Bueno!! ya hemos convertido el Arduino en un programador, y ahora lo utilizaremos para programar el bootloader en el Arduino Leonardo (Hasta que el chip no tenga el bootloader cargado no podremos conectarle con el IDE de Arduino).

Para cargar el bootloader en la placa Pareduino Leonardo que hemos realizado seguiremos los pasos siguientes:

1 Deberemos descargar el nuevo entorno de Arduino (Arduino1), que dispone del bootloader para el Leonardo. Lo podemos descargar desde aquí.

2 Lo descomprimimos

3 Ejecutamos el archivo "Arduino", y se abrirá el nuevo entorno.

4 Conectamos el Paperduino al Arduino, para ello utilizaremos las patillas siguientes:

10: RESET
11: MOSI
12: MISO
13: SCK

Si queremos ver el estado de funcionamiento del programador podemos añadirle unos LEDS (con sus correspondientes resistencias de polarización) en los pines:

9: Pulsos - Indica que el programador está funcionando
8: Error - Se iluminará cuando se produzca algún error (mejor que sea de color rojo)
7: Programando - Comunicándose con el esclavo (Paperduino Leonardo)

El conexionado sobre las placas reales será algo parecido a:

Nota: Si tienes un Arduino UNO, tal vez necesites colocar un condensador de unos 10uF entre las patillas RESET y GND para que no se ejecute el autoreset (info).

4 Una vez conectado, desde el entorno de Arduino, seleccionamos el puerto serie que utiliza nuestro Arduino: Tools/Serial Port/(Puerto Serie de Arduino)

5 Seleccionamos la placa como Arduino Leonardo:Tools/Board/Arduino Leonardo:

NOTA: Recuerda que en la versión del IDE Arduino1.0 los chicos de Arduino han eliminado del menú "Board" la opción "Leonardo", pero puedes activarla eliminando los comentarios en el archivo Arduino-1.0/Hardware/Arduino/boards.txt.

6 Le indicamos que vamos a programarlo utilizando un Arduino como programador: Tools/Programmer/Arduino as ISP:

7 Y por último seleccionamos Tools/Burn Bootloader, para cargar el bootloader de Leonardo en nuestro Paperduino.

Se empezarán a encender y apagar los leds (espero que no se te encienda el rojo que indica que se ha producido un error) y ya hemos convertido nuestra placa en un Paperduino Leonardo.

8 Conectamos nuestro Paperduino Leonardo directamente al PC mediante el cable USB (ya no necesitaremos el Arduino original), y veremos que el ordenador lo reconoce y el entorno Arduino también (en el puerto dev/ttyACM0 ).

Blink.ino

Como la placa ya incorpora un LED en el pin 13, podemos cargar el sketch blink (File/Examples/Basic/Blink) y comprobar que funciona.

Nota: los sketches de arduino tienen ahora la extensión ino para diferenciarlos de los de processing.

Keyboard.ino

Una de las características importantes de nuestro Leonardo, es que puede simular las pulsaciones de un teclado en el ordenador. Podemos comprobarlo cargando el sketch keyboard (File/Examples/Keyboard/KeyboardMessage).

NOTA: En la versión 1.0 del entorno Arduino, han eliminado los ejemplos keyboard y mouse utilizables con el Leonardo, los puedes descargar del siguiente enlace. Debes decomprimirlos y colocarlos en la carpeta libraries: en la carpeta Arduino-1.0/libraries/Mouse y Arduino-1.0/libraries/Keyboard.

Deberás conectar un pulsador a 5v en la patilla 4 con una resistencia Pull-down. Como verá en el vídeo simplemente he conectado una resistencia de 10K entre el pin 4 y masa y después con un cable que está conectado a 5v puenteo el pin 4. Cada de vez que se activa dicho pin el Leonardo envía al ordenador una cadena de texto como si fuera un teclado.

NOTA: el programa no envía datos por el puerto paralelo, sinó que para el ordenador es como si se hubieran tecleado. Como ves en el video el programa que está en pantalla y donde aparecen los mensajes es un procesador de texto.

Enlaces de interés

Página donde me he "inspirado" para la realización del circuito realizada por J.M. en el blog de C.I.R.E.

Paperduino, Diseño original de paperduino por Guilherme Martins, un clon de Arduino realizado sobre un cartón, de donde ví por primera vez la utilización de etiquetas para la ayuda en la confección de circuitos (a partir de ahí surgieron todos los paper).

Archivo descriptivo del patillaje de Arduino Leonardo, utilizado para modificar el circuito de J.M. de un ATMega32U4 en un Arduino compatible.

Página oficial de Arduino

Página donde descubrí el parche (ArduinoISP_04.zip) para el sketch ArduinoISP compatible con el Arduino Leonardo.

Información legal

0. Fallos y txapuzas no controladas.
Los circuitos publicados se han comprobado y funcionan correctamente. No obstante en el caso de que en una página se publiquen varios montajes diferentes de un mismo circuito (sobre un stripboard, PCB, ...), pueden existir fallos que no se han detectado en alguno de los montajes, ya que normalmente sólo realizo un montaje. En ese caso por favor notificad el fallo para que pueda corregirlo. muchas gracias.

1. Propiedad intelectual
Todos los derechos de propiedad intelectual del contenido de Txapuzas eléctronicas, están bajo una licencia Creative Commons Share-Alike, cuyo contenido podéis revisar en este enlace.
Por tanto queda permitido copiar, distribuir, comunicar públicamente la obra y hacer obras derivadas de la misma, siempre que se respeten los términos de la licencia arriba reseñada.
3. Actualizaciones y modificaciones de Txapuzas electrónicas
El autor se reserva el derecho a actualizar, modificar o eliminar la información contenida en Txapuzas eléctrónicas, y la configuración o presentación del mismo, en cualquier momento, sin previo aviso, y sin asumir responsabilidad alguna por ello.
4. Indicaciones sobre aspectos técnicos
El autor no asume ninguna responsabilidad que se pueda derivar de problemas técnicos o fallos en los equipos informáticos, que se produzcan a causa de los circuitos e ideas expuestos en el blog de txapuzas electrónicas, así como de los daños que pudieran ocasionar.
El autor se exime de toda responsabilidad ante posibles daños o perjuicios que pueda sufrir el usuario a consecuencia de errores, defectos u omisiones en la información facilitada.

Descargas

El esquema, circuito impreso, descripción e imágenes están disponibles en el siguiente enlace:

Notas
Para la realización de este proyecto se han utilizado los programas: Arduino, Inkscape, Openoffice, Gimp, Picasa, Fritzing
Si encuentras algún fallo, se te ocurre alguna mejora, o simplemente quieres hacer algún comentario, te lo agradeceré: Gracias. :-)

PaperRobot: Robot simple con Arduino

2009-12-12T12:30:00.000+01:00

Descripción

El objetivo de este proyecto es realizar un sencillo robot controlado por Arduino de una forma fácil y económica.
El chasis está realizado en cartón pluma, material rígido y de fácil manipulación. Las ruedas delanteras están hechas con dos tapas de botes de conservas, para la rueda trasera he utilizado el "RollOn" de un desodorante y los motores son dos microservos trucados para que puedan girar más de 180º. Si no dispones de una placa protoboard, con unos pocos pines hembra y un trozo de stripboard podemos hacer una regleta de expansión que nos multiplique el número de bornas de 5v y masa de Arduino, y así poder conectar todo tipo de sensores.

Chasis

Para realizar el chasis puedes imprimir el PaperDocumento (no es en absoluto necesario) y pegarlo sobre el material que quieras utilizar para la confección del chasis. Antes de recortarlo, le he pegado encima un poco de Aironfix, para mantener la superficie del robot un poco "limpia". (El paper documento está disponible en el apartado de descargas en la parte final de este página)

Una vez impreso el documento, comprobaremos que la impresión se ha realizado a la escala correcta con la ayuda de la regla impresa situada en el lateral izquierdo de la hoja. Al colocar a su lado un regla en centímetros deberán coincidir las marcas.

No tiene por que ser cartón-pluma, puedes utilizar cualquier otro tipo de material (madera, plástico... ), pero la gran ventaja del cartón pluma es que se corta con gran facilidad.

Dependiendo de la "rueda trasera" que utilices deberás cortar el chasis:

Ruedas delanteras

Al utilizar servomotores trucados, tienen un sistema de engranajes con una gran reducción, suministrando una velocidad máxima muy baja, por lo que es conveniente utilizar unas ruedas de diámetro amplio, y así aumentar la velocidad máxima.
Yo he utilizado dos tapas de botes de conservas, con una junta tórica que hace de banda de rodadura (no es estrictamente necesario, y vale perfectamente una goma elástica)

Para calcular el centro de la tapa, medimos el diámetro de la misma:

Hacemos una pila con unos libros o folios y colocamos sobre él un rotulador (conviene que no sea permanente, para poder borrarlo), de forma que la punta del rotulador esté a la mitad del radio de la base:

Marcamos una linea horizontal manteniendo la rueda vertical

La giramos 180 grados y volvemos a marcar una linea horizontal paralela a la anterior

Ahora giramos 90º la tapa y repetimos el proceso anterior:

Si vemos que nos han quedado las lineas muy separadas (tal y como aparece en la imagen), borramos las líneas, ajustamos la anchura de la pila añadiendo o quitando folios y lo realizamos de nuevo. El punto central del círculo estará entre las 4 lineas dibujadas.
Un ejemplo:

Una vez que tenemos localizado el centro, con un clavo lo marcamos:

Y ya podemos con el taladrín hacer un agujero con una broca de tamaño similar al tornillo que viene con el servo para fijar las palancas de accionamiento

Rueda trasera

Sustituyendo a una rueda, puedes utilizar un deslizador simplemente con un tornillo DIN603, (Tornillo cuadradillo con tuerca), ya que tiene la cabeza redondeada permitiendo un deslizamiento fácil. Con un par de tuercas puedes regular la altura del deslizador.

En vez de utilizar este sistema, he querido probar una idea que surgió en el blog de Arduino en español (~~no recuerdo su autor~~ Gracias Javier!), y he utilizado la bola de un desodorante RollOn.

Todos los elementos están clipados a presión, primeramente soltamos la bola con su soporte del recipiente (nos podemos ayudar de un objeto afilado como un cutter o un cuchillo para hacer presión)

Después desmontamos el "RollOn" también con la ayuda de un cutter o un cuchillo

Cortamos con un cutter el muelle de plástico para que tenga menos rozamiento

Y por último lo volvemos a unir, pero para que la bola tenga más holgura y se mueva con mayor facilidad, no he clipado las dos partes del soporte, sino que las he unido con cinta aislante manteniendo una separación:

Y ya tenemos nuestra "rueda loca"

Parachoques

Todo robot que se precie necesita unos sensores que le indiquen que se ha chocado.
Estos sensores se pueden hacer colocando un par de microinterruptores en la parte delantera del robot:

Pero como estamos haciendo un paper robot, ¿Por qué no nos lo hacemos nosotros mismos?

La idea es mantener separadas dos superficies conductoras, de forma que cuando se produzca un impacto estas dos superficies entren en contacto y por lo tanto cierren el circuito.

Necesitaremos cinta conductora, debes tener en cuenta que no todas las cintas metálicas que venden son conductoras, algunas están recubiertas por una capa plástica aislante (tal vez se podría quitar con disolvente tipo acetona, pero no lo he intentado). Si no encuentras, podrías pegar directamente papel de aluminio que se utiliza en cocina sobre el chasis o un cartón.

Primeramente cortamos una tira de unos 15mm de anchura

Y la pegamos centrada sobre la zona curvada del chasis

Con unas tijeras hacemos cortes a intervalos regulares para permitir que la cinta se acople a la superficie curva:

Y vamos plegando cada una de las lengüetas generadas y pegándolas sobre el ecatón pluma:

Comprueba que la cinta no llegue a los extremos laterales del chasis para que no generen falsos contactos cuando incorporemos la otra parte del parachoques.

Con una broca o un taladro haces un agujero cerca de la cinta pegada.

Por ese agujero pasamos un cable y lo empalmamos, hacemos la unión más o menos estable con un macarrón termorretráctil (previamente puedes hacer un ligero canal en la zona de la cinta para que el espesor del cable no genere falsos contactos).

Ahora tendremos que hacer los guardabarros, en el documento los tienes dibujados al tamaño preciso. Si quieres los puedes proteger y rigidizar un poco pegando encima de ellos plástico adhesivo transparente (aironfix)

Necesitaremos, un trozo de cartulina (yo he utilizado un plástico utilizado como portada de encuadernación de fotocopias), una tira de unos 25mm de ancho de cinta adhesiva conductora, y los guardabarros impresos

Primeramente pegamos el dibujo del guardabarro sobre la cartulina,

y en la parte inferior pegamos la cinta adhesiva conductora.

Y ahora cortamos con un cutter siguiendo el dibujo

Y obtenemos nuestros guardabarros, por un lado del Athletic y por el otro metálicos ;-)

cerca de un extremo hacemos dos muescas y fijamos un cable (podemos hacer la unión permanente utilizanto tubo termorretráctil)

Y colocamos las bandas en las ranuras de nuestro chasis

Motores (microservos 9gr)

Como sistema motriz, he utilizado dos microservos, en ebay los tienes bastante económicos:

Estos servos hay que trucarlos, para que permitan un giro completo (de fábrica sólo permite 180º). En este tipo de servos este proceso tiene tres partes (inspirado en http://letsmakerobots.com/node/9420):

Eliminación del tope mecánico de la carcasa

Para abrir la carcasa soltamos los cuatro tornillos de la parte trasera, y podemos ver que la última rueda dentada tiene un saliente que hace tope con otro saliente de la carcasa. Lo más sencillo es eliminar el tope de la carcasa con un cutter.

Fijación del eje en el punto medio

En este servo el eje del potenciómetro es también el eje de la última rueda dentada, así que será necesario desmontarlas (ponlas en una superficie en orden, para saber luego como montarlas).
Una posibilidad es eliminar el potenciómetro, y sustituirlo por dos resistencias de valor idéntico de unos 4K, pero creo que es más sencillo, bloquear el potenciómetro en la posición central.
Teniendo el servo conectado a un Arduino y corriendo en él un programa que provoque que el servo está a 90º, deberemos ir moviendo el eje del potenciómetro hasta conseguir que el motor deje de moverse, en ese momento lo que haremos será fijar la posición del potenciómetro en ese punto. Una forma de fijarlo es con adhesivo, no te recomiendo que utilices cianocrilato (Loctite), ya que es muy fluido y se puede extender a la zona de contacto del potenciómetro con la pista, yo he utilizado un adhesivo epoxi rápido de doble componente (Araldit), aplicado en la zona de inicio y fin de la pista del potenciómetro tal y como se indica en la figura siguiente:

Para definir el punto central del potenciómetro del servo, puedes descargar el siguiente sketch PararServo.pde, una vez cargado en el Arduino, y conectado el cable de señal al pin 9, el de alimentación a 5v y el de masa a GND, debes girar el eje del potenciómetro hasta que el motor se pare, en ese estado puedes fijar el potenciómetro con adhesivo tal y como se ha indicado.

Permitir el giro libre de la última rueda dentada
Una vez que tenemos fijado el eje del potenciómetro, deberemos hacer algo para que el último engrane pueda girar sobre su eje (el eje del potenciómetro), que en su extremo tiene unas entallas para que encaje:

Creo que lo más fácil es con una broca o un destornillador fino, eliminar las entallas agrandando un poco el agujero de la rueda dentada.

Y ya podemos colocar las ruedas dentadas, (conviene comprobar que con las manipulaciones no se haya soltado ningún cable) y cerrar el servo con los cuatro tornillos.

Para poder conectarlo, he sustituido el conector hembra de tres vías, por tres pines macho individuales.

Protoboard

Para poder conectar los diferentes sensores a Arduino, es necesario aumentar el número de pines del Arduino, podemos hacerlo simplemente incorporando una protoboard al chasis:

o también puedes realizar una microprotoboard con un trozo de stripboard y unos pines hembra:

Con un trozo de stripboard de 4 pistas por 15 agujeros podemos conseguir 8 pines de 5v, 8 pines de masa y dos grupos de 3 pines cada uno (no te olvides de cortar las pistas 2 y 3 entre los agujeros 10 y 11):

Alimentación

Como no es muy conveniente alimentar los servos directamente del Arduino, ya que calentamos innecesariamente el regulador de la placa (además una pila de 9v no tiene mucha potencia) . Utilizaremos dos baterías, una para alimentar Arduino y sensores con 9v, y otra de 6v para alimentar los servos realizada con 4 pilas de 1,5v sobre un soporte pegado con cola termofusible a la parte inferior del chasis.
Las pilas de 1,5v conviene colocarlas entre las tres ruedas, para garantizar la máxima estabilidad del robot.

Los positivos de los motores están conectados a la batería mediante un conector casero, realizado con dos pines de conexionado hembras.

También he añadido un interruptor en serie con la pila de 9v para apagar el Arduino (perdona por la calidad de la imagen, pero como lo he pegado sobre una pila negra no se ve nada)

Montaje completo

En el documento de descargas (al final de esta página), tienes el segundo PaperDocumentos con los esquemas e instrucciones de montaje:

Para saber como debemos conectar todos los componentes nos fijaremos en el siguiente esquema:

Utilizaremos el regulador de tensión de la placa Arduino para obtener 5v para los sensores que utilicemos a partir de una pila de 9v.

Conectaremos un cable del parachoques a masa y el otro a las entradas D11 (delantero) y D12 (trasero). Deberemos activar por software las resistencias internas pull-up del Arduino, de forma que el Arduino detectará 0v cuando se choque y 5v en caso contrario.

Para activar las resistencias Pull-Up de las patillas D11 y D12 deberemos utilizar un código similar al siguiente:

...

pinMode(pinD11, INPUT);           // pone el pinD11 como entrada
digitalWrite(pinD12, HIGH);       // activa su resistencia pullup

pinMode(pinD12, INPUT);           // pone el pinD12 como entrada
digitalWrite(pinD12, HIGH);       // activa su resistencia pullup

...

El negativo de las pilas de los motores lo conectamos a masa y el positivo a través de un interruptor al positivo de los servos (no lo he representado en el dibujo de montaje inferior). El negativo de los servos a masa y el cable de control a las patillas D2 y D3 del Arduino.

Si quieres, puedes poner un zumbador entre la patilla 13 y masa, de forma que el robot pite cuando se choca (si está programado en el sketch).

NOTA: Algunos servos identifican los cables de forma diferente:

Positivo: Rojo.

Negativo: Marrón, Negro.

Señal: Naranja, Blanco.

NOTA: en el dibujo superior el conmutador de la pila de 9v está mal colocado, ha de estar conectado la pata central y una pata lateral!!

Y aquí podéis ver el resultado (menudo lío de cables!!):

Programa

El archivo PaperRobot.pde lo tienes en el archivo de descargas disponible en el enlace al final de esta página. (Es mejor que lo copies de ahí, ya que a veces blogger confunde comandos de Arduino con comandos de HTML, sobre todo con #include )

/*
* PaperRobot: Programa de control de un rebot realizado con dos servos controlados por Arduino
* Version 31.10.2011
* Copyright 2011 Iñigo Zuluaga
* http:www.txapuzas.blogspot.com
*/

#include (Esta linea está mal, falta la librería a incluir: servo)

int LUCES_PIN=8;                // Pin al que estan conectadas las luces
int SERVOIZDA_PIN=9;            // Pin al que esta conectado el motor izdo
int SERVODCHA_PIN=10;           // Pin al que esta conectado el motor dcho
int TOPEDEL_PIN=11;             // Pin al que esta conectado el parachoques delantero
int TOPETRAS_PIN=12;            // Pin al que esta conectado el parachoques trasero
int CLAXON_PIN=13;              // Pin al que está conectado un buzzer (con vibrador)
//int Marcha=0;                 // Marcha (velocidad): 1,2,3
boolean TopeDelantero=HIGH;     // Definimos el estado del tope delantero
boolean TopeTrasero=HIGH;       // Definimos el estado del tope trasero
Servo MotorIzda;                // creamos los objetos servo para poder controlarlos
Servo MotorDcha;

void setup(){
pinMode(TOPEDEL_PIN, INPUT);           // pone el pin como entrada
digitalWrite(TOPEDEL_PIN, HIGH);       // activa la resistencia pullup
pinMode(TOPETRAS_PIN, INPUT);          // pone el pin como entrada
digitalWrite(TOPETRAS_PIN, HIGH);      // activa la resistencia pullup
int Marcha=1;                          // ponemos la primera
MotorIzda.attach(SERVOIZDA_PIN);       // conectamos el servo izquierda
MotorDcha.attach(SERVODCHA_PIN);       // conectamos el servo derecha
Serial.begin(9600);                    // definimos la velocidad de la conexion serie

Paro();                                // paramos el robot
Claxon(50);                            // Y que pite dos veces para indicar que esta listo
Claxon(50);

}

void loop() {
int Marcha=3;                           // Pone la tercera
TopeDelantero=digitalRead(TOPEDEL_PIN); // Comprueba si se ha chocado por delante
TopeTrasero=digitalRead(TOPETRAS_PIN); // Comprueba si se ha chocado por detras

if (TopeDelantero==LOW){               // si se ha chocado por delante
    if (TopeTrasero==LOW){               // y por detras !!!!
      Serial.println("AMBOS TOPES");     // manda por el puerto serie el caso (solo con cable usb)
      Serial.println("---------------");
      Paro();                            // Para los motores
      Claxon(200);                       // y da unos cuantos pitidos largos para indicar la situacion
      Claxon(200);
      Claxon(200);
      Claxon(200);
    }
    else{                                // Si el choque solo es delantero
    Serial.println("TOPE DELANTERO");    // Manda por el puerto serie la situacion
    Serial.println("---------------");
    Atras(Marcha);                       // Inicia maniobra desbloqueo: Atras
    Claxon(100);                         // pita
    delay(500);                          // durante medio segundo
    Izda(Marcha);                        // Gira a la izquierda
    Claxon(100);                         // pita
    delay(500);                          // gira durante medio segundo
    Adelante(Marcha);                    // adelante en tercera
    Claxon(50);                          // dos pitidos cortos (50 ms)
    Claxon(50);
    }
}

if (TopeTrasero==LOW){                 // Si el choque es trasero
    Serial.println("TOPE TRASERO");      // Manda por el puerto serie el estado
    Serial.println("---------------");
    Adelante(Marcha);                    // y automaticamente va hacia adelante
    Claxon(50);                          // dos pitidos cortos (50 ms)
    Claxon(50);
}
}

void Adelante(int Marcha){
// Se encarga de mover los dos motores hacia Adelante
// ENTRADAS=> Marcha (velocidad): 1,2,3
int SMotorIzda=1;                    // Motor Izquierdo hacia adelante
int SMotorDcha=1;                    // Motor Derecho hacia adelante
Serial.println("ADELANTE");         // Manda por el puerto serie el estado
Mover(Marcha,SMotorIzda, SMotorDcha); // mueve los motores
}

void Izda(int Marcha){
// Se encarga de girar el robot hacia la Izquierda
// ENTRADAS=> Marcha (velocidad): 1,2,3
int SMotorIzda=-1;                   // Motor Izquierdo hacia Atras
int SMotorDcha=1;                    // Motor Derecho hacia Adelante
Serial.println("IZQUIERDA");        // Manda por el puerto serie el estado
Mover(Marcha,SMotorIzda, SMotorDcha); // mueve los motores
}

void Dcha(int Marcha){
// Se encarga de girar el robot hacia la Derecha
// ENTRADAS=> Marcha (velocidad): 1,2,3
int SMotorIzda=1;                    // Motor Izquierdo hacia Adelante
int SMotorDcha=-1;                   // Motor Derecho hacia Atras
Serial.println("DERECHA");          // Manda por el puerto serie el estado
Mover(Marcha,SMotorIzda, SMotorDcha); // mueve los motores
}

void Atras(int Marcha){
// Se encarga de mover el motor hacia Atras
// ENTRADAS=> Marcha (velocidad): 1,2,3
int SMotorIzda=-1;                   // Motor Izquierdo hacia Atras
int SMotorDcha=-1;                   // Motor Derecho hacia Atras
Serial.println("ATRAS");            // Manda por el puerto serie el estado
Mover(Marcha,SMotorIzda, SMotorDcha); // mueve los motores
}

void Paro(){
// Para los motores
int SMotorIzda=0;                    // Motor Izquierdo Paro
int SMotorDcha=0;                    // Motor Derecho Paro
int Marcha=0;                       // Marcha Ninguna
Serial.println("PARO");             // Manda por el puerto serie el estado
Mover(Marcha,SMotorIzda, SMotorDcha); // mueve los motores
}

void Mover(int Marcha,int SMotorIzda, int SMotorDcha){
/* Manda Mover los motores
ENTRADAS=> Marcha(velocidad): 1,2,3
             SMotorIzda: Sentido de marcha del motor Izquierdo (1=horario, -1=Antihorario)
             SMotorDcha: Sentido de marcha del motor Izquierdo (1=horario, -1=Antihorario)
*/
int VelMotorIzda = 0;                // Velocidad del motor izquierdo
int VelMotorDcha = 0;                // Velocidad del motor derecho
VelMotorIzda=90-SMotorIzda*30*Marcha; //M0(90);M1(1:120,-1:60);M2(1:150,-1:30);M3(1:180,-1:0)
VelMotorDcha=90+SMotorDcha*30*Marcha; //M0(90);M1(1:60,-1:120);M2(1:30,-1:150);M3(1:0,-1:180)
MotorIzda.write(VelMotorIzda);       // Transmite la velocidad al pin
MotorDcha.write(VelMotorDcha);       // Transmite la velocidad al pin
Serial.print("MotorIzda:");
Serial.println(VelMotorIzda);
Serial.print("MotorDcha:");
Serial.println(VelMotorDcha);
Serial.println("---------------");
}

void Claxon(int Duracion){
// Realiza un pitido
// ENTRADAS=> Duracion del pitido en milisegundos

digitalWrite(CLAXON_PIN,HIGH);      // Activa el pin del Buzzer
delay(Duracion);                    // Espera
digitalWrite(CLAXON_PIN,LOW);       // Apaga el buzzer
delay(Duracion);                    // Espera (por si hay que hacer varios pitidos)
}

Cuando iniciamos el programa, el robot permanecerá parado hasta que activemos algún parachoques.
Si el parachoques delantero detecta un impacto, efectuará una maniobra de evasión, un poco hacia atras, giro y hacia adelante de nuevo.
Si el parachoques trasero detecta un impacto simplemente cambiará de sentido de la marcha.
A continuación podemos ver el programa anterior en funcionamiento:

Información legal

Descargas

El esquema, descripción e imágenes están disponibles en el siguiente enlace:

PaperATTinyMosfet: Control de velocidad de un motor de corriente continua con ATtiny

2009-12-12T12:29:00.003+01:00

Descripción

Para controlar la velocidad de un motor no necesitamos un Arduino, con un pequeño ATtiny podemos realizar la misma función.

En este circuito el ATtiny realizará dos funciones:
- por un lado comprueba la tensión de la batería, y visualiza su estado mediante un LED bicolor (Verde,Naranja(Verde+Rojo), Rojo)
- En función del valor de un potenciómetro controla la velocidad de un motor de corriente contínua.

Para la programación del ATtiny mediante el IDE de Arduino, puedes mirar aquí.

Esquema

En la parte superior derecha vemos la zona de mando que consta de un potenciómetro con un interruptor integrado, y un diodo bicolor con sus resistencias de polarización.

Como el interruptor del potenciómetro no puede conmutar intensidades altas, con él activamos un relé de 20A que hace las funciones de interruptor general (con su diodo de protección D5).

El circuito controla la carga de la batería mediante el divisor de tensión R1-R2 y muestra su estado mediante un LED bicolor.

El control de velocidad lo realizamos mediante control de anchura de pulso (PWM) sobre un transistor FET de entrada compatible TTL (IRL540N), que con una buena refrigeración soporta hasta 30A.

La alimentación proviene de una batería de 12v (con un fusible en el cable de 15A). De la misma batería, mediante un regulador de tensión (7805), obtenemos la tensión de alimentación para el micro, mediante el diodo D2 protegemos al micro ante inversiones de polaridad de la batería.
Tanto el motor como el FET los protejemos con diodos rápidos en antiparalelo (D3 y D4).

Debes tener en cuenta que la numeración de los pines digitales y analógicos en el ATtiny 85 son diferentes:

Componentes

Componentes Mando

10K1       Potenciómetro con interruptor
D1         LED Bicolor
P2         Conector MOLEX 7pines hembra
R1         Resistencia 470 Ohmnios 1/4W
R2         Resistencia 470 Ohmnios 1/4W

Componentes placa
C1      Condensador 100nF
C2      Condensador 100nF
C3      Condensador 100nF
C4      Condensador electrolítico 470uF/16v
D2      Diodo rectificador 1N4007
D3      Diodo Schottky N5821
D4      Diodo Schottky 1N5821
D5      Diodo rectificador 1N4007
JP2     JUMPER
K1      Relé SRA-12VDC-CL
P1      Conector MOLEX CI macho 7
Q1      Transistor MOSFET IRL540N
R1      Resistencia 10K 1/4W
R2      5K 1/4W
R3      10K 1/4W
R4      100R 1/4W
R5      30K
U1      ATTINY85/DIP-SO
U2      LM7805
(Portafusibles aéreo y fusible 15A)

Realización

Esta vez he realizado el circuito con KiCad, al final de esta página, en el apartado de descargas encontrarás el enlace al archivo de descarga con el esquema, PCB de KiCad y el paperdocumento preparado para su impresión.

Una vez descargado el documento, y descomprimido, puedes cargar los datos en Kicadm o simplemente puedes imprimir el documento PaperATtinyMosfet.pdf (sin aplicar ningún tipo de escala)

En la parte inferior del documento tienes la placa PCB (espejo) preparada para su transferencia a la capa de cobre (bien por el método de la plancha, o por fotosensibilización).

Las dimensiones de la placa están definidas por la carcasa contenedora, ya que este circuito sustituye al original de un carro de golf motorizado. (a continuación la versión original estropeada)

Aquí vemos la cara componentes de la placa

A continuación la versión definitiva

Un detalle del circuito de mando (potenciometro y led bicolor del carro):

Y del motor (tiene bastante potencia):

Y por último un vídeo del carrito funcionando, dirigido por la mano diestra de mi cuñado :-)

Programa

El archivo PaperATTinyMosfet.pde lo tienes en el archivo de descargas disponible en el enlace al final de esta página, (lo siento, pero he intentado poner el programa pero blogger se vuelve loco y no representa correctamente la página.)
El sketch hay que grabarlo en el ATtiny a través de un programador, o puedes utilizar el ATtinyProgrammer donde se usa el Arduino como programador, y el entorno Arduino para programarlo.

En el programa se consideran los siguientes límites de la batería:
V mayor que 12v = verde
V entre 12 y 11,6 = naranja
V menor que 11,6 = rojo

Estos valores dependen de la batería que utilices y del consumo del motor, así que tal vez tengas que modificarlos. Para ayudarte en esa tarea tienes en el archivo de descargas una hoja de cálculo.

Información legal

Descargas

El esquema, descripción e imágenes están disponibles en el siguiente enlace:

PaperBluetooth: Bluetooth Shield para Arduino

2009-12-12T12:28:00.000+01:00

Descripción

Ultimamente están apareciendo módulos bluetooth bastante económicos (<5€), Estos módulos permiten la conexión serie por bluetooth entre Arduino (Esclavo) y un PC o móvil (Maestro), la única pega que tienen es que están alimentados con 3,3v.
El presente proyecto simplemente es un adaptador para Arduino de uno de estos módulos.

Esquema

El circuito que utilizaremos es una simplificación de los circuitos que existen en internet de los diferentes módulos más o menos compatibles, pero partiendo de las indicaciones dadas para el módulo SURE GP-GC021.

Como puedes ver en el esquema conectamos la salida TX del módulo directamente a la entrada de arduino, ya que según las características del chip ATMega, considera como nivel alto cualquier valor que esté por encima de 0,6Vcc. Por lo que si lo alimentamos con 5v => 0,6x5=3, valor inferior al que nos da el módulo bluetooth SURE.

La entrada RX del módulo (3,3v) la tomamos de un divisor de tensión formado por las resistencias R1 (5K6) y R2 (10K) acoplado entre la patilla Tx (5v) de Arduino y masa (0v)
Si despreciamos la intensidad de entrada en el módulo bluetooth:
I=Vcc/(R1+R2)
Luego la caída de tensión que esta intensidad generará en la resistencia R2=
Vo=R2*I=R2*Vcc/(R1+R2)=10*5/(15,6)=3,2v
Que es un valor compatible con la tensión de entrada del módulo.

En la la patilla de Reset del módulo colocamos una resistencia Pull-Up a Vcc (se activa a nivel bajo).

Las patillas 13,14,21 y 22 a masa.

NOTA: Si utilizas otro módulo compatible comprueba mirando en sus hojas de características si es necesario llevar a masa la patilla 14.

En algunos módulos se puede conectar en la patilla 24 un LED que nos indica el estado del mismo.

Por defecto el módulo SURE tiene una velocidad de 9600 baudios, pero parece que se puede modificar mediante instrucciones AT, para lo cual es necesario puentear los terminales 3 (CTS) y 4 (RTS) según las instrucciones indicadas en:

http://www.circuit-blog.com/how-to-change-baud-rate-of-bluetooth-modem-bluesmirf-gold-using-arduino-terminal/

La placa tiene prevista la alimentación a partir de los 5v de la placa Arduino (~500mA) mediante la colocación en serie de dos diodos rectificadores que provocan cada uno una caida de tensión de 0,7v) es decir 5-0,7*2= 3,6v (admisible de 2,2v a 4,2v).
Otra posibilidad es utilizar la tensión de 3,3v disponibles en la placa Arduino que puede suministrar como máximo 50 mA, intensidad suficiente para el módulo de SURE GP-GC021 que consume como máximo 10mA según su hoja de características.

NOTA:

Lo que no debemos hacer es conectar la alimentación de 5v (rebajada con los diodos a 3,6v) y la alimentación de 3,3v, ya que estaríamos alimentando el módulo simultáneamente con 3,6v y con 3,3v !!

Realización

Lo primero es localizar el módulo

una vez que lo tengamos :-) ...

Utilizaremos el método Paper, que consiste en ayudarnos en unas pegatinas para facilitarnos el proceso de montaje y soldadura.

Primero imprimiremos (sin aplicar ningún tipo de escala) el documento PaperBluetooth, lo puedes descargar del enlace de la parte inferior de esta página en el apartado de descargas:

En el documento tenemos tres posibilidades de realización, una con circuito impreso, y las otras dos con stripboard, con todos los pines disponibles (para poder conectar más shield, y una placa sencilla que ocupa los terminales de GND, 5v y 3,3v , y TX y RX. Vamos a ver como realizar ésta última variante:

Si quieres puedes proteger la paperetiqueta con un poco de plástico transparente autoadhesivo (aironfix):

Si quieres puedes proteger con un poco de plástico transparente la paperetiqueta antes de recortarla.

Con un cutter cortamos un trozo de stripboard de 12 tiras x 20 agujeros

Primero lo marcamos

Con un cutter cortamos la placa trazando el corte sobre la línea de agujeros para facilitar la rotura de las piezas.

Con una ligera presión separamos las piezas

Ahora recortamos la placa para permitir el acceso a los terminales del Arduino, que la placa bluetooth no utiliza (es importante profundizar en la esquina indicada en la figura por los dos lados de la placa).

Con unos alicates flexionamos ligeramente hacia arriba y hacia abajo hasta que se separen los recortes.

Aplicamos adhesivo

Con ayuda de una aguja la colocamos de forma que los agujeros de la paperetiqueta coincidan con la placa de stripboard, y perforamos todos los agujeros de la paperetiqueta que necesitemos.

Desplazamos los pines macho, ya que los vamos a soldar por la parte inferior

Y soldamos los diferentes componentes. Para soldar el módulo, lo que he hecho, ha sido soldar trozos de cable a la placa, para posteriormente colocando el módulo sobre la placa podemos soldar uno a uno estos cables

Para soldar los componentes y para cortar las pistas inferiores fíjate en el dibujo del paperdocumento:

Y este es el resultado final

Notas:

Como ves, no he conectado ningún led, y la señal de alimentación de 3,3v la tomo directamente de la placa Arduino no he colocado los diodos que puentean 5v y 3,3v)

Y lo podemos conectar en el Arduino (fíjate que dejamos el pin de reset libre)

INSTALACION (en Ubuntu)

Para probar nuestro circuito deberemos instalar en ubuntu con el administrador de aplicaciones el gestor de bluetooth "Blueman", ya que el applet de la barra superior que viene por defecto no nos permite activar el servicio de puerto serie.

Al conectar nuestro bluetooth en el ordenador, aparecerá un icono nuevo en la barra superior, y al hacer click sobre él se nos abrirá el programa.

Ahora alimentaremos nuestro Arduino con la placa Bluetooth conectada, y apretamos sobre el botón Buscar del programa Blueman, y nos aparecerá la lista de dispositivos bluetooth disponibles (en mi caso solamente el módulo Sure) :

Lo seleccionamos y apretamos el botón configurar, con lo que se nos abrirá una ventana para emparejarlo con nuestro ordenador:

Seleccionamos la segunda opción e introducimos la contraseña "1234" (tal vez tu módulo necesite introducir "0000").

El programa nos solicita que introduzcamos la clave en nuestro módulo bluetooth: EINGG??!! cómo voy a hacer eso!! así que no hago nada y espero un poco...

Oh no!! el programa falló!! no te preocupes, al cerrar la ventana vemos que el dispositivo está conectado (fíjate en el icono de la llave)

Ahora que está emparejado, podemos habilitar el servicio de puerto serie, para lo cual, teniéndo seleccionado el icono del módulo Sure, volvemos a apretar el botón de configuración, y nos aparecerá una ventana con los servicios disponibles:

Seleccionamos el puerto serie y apretamos el botón de "Adelante", al cabo de un ratito, el sistema nos indicará en la parte superior derecha de la pantalla que se ha habilitado un puerto serie en /dev/rfcomm0:

y el icono de Bluemon de la barra superior de la pantalla del ordenador indicará que tenemos una conexión bluetooth activa:

Ahora ya podemos utilizarlo!!

Si quieres, colocando el cursor sobre los iconos de la derecha de Bluemon, puedes ver la calidad de conexión de tu módulo:

Ejemplo: Dimmer.pde

Un ejemplo muy sencillo de uso es utilizar el programa de ejemplo del entorno Arduino dimmer (Arduino/menu/File/Examples/Communication/Dimmer).

Tienes más información en el documento disponible al final de este documento en el apartado de descargas (en la carpeta Sketches):

Este programa espera a recibir un valor byte (0-255) del puerto serie y cuando lo recibe, ilumina más o menos un led conectado en la patilla 9, como nuestra placa bluetooth dispone del servicio serie, y está conectada a los terminales TX y RX de Arduino, lo que reciba por bluetooth se lo transmitirá a Arduino como si fuera a través del cable USB.

Lo primero que deberemos hacer es cargar el programa Dimmer en nuestro Arduino. El proceso de carga lo haremos por el método habitual, es decir a través del cable USB. Tal vez tengas problemas de carga si tienes el módulo bluetooth conectado al Arduino, ya que también utiliza los terminales Tx y Rx del Arduino. (en este caso quita el módulo bluetooth del Arduino).

Conectaremos el terminal positivo (el más largo) de un led al pin 9 de Arduino, y el negativo a través de una resistencia (de 330 Ohmnios a 1K) a GND.

Desde el PC necesitaremos un terminal serie que permita configurar el puerto serie, yo lo he intentado con el que incorpora el entorno Arduino, pero no he conseguido conectarlo al puerto /dev/rfcomm0, así que me he descargado con el administrador de aplicaciones el GTKTerm que se instala en Aplicaciones/Accesorios/Serial Port Terminal.

En este programa podemos configurarle para que se conecte a través del puerto rfcomm0 (GKTTerm/Menu/Configuration/Port) :

Y ahora lo que escribamos en pantalla lo recibirá nuestro Arduino, encendiendo más o menos el LED.

Debes tener en cuenta que lo que mandas es un Byte, y que los teclados de ordenador están codificados en ASCII, es decir cuando aprietas la tecla A envías el byte 65. A continuación tienes una lista de los códigos ASCII del 00 al 255 que utiliza un teclado de PC:

Para probar el funcionamiento del módulo, puedes apretar las siguientes teclas:
<- (Tecla retroceso): 08 => LED iluminación baja
z (letra z minúscula):122 => LED iluminación intermedia
º (símbolo de grado):248 => LED iluminación alta

NOTA: Cuando escribes en el terminal las teclas que escribes no se visualizan en pantalla, ya que se envían al Arduino, si quieres que se muestren, debes activar el "Eco local" (GTKTerm/Menu/Configuration/Local echo)

Ejemplo: LEDSerial.pde

En este ejemplo encenderemos y apagaremos 8 LEDS desde un terminal (ya sabes, quien enciende un LED mueve el mundo!!) , y en vez de conectar el PC con el Arduino, conectaremos un móvil con Android.

El móvil debe tener instalado un terminal serie bluetooth, yo he utilizado Blueterm, descargable desde Android Market. Este programa es un terminal serie, que envía los comandos que escribas directamente por el bluetooth del móvil.

El hardware consistirá en un conjunto de diodos LED (con su correspondiente resistencia) conectados entre las patillas 6-13 y masa, aunque yo he utilizado el PaperLED

Tienes más información en el archivo de descargas (directorio sketches) disponible en el enlace situado al final de esta página.

Los pasos a realizar son los siguientes:

1 Instalar el sketch LEDSerial.pde en el Arduino

(El archivo LEDSerial.pde lo tienes en el archivo de descargas disponible en el enlace al final de esta página)

/*
LED Serie

Este ejemplo se muestra como encender diferentes leds en funcin de los datos que Arduino
reciba por el puerto serie. Los datos son enviados como bytes individuales, comprendidos en el rango de 0 a 255.

Hardware:
LEDs conectados entre los pines 6-13 a masa (con su correspondiente resistencia).
Un Vibrador de 5v entre el pin 5 y masa
Conexion serie (cable USB, Modulo bluetooth, Max232 ...)
Terminal serie desde PC o movil

creado en 2011
Iñigo Zuluaga
www.txapuzas.blogspot.com

Este codigo es de dominio publico.

*/

const int BuzzerPin = 5;    // Pin en el que se conecta el vibrador
const int LedPin1 = 6;      // Pin en el que se conecta el LED 1
const int LedPin2 = 7;      // Pin en el que se conecta el LED 2
const int LedPin3 = 8;      // Pin en el que se conecta el LED 3
const int LedPin4 = 9;      // Pin en el que se conecta el LED 4
const int LedPin5 = 10;     // Pin en el que se conecta el LED 5
const int LedPin6 = 11;     // Pin en el que se conecta el LED 6
const int LedPin7 = 12;     // Pin en el que se conecta el LED 7
const int LedPin8 = 13;     // Pin en el que se conecta el LED 8

void setup()
{
// configura la comunicacion serie:
Serial.begin(9600);
// configura los pines de los leds y buzzer como salida:
pinMode(BuzzerPin, OUTPUT);
pinMode(LedPin1, OUTPUT);
pinMode(LedPin2, OUTPUT);
pinMode(LedPin3, OUTPUT);
pinMode(LedPin4, OUTPUT);
pinMode(LedPin5, OUTPUT);
pinMode(LedPin6, OUTPUT);
pinMode(LedPin7, OUTPUT);
pinMode(LedPin8, OUTPUT);
}

void loop() {
byte dato;
char* mensaje;

// mira si se ha recibido algo del puerto serie:
if (Serial.available()) {
    // lee el ultimo byte recibido (valor entre 0 y 255)
    dato=Serial.read();
    switch(dato){
      case 113: // q
        digitalWrite(LedPin1, HIGH);   // enciende el LED 1
        mensaje="LED 1 Encendido";
        break;
      case 97: // a
        digitalWrite(LedPin1, LOW);   // apaga el LED 1
        mensaje="LED 1 Apagado";
        break;
      case 119: // w
        digitalWrite(LedPin2, HIGH);   // enciende el LED 2
        mensaje="LED 2 Encendido";
        break;
      case 115: //s
        digitalWrite(LedPin2, LOW);   // apaga el LED 2
        mensaje="LED 2 Apagado";
        break;
      case 101: // e
        digitalWrite(LedPin3, HIGH);   // enciende el LED 3
        mensaje="LED 3 Encendido";
        break;
      case 100: // d
        digitalWrite(LedPin3, LOW);   // apaga el LED 3
        mensaje="LED 3 Apagado";
        break;
      case 114: // r
        digitalWrite(LedPin4, HIGH);   // enciende el LED 4
        mensaje="LED 4 Encendido";
        break;
      case 102: // f
        digitalWrite(LedPin4, LOW);   // apaga el LED 4
        mensaje="LED 4 Apagado";
        break;
      case 116: // t
        digitalWrite(LedPin5, HIGH);   // enciende el LED 5
        mensaje="LED 5 Encendido";
        break;
      case 103: // g
        digitalWrite(LedPin5, LOW);   // apaga el LED 5
        mensaje="LED 5 Apagado";
        break;
      case 121: // y
        digitalWrite(LedPin6, HIGH);   // enciende el LED 6
        mensaje="LED 6 Encendido";
        break;
      case 104: // h
        digitalWrite(LedPin6, LOW);   // apaga el LED 6
        mensaje="LED 6 Apagado";
        break;
      case 117: // u
        digitalWrite(LedPin7, HIGH);   // enciende el LED 7
        mensaje="LED 7 Encendido";
        break;
      case 106: //j
        digitalWrite(LedPin7, LOW);   // apaga el LED 7
        mensaje="LED 7 Apagado";
        break;
       case 105: // i
        digitalWrite(LedPin8, HIGH);   // enciende el LED 8
        mensaje="LED 8 Encendido";
        break;
      case 107: // k
        digitalWrite(LedPin8, LOW);   // apaga el LED 8
        mensaje="LED 8 Apagado";
        break;
     case 122: // z
        digitalWrite(LedPin1, HIGH);   // enciende TODOS los LEDs
        digitalWrite(LedPin2, HIGH);
        digitalWrite(LedPin3, HIGH);
        digitalWrite(LedPin4, HIGH);
        digitalWrite(LedPin5, HIGH);
        digitalWrite(LedPin6, HIGH);
        digitalWrite(LedPin7, HIGH);
        digitalWrite(LedPin8, HIGH);
        mensaje="TODOS los LEDs Encendidos";
        break;
      case 109: // m
        digitalWrite(LedPin1, LOW);   // apaga TODOS los LEDs
        digitalWrite(LedPin2, LOW);
        digitalWrite(LedPin3, LOW);
        digitalWrite(LedPin4, LOW);
        digitalWrite(LedPin5, LOW);
        digitalWrite(LedPin6, LOW);
        digitalWrite(LedPin7, LOW);
        digitalWrite(LedPin8, LOW);
        mensaje="TODOS los LEDs Apagados";
        break;
      default:
        Serial.print(dato);
        Serial.print(": ");
        mensaje="Tecla no admitida !";
        digitalWrite(BuzzerPin, HIGH);
        delay(200);
        digitalWrite(BuzzerPin, LOW);
        delay(200);
    }
    // Emite un pitido
    digitalWrite(BuzzerPin, HIGH);
    delay(200);
    digitalWrite(BuzzerPin, LOW);
    // Envia respuesta
    Serial.println(mensaje);
}
}

El sketch hay que grabarlo a través del cable USB, y desconectando el módulo PaperBluetooth, ya que como el módulo utiliza los terminales TX y RX interfiere en la grabación.

2 Conectar en la placa Arduino el módulo bluetooth, los leds (PaperLED), y el vibrador.

3 Alimentar el arduino

4 Activar la Wifi en el móvil y desde el Market descargar el programa "BlueTerm"
5 Activar el Bluetooth
6 Ejecutar el programa "BlueTerm"
7 En el menú del programa seleccionar "Conectarse a un dispositivo"
8 La primera vez tendrás que apretar "Buscar dispositivos" y emparejarlo con el dispositivo SURE con la clave "1234" o "0000", posteriormente simplemente seleccionaremos "Sure" de la lista de dispositivos sincronizados.
9 Una vez sincronizados, puedes enviar comandos al Arduino.

Los teclas (Bytes) de control son:

LED	Encencer	Apagar
1	q (113)	a (97)
2	w (119)	s (115)
3	e (101)	d (100)
4	r (114)	f (102)
5	t (116)	g (103)
6	y (121)	h (104)
7	u (117)	j (106)
8	i (105)	k (107)
Todos	z (122)	m (109)

Nota: En el video no se aprecia el sonido del buzzer ya que la cámara no lo percibe.

Información legal

Descargas

El esquema, descripción e imágenes están disponibles en el siguiente enlace:

PaperRS232: Convertidor RS232-TTL para Paperduino

2009-12-12T12:27:00.004+01:00

Descripción

Como el Paperduino no tiene chip USB, no podemos conectarlo directamente al PC. Para conectarlo podemos utilizar el PaperFTDI, o tambien podemos realizar el circuito que explicamos a continuación.

El PaperRS232 es un convertidor de señal para Paperduino. Permite conectar el puerto serie del PC que trabaja con tensiones +12v (LOW) y -12V (HIGH) con las patillas RX y TX del Paperduino que trabajan con tensiones TTL convencionales +5v (HIGH) y 0v (LOW).

Con este convertidor podremos transferir los programas (sketches) al paperduino, y posteriormente comunicar con el terminal serie integrado en el entorno de programación de Arduino.

Esquema

El circuito que utilizaremos es el que explica el fabricante en el datasheet del integrado Max232:

De los dos convertidores de señal que tiene el chip, utilizamos 1'5, es decir las señales de TX, RX y RTS.

Realización

El método Paper consiste en ayudarnos en unas pegatinas para facilitarnos el proceso de montaje y soldadura.

Primero imprimiremos (sin aplicar ningún tipo de escala) el documento PaperRS232, disponible en la parte inferior de esta página en el apartado de Descargas:

Después cortaremos la paperetiqueta

Si quieres puedes proteger con un poco de plástico transparente la paperetiqueta

Antes de recortarla:

Y para finalizar la paperetiqueta, le aplicamos adhesivo de doble cara, y la pegamos sobre un trozo de stripboard de 11 filas x 14 agujeros. Para que coincidan los dibujos de la etiqueta con los agujeros del stripboard, podemos ayudarnos de una aguja.

Punzonamos con una aguja todos los agujeros utilizados por los componentes (podemos comprobar al trasluz que están todos los agujeros perforados)

Una vez que tenemos la placa preparada, podemos colocar los puentes (los hago con un trozo de cable unifilar pelado), y los componentes. Debes fijarte en la polaridad de los condensadores electrolíticos.

Yo suelo cortar las pistas de la parte inferior una vez que tengo soldados los componentes. Puedes utilizar la imagen del Paperdocumento como referencia:

Y este es el resultado final

En este circuito he utilizado un cable serie viejo al que he cortado un terminal. Con un tester he identificado los cables, y luego he soldado los cables 2,3,4,5 a la placa. (Posteriormente he reforzado la unión de los cables con la placa con un poco de adhesivo termofusible).
La disposición de estos pines en la placa permiten que sueldes directamente un conector de 9 pines en la placa y luego utilizar un cable con dos conectores.

NOTA: La mejor forma de identificar los pines del conector es fijarse en los números que están en el interior del conector.

A la hora de utilizarlo, debes tener en cuenta que el PaperRS232 toma la alimentación del Paperduino, por lo que debes tener el Paperduino conectado a una fuente de alimentación, y en el Paperduino conectar el terminal 3 del conector FTDI a 5v. En la imagen se puede ver un cable rojo que conecta el pin 3 del conector FTDI, ya que en la placa está desconectado este terminal de 5V. (En el PaperDocumento te explica cómo hacerlo )

A continuación un ejemplo de utilización. Como ves no es necesario apretar el botón de Reset del Paperduino para programarlo (el entorno de programación de Arduino lo hace automáticamente).

En el ejemplo anterior se reprograma el sketch "blink" modificando el parpadeo de 1 segundo a 100 milisegundos.

El proceso es muy sencillo:
1. Arrancamos el entorno de programación Arduino.
(lo puedes descargar en:http://arduino.cc/en/Main/Software)
2. En el menú "Tools/Board" Seleccionamos el tipo de placa que utilizamos (Si es Paperduino, dependiendo del micro que utilicemos será "Duemilanove w/328" o "Diecimila o Duemilanove w/168").
3. En el menú "Tools/Serial Port" seleccionamos el puerto serie al que está conectado el PaperRS232. (Recuerda que recibe la alimentación del Paperduino, por lo que el Paperduino ha de estar conectado a una fuente de alimentación).
4. Abrimos en el editor el programa que queramos cargar al micro.
5. Apretamos el sexto icono "Upload" de la barra de herramientas superior del entorno de programación Arduino. Primeramente compilará el programa, y luego procederá a su grabación en el chip.

Si no se produce ningún error, en la barra de estado pondrá "Uploading..." y finalmente "Uploaded" !!.

Enlaces de Interés

Te pueden interesar los enlaces siguientes

Marco Ritrivi tiene este mismo circuito realizado sobre un PCB (el conector de conexionado no coincide con el Paperduino), además de una variante de paperduino con una disposición standar de los pines, para que sea compatible con los shields existentes.
YOPERO ha realizado una modificación al circuito de Marco para posibilitar su uso con paperduino. El circuito de esta página web es el mismo que el de YOPERO, ( de hecho, el circuito que había diseñado no tenía Reset automático, pero después de contactar con Yopero, le he copiado el diseño).
En vez de utilizar este circuito puedes utilizar el PaperFTDI, que te posibilita conectar Paperduino con el PC a traves de un puerto USB.

NOTA: Tanto Marco como Yopero utilizan condensadores de 100nF y les funcionan correctamente. (Yo he utilizado condensadores de 1uF tal y como indica el datasheet del MAX232)

Información legal

Descargas

El esquema, descripción e imágenes están disponibles en el siguiente enlace:

PaperDimmerLDR: Control de potencia de un Triac con un microcontrolador

2009-12-12T12:26:00.003+01:00

Descripción

En esta página, veremos un método de controlar un triac mediante un microcontrolador. La idea es modificar la resistencia de carga de un diac de disparo con una resistencia LDR variando la luz que recibe, esta variación la realizamos al regular la intensidad luminosa de un led mediante el control de pulsos (PWM).

Esquema

El esquema de este circuito está basado en el PaperDimmer, pero sustituyendo las resistencias de carga del triac por una LDR.

Al realizar el montaje, me he dado cuenta de que aunque la resistencia de la LDR sea (según su datasheet) bastante lineal, la tensión de salida crece rápidamente al dar tensión al LED.

En la gráfica (Tensión-AnalogWrite) vemos que al inicio con valores pequeños de tensión crece rápidamente la tensión de salida del triac, y posteriormente necesitamos suministrar gran tensión al LED para que el valor de la tensión de salida se incremente.

Estos valores dependen de la LDR utilizada, y de su LED asociado, por lo que lo mejor es mediante el método de prueba y error encontrar los valores que hay que suministrar en la salida del micro para obtener valores compensados en la carga del triac.

Realización

Este circuito podemos realizarlo con un circuito impreso:

utilizando un Stripboard:

O directamente con unas regletas o clemas:

Veremos un ejemplo de este último método.

Si quieres puedes descargar el documento PaperDimmerLDR (al final de esta página en el apartado descargas) para tenerlo accesible.

Lo único que tendremos que hacer es recortar un poco el plástico de las clemas donde van el condensador y el triac, para permitir que las patillas del entren en la clema lo suficiente.

Antes de nada deberemos hacer nuestro optoacoplador, que consistirá en un led y una resistencia LDR y un trozo de tubo termoretráctil

Puedes probar distintas resistencias y diferentes leds, en función de ello deberás modificar el programa para ajustar los valores de la tensión de alimentación del led. Introducimos el LED y la LDR en el tubo...

Y le aplicamos un poco de calor

(perdona la calidad de la iagen, pero es dificil sujetar una cerilla, el optoacoplador y la cámara simultáneamente :-) )

Puede ser necesario repetir este proceso varias veces, o incluso forrarlo con cinta adhesiva para impedir que la luminosidad del ambiente afecte a las tensiones.

Fijándonos en la imagen inferior, colocamos los elementos en una clema (dependiendo del tamaño del condensador C1, tal vez necesites cortar la clema).

Y el resultado es el siguiente:

A continuación vemos un ejemplo utilizando el sketch Fade_triac (Fade ligeramente modificado para adaptar los valores de salida):

/*
Fade (modificado)

This example shows how to fade an LED on pin 9
using the analogWrite() function.

This example code is in the public domain.

*/
int brightness = 0;    // how bright the LED is
int fadeAmount = 1;    // how many points to fade the LED by
int brillomax=19;      // 20 (19+1) valores de la matriz de brillo
int brillo[20]={0,3,5,6,7,8,9,10,11,12,14,16,18,20,23,26,30,40,50,60};

void setup() {
// declare pin 9 to be an output:
pinMode(9, OUTPUT);
Serial.begin(9600);

}

void loop() {
// set the brightness of pin 9:
analogWrite(9, brillo[brightness]);
Serial.println(brillo[brightness], DEC);
// change the brightness for next time through the loop:
brightness = brightness + fadeAmount;

// reverse the direction of the fading at the ends of the fade:
if (brightness == 0 || brightness == brillomax) {
    fadeAmount = -fadeAmount ;
}
// wait to see the dimming effect

delay(100);
}

Nota:

Como la cámara de video tiene compensación automática de la luminosidad no se aprecia correctamente el encendido gradual de la lámpara (la he protegido con un papel para que no deslumbre mucho).

Enlaces de Interés

Tal vez te interesen estos otros paper:
http://txapuzas.blogspot.com/2010/06/regulador-de-potencia-por-triac-para.html
http://txapuzas.blogspot.com/2010/07/rele-controlado-por-transistor.html
http://txapuzas.blogspot.com/2010/09/micropaperrele-carta-de-reles.html

Información legal

Descargas

El esquema, descripción e imágenes están disponibles en el siguiente enlace:

PaperATtinyProgrammer: Un programador para ATtiny usando un Arduino como ISP

2009-12-12T12:25:00.012+01:00

Programando el ATtiny45 / ATtiny85 con Arduino

(Esta página es traducción de http://hlt.media.mit.edu/wiki/pmwiki.php?n=Main.ArduinoATtiny4585)

Este tutorial muestra como programar un microcontrolador Attiny45 o un ATtiny85 utilizando una placa Arduino y el entorno de programación Arduino. El ATtiny45 y el ATtiny85 son unos microprocesadores pequeños (8-patas) y económicos ($2-3); Son casi idénticos, excepto que el ATtiny85 tiene el doble de memoria que el ATtiny45 y puede por lo tanto manejar programas más complejos. Para programarlos utilizaremos una modificación de las librerías de Arduino creadas por Alessandro Saporetti y ligeramente modificados por HLT (http://hlt.media.mit.edu/wiki/pmwiki.php?n=Main.ArduinoATtiny4585).

Materiales y Herramientas

Para realizar este tutorial (para la variante breadboard) necesitarás:

Arduino Uno or Duemilanove (con un ATmega328, no son válidos las placas antiguas con un ATmega168)
ATtiny45 o ATtiny85 (encapsulado 8-patillas)
Un condensador de 10 uF (e.g. from Sparkfun or from Digi-Key)
Una placa de prototipado (breadboard).
Cables de conexionado

Software

Necesitarás el entorno de programación Arduino. Si no lo tienes todavía, puedes d escargarlo desde la página web de Arduino. Las instrucciones de instalación están disponibles para Windows y para Mac OS X.

El microcontrolador ATtiny45 / ATtiny85

Aquí está el patillaje del ATtiny45 y ATtiny85:

Instalando en Arduino el soporte para ATtiny45 / ATtiny85

Descarga: attiny45_85.zip
Busca la carpeta de Arduino “sketchbook” (puedes encontrar su situación en el diálogo de preferencias del entorno de programación Arduino)
Crea una nueva subcarpeta llamada "hardware" en la carpeta “sketchbook”.
Copia la carpeta attiny45_85 de attiny45_85.zip a la carpeta “hardware”.
Reinicia el entorno de programación Arduino.

Transformando la placa de Arduino en un programador

Ahora utilizaremos la placa Arduino para programar el ATtiny45 o ATtiny85. Primero necesitaremos convertir la placa Arduino en un programador ISP ( "In-System Programmer").
Para ello:

Arranca el entorno de programación Arduino.
Abre el sketch “ArduinoISP” del menú de ejemplos (examples).
Selecciona la placa y el puerto serie que corresponden a tu placa Arduino.
Carga el sketch “ArduinoISP”.

Conectando la placa Arduino y el ATtiny

Conectaremos la placa Arduino al ATtiny tal como se indica en el siguiente diagrama. Utiliza el punto (pin 1) de la esquina del ATtiny para orientarlo correctamente. También conectaremos un condensador electrolítico de 10uF entre reset y masa en la placa Arduino como se indica en la imagen (La banda del condensador marcada con un signo negativo (-) debe ir a masa (GRD). (Sólo se necesita el condensador si se utiliza una placa Arduino Uno, no es necesario con un Arduino Duemilanove.)

Conexionado de las patillas:

ATtiny Pin 7 (D2) a Arduino D13 (SCK)
ATtiny Pin 6 (D1) a Arduino D12 (MISO)
ATtiny Pin 5 (D0) a Arduino D11 (MOSI)
ATtiny Pin 1 (Reset-D5) a Arduino D10

Programando el ATtiny45 o ATtiny85

Ahora podemos utilizar el Arduino como un programador ISP para cargar el programa al ATtiny45/85:

Abrimos el sketch “Blink” desde el menú de ejemplos (examples).
Cambiamos los números de pin de 13 a 0. (Si realizas el PaperATtinyProgrammerPCB o PaperATtinyProgrammerStripboard, el led está conectado en el PIN D5)
Seleccionamos "ATtiny45 (w/ Arduino as ISP)" o "ATtiny85 (w/ Arduino as ISP)" en el menú Herramientas/Placa (Tools > Board) (Indicando previamente el puerto serie al que está conectada la placa Arduino).
Cargamos el sketch.

Es probable que aparezca el siguiente mensaje, pero no hay que preocuparse la programación debería haberse efectuado correctamente:

avrdude: please define PAGEL and BS2 signals in the configuration file for part ATtiny85
avrdude: please define PAGEL and BS2 signals in the configuration file for part ATtiny85

Ahora, conectamos el LED y comprobamos que parpadea.

Referencia

Los siguientes comandos de Arduino deberían funcionar correctamente:

NOTA: Estos comandos son los específicos de Arduino (dependen de la velocidad del micro, interrupciones, registros específicos...) , desde luego los comandos standard del lenguaje de programación "C" : "if"‚ "case" y similares también funcionan.

Si tienes intención de trabajar a menudo con microcontroladores ATtiny45/85, quizás te interese realizar un circuito un poco más estable, vamos a ver como realizarlo sobre un stripboard (también si quieres puedes hacer tu propio PCB).

Realización

El método Paper consiste en ayudarnos en unas pegatinas para facilitarnos el proceso de montaje y soldadura.

Primero imprimiremos el documento PaperATtinyProgrammer (disponible en la parte inferior de esta página en el apartado de Descargas):

Primeramente cortaremos la paperetiqueta

Si quieres puedes proteger con un poco de plástico transparente la paperetiqueta

Antes de recortarla:

Y para finalizar la paperetiqueta, le aplicamos adhesivo de doble cara

Posteriormente cortamos una placa de stripboard de 7 filas por 20 agujeros, podemos hacerlo fácilmente si con un cutter marcamos por las dos caras sobre una fila de agujeros.

Y luego con la mano suavemente flexionas alternativamente la placa y se romperá por la zona debilitada.

Finalmente lijamos los cantos para darle un mejor aspecto

Con ayuda de una (o varias) agujas se posiciona la paperetiqueta de forma que coincidan los agujeros de la placa con los dibujos de la paperetiqueta

Punzonamos con una aguja todos los agujeros utilizados por los componentes (podemos comprobar al trasluz que están todos los agujeros perforados)

Y sólo nos queda montar los componentes tal y como se indica en la paperetiqueta. Deberás prestar atención a la posición del LED y del Condensador electrolítico (Si lo utilizas, ya que sólo es necesario para Arduino UNO).

Como los pines (yo he utilizado largos, pero puedes usar normales) se sueldan por la parte inferior, es necesario desplazar el plástico soporte a un extremo del pin.

Una vez soldados todos los elementos (que no se te olviden los puentes!), deberemos cortar algunas pistas tomando como referencia la imagen del documento impreso

Y ya tenemos listo nuestro maravilloso programador!!

Al utilizarlo deberemos tener cuidado de conectar nuestro Shield en los pines adecuados de Arduino. (D13-D10 y Reset-GND)

como ves en la imagen, aunque los pines del Arduino no coinciden exactamente con los pines del Shield, no hay problemas para conectarlo, simplemente el PaperATtiny queda ligeramente inclinado.

Al Programar hemos de tener en cuenta que el ATtiny sólo tiene 6 pines de control, y que el led está conectado en el pin 4 en vez del pin 13. De forma que si queremos ver en funcionamiento el programa blink:

A continuación vemos como se programa el sketch Blink en un ATtiny85 modificando el valor del delay de 1000 a 100.

PaperATtinyCable

Un problema que tiene PaperATtinyProgrammer, es que cada vez que quieres realizar una modificación en el sketch, debes sacar el chip de la placa del circuito y conectarlo en el PaperATtinyProgrammer. Una alternativa es realizar en la placa del circuito un conector que nos permita utilizar el PaperATtinyCable.

Para realizarlo, sólo utilizaremos unos conectores de pines hembra (4+4) y unos conectores macho (5+1) y un trozo de cable plano.

Puedes obtener el cable plano de un ordenador antiguo:

Cortamos un trozo de aproximadamente 30cms x 6hilos:

Separamos ligeramente los extremos y los pelamos, y fijándonos en la imagen siguiente (está en el paperdocumento):

Soldamos los terminales:

En el paperdocumento, tienes preparadas para recortar una etiquetas identificativas de los terminales de los conectores.

Para poder fijarlas, he utilizado adhesivo de doble cara:

Una vez pegada, con un poco de cello la protegemos he impedimos que se suelte:

He aquí el resultado final:

Ahora, cada vez que realices un circuito con un ATtiny recuerda que debes poner unos conectores de programación similares a:

Enlaces de Interés

Te pueden interesar los enlaces siguientes

Información legal

Descargas

El esquema, descripción e imágenes están disponibles en el siguiente enlace:

ClemaRelé: Control de un relé sin circuito impreso

2009-12-12T09:24:00.004+01:00

Descripción

En esta página, veremos un método muy sencillo de conectar un relé convencional a un microcontrolador sin necesidad de hacer un circuito impreso, utilizando un transistor FET.

¿Qué es un transistor F.E.T.?

Un Transistor FET (o de Efecto de Campo) es un tipo de transistor que simplificando, podríamos decir que entra en modo de conmutación simplemente aplicando una tensión en su patilla de puerta (GATE), y sin casi caída de tensión entre sus terminales de drenador (DRAIN) y fuente (SOURCE).

Este tipo de transistores son bastante sensibles a las cargas electroestáticas, así que procura no tocar los terminales (ni los cables a los que está conectado) con las manos.

Esquema

El esquema de este circuito es muy simple, y consta sólamente de un diodo rectificador, un transistor FET y un relé.

El transistor trabaja como un interruptor activado por tensión en la patilla G, y el diodo D1 evita que la energía de la bobina del relé pueda estropear el transistor, o que se quede "pegado".

Realización

Si queremos podemos imprimir el documento clemaRelé en el apartado de descargas, para tenerlo accesible.

Lo único que tendremos que hacer es recortar un poco el plástico de la clema, para permitir que las patillas del relé entren en la clema lo suficiente (las dos de la parte inferior derecha).

Fijándonos en las imágenes inferiores, colocamos los elementos en una clema de cuatro bornas

Y el resultado es el siguiente:

A continuación vemos un ejemplo de funcionamiento del skecht "blink", conectando el cable azul (IN) a la patilla 13, y como el relé es de 12v está alimentado con un paquetito de baterías.

Enlaces de Interés

Tal vez te interesen otros paper:
http://txapuzas.blogspot.com/2010/07/rele-controlado-por-transistor.html
http://txapuzas.blogspot.com/2010/09/micropaperrele-carta-de-reles.html

Información legal

1. Propiedad intelectual
Todos los derechos de propiedad intelectual del contenido de Txapuzas eléctronicas, están bajo una licencia Creative Commons Share-Alike, cuyo contenido podéis revisar en este enlace.
Por tanto queda permitido copiar, distribuir, comunicar públicamente la obra y hacer obras derivadas de la misma, siempre que se respeten los términos de la licencia arriba reseñada.
3. Actualizaciones y modificaciones de Txapuzas electrónicas
El autor se reserva el derecho a actualizar, modificar o eliminar la información contenida en Txapuzas eléctrónicas, y la configuración o presentación del mismo, en cualquier momento, sin previo aviso, y sin asumir responsabilidad alguna por ello.
4. Indicaciones sobre aspectos técnicos
El autor no asume ninguna responsabilidad que se pueda derivar de problemas técnicos o fallos en los equipos informáticos, que se produzcan a causa de los circuitos e ideas expuestos en el blog de txapuzas electrónicas, así como de los daños que pudieran ocasionar.
El autor se exime de toda responsabilidad ante posibles daños o perjuicios que pueda sufrir el usuario a consecuencia de errores, defectos u omisiones en la información facilitada.

Descargas

El esquema, descripción e imágenes están disponibles en el siguiente enlace:

PaperLed: El LED y tarjeta comprobación de salidas

2009-12-12T09:23:00.004+01:00

Descripción

En esta página, veremos qué es un diodo LED y como aplicación práctica, realizaremos una tarjeta de comprobación de estado de 8 salidas.

¿Qué es un diodo LED?

Un LED (Diodo Electro Luminescente), es un componente electrónico que funciona como una bombilla, pero hemos de tener en cuenta que es un diodo, es decir, un componente que deja conducir la corriente eléctrica en un sentido y en el otro no conduce (por eso su símbolo es una flecha indicando la dirección de conducción).

El diodo LED es un diodo especial que al conducir emite una luz que puede ser visible o infrarroja.

Al estar fabricados con el objetivo de emitir luz, son más delicados que un diodo rectificador normal, y debemos de prestar atención a la tensión y polaridad a la que los conectamos. El diodo LED a perdido su función de rectificador, y si lo conectamos invertido, es posible que nos lo "carguemos".

Para distinguir los terminales del LED nos fijaremos en la longitud de sus terminales.
El largo es el ánodo y el corto es el cátodo. También la cápsula de plástico tiene una marca en el cátodo, es decir "un corte en el corto".

El símbolo del LED es el del diodo con unas flechas para simbolizar la emisión de luz :

La tensión a la que trabaja cada LED depende de su color (y fabricante):
Rojo = 1,8v-2,2v
Naranja = 2,1v-2,2v
Amarillo = 2,1v-2,4v
Verde = 2v-3,5v
Azul = 3,5v-3,8v
Blanco = 3,6v.

Los LED convencionales trabajan de 10 a 20mA. Para limitar la intensidad que circula por el LED, y evitar que éste se funda se suele colocar una resistencia limitadora. Veamos como se calcula:
Si lo alimentamos con 5v, y si sabemos que la Intensidad máx del diodo es If=10 mA y trabaja con una tensión de 2v, la resistencia tiene que provocar una caída de:
VR=5-2=3v.
Según la ley de Ohm:
V = I x R => R = VR/If=3/10=0,3 KOhmnios
(al estar If en mA el valor obtenido serán KOhmnios).
Es decir con una resistencia de unos 300 Ohmnios el LED da su mayor brillo. Es conveniente no trabajar con valores máximos. Por lo que para aumentar la vida del LED y aunque ilumine menos, podemos aumentar el valor de la resistencia y así no preocuparnos de que tipo de LED es.
(valores habituales para 5v van desde 330 Ohmios a 1K).

Las puertas de los micros suministran intensidad suficiente para alimentar un LED.
Si queremos que se encienda el LED con un nivel ALTO (5v) utilizaremos este esquema:

Y si queremos que se encienda el LED con un nivel BAJO (0v) este otro:

Vamos a realizar un circuito muy sencillo, que consiste simplemente en 8 leds con su resistencia en serie.

NOTA: puedes usar una tira de 8 Pines hembras, o una de 8 pines hembra en conjunción una tira de 8 pines macho. de esta manera puedes también conectar el circuito con cables.

Realización

El método Paper consiste en ayudarnos en unas pegatinas para facilitarnos el proceso de montaje y soldadura.

Primero imprimiremos el documento PaperLed (disponible en la parte inferior de esta página en el apartado de descargas):

Cortamos una placa de stripboard de 10 filas por 7 agujeros, y fijándonos en el paper-documento cortamos las pistas.

Para soldar los componentes SMD, prefiero pegarlas primero con un poco de cianocrilato (Loctite),

y con la ayuda de un palillo para evitar utilizar mucho adhesivo:

Luego colocamos el componente con "cuidadín"

Y ya los podemos soldar con tranquilidad.

Recuerda que hay que unir todas todas las pistas con ayuda de un trozo de cable en el lado contrario al conector.

En este caso haremos una Paperetiqueta para proteger el circuito, y que se muestre un número al encender cada led.

Primero le aplicaremos Aironfix transparente (puede valer cello)

Para hacer el papel más transparente, puedes aplicarle un poco de aceite

(no hace falta que sea de oliva!)

Y al aplicar cinta de doble cara, dejar la zona con aceite sin adhesivo:

Ahora podemos colocarlo sobre el circuito

Obteniendo el siguiente resultado:

Para facilitar el conexionado, en vez de cables, podemos utilizar una tira de pines largos Macho

Sobre los pines macho, he soldado unos pines hembra, para poder utilizar la señal, además de visualizar su estado.

Ruleta electrónica

Vamos a probar el correcto funcionamiento de la placa con un ejemplo que simula una ruleta electrónica:

Además del PaperLED, necesitaremos un buzzer con vibrador incorporado y un pulsador que lleve a masa una patilla de Arduino (yo he utilizado un PaperTeclado).

Podemos ayudarnos del documento de ejemplo donde tenemos una imagen con detalles del montaje:

Cargaremos en el Arduino el Sketch del archivo de descargas:

El programa muestra mediante pitidos que tecla se ha pulsado, también envía al terminal serie del PC el código del pulsador.

/*
Ruleta
Enciende un led aleatoriamente simulando una ruleta.

Este ejemplo es de dominio publico.

* Colocamos un pulsador entre GND y la patilla 4,
y una resistencia pull-up entre la patilla 4 y 5v
(Podemos usar un Paper-Teclado)
* Colocamos un vibrador con oscilador integrado (buzzer) entre masa y la patilla 5
* Colocamos el PaperLed entre las patillas 6 y 13
(8 leds con una resistencia en serie a masa)

creado el 30 de Marzo 2011
por Iñigo Zuluaga
www.txapuzas.blogspot.com

*/
// Definicion de Entradas/Salidas
int Led1Pin = 6;         // Selecciona el pin para el led 1
int Led2Pin = 7;         // Selecciona el pin para el led 2
int Led3Pin = 8;         // Selecciona el pin para el led 3
int Led4Pin = 9;         // Selecciona el pin para el led 4
int Led5Pin = 10;        // Selecciona el pin para el led 5
int Led6Pin = 11;        // Selecciona el pin para el led 6
int Led7Pin = 12;        // Selecciona el pin para el led 7
int Led8Pin = 13;        // Selecciona el pin para el led 8
int PulsadorPin = 4;     // Selecciona el pin para el led 10
int VibradorPin = 5;     // Selecciona el pin para el vibrador
// Definicion de Variables
int Espera = 0;          // Tiempo de espera (velocidad)
int Numero = 0;          // Numero aleatorio
int nLed=0;
int Leds[8]={Led1Pin,Led2Pin,Led3Pin,Led4Pin,Led5Pin,Led6Pin,Led7Pin,Led8Pin};
int Pulsador;           // Estado del pulsador

void setup() {
// Inicializamos las entradas.
pinMode(PulsadorPin, INPUT);
// Inicializamos las salidas.
pinMode(Led1Pin, OUTPUT);
pinMode(Led2Pin, OUTPUT);
pinMode(Led3Pin, OUTPUT);
pinMode(Led4Pin, OUTPUT);
pinMode(Led5Pin, OUTPUT);
pinMode(Led6Pin, OUTPUT);
pinMode(Led7Pin, OUTPUT);
pinMode(Led8Pin, OUTPUT);
pinMode(VibradorPin, OUTPUT);
}

void loop() {
Pulsador = digitalRead(PulsadorPin);
if (Pulsador == LOW){
    for (int i=0; i <= 7; i++){          // Recorre todos los diodos
      digitalWrite(Leds[nLed],LOW);      // y los apaga
    }
    randomSeed(analogRead(0));           // Inicializa la semilla del numero aleatorio
    Numero = random(100,400);             // Numero resultado de la ruleta

    for (int i=0; i <= Numero; i=i+10){ // mientras el contador < numero aleatorio
      nLed=nLed+1;                       // Incrementa el led a encender
      if (nLed>7) nLed=0;                // Solo tenemos 8 leds!
      digitalWrite(VibradorPin,HIGH);    // Suena el vibrador
      digitalWrite(Leds[nLed],HIGH);     // Enciende el led que corresponde
      delay(i);                          // Espera
      digitalWrite(VibradorPin,LOW);     // Apaga el vibrador
      digitalWrite(Leds[nLed],LOW);      // Apaga el led que corresponde
      delay(i/2);
    }      // Cuando ha llegado al numero premiado
    for (int i=0; i <= 2; i++){          // Repite 3 veces
      digitalWrite(Leds[nLed],LOW);      // Apaga el led que corresponde
      digitalWrite(VibradorPin,LOW);     // Apaga el vibrador
      delay(100);                        // Espera
      digitalWrite(Leds[nLed],HIGH);     // Enciende el led que corresponde
      digitalWrite(VibradorPin,HIGH);    // Suena el vibrador
      delay(100);                        // Espera

    }
    digitalWrite(VibradorPin,LOW);       // Apaga el vibrador
}
}

Y el resultado final es (no se aprecia muy bien el correcto funcionamiento de los LEDs debido a la mala calidad del video, pero bueno)

Enlaces de Interés

http://inventable.eu/2010/08/23/como-conectar-un-led/
http://www.monografias.com/trabajos60/diodo-led/diodo-led.shtml
http://es.wikipedia.org/wiki/Led
http://inventable.eu/2010/08/24/como-medir-la-tension-caracteristica-de-un-led/

Información legal

Descargas

El esquema, descripción e imágenes están disponibles en el siguiente enlace:

PaperDiodo: Teoría del diodo y Diseño de una Fuente de Alimentación para Arduino

2009-12-12T09:22:00.004+01:00

Descripción

En esta página, veremos qué es un diodo y cómo funciona, y finalmente lo utilizaremos en una fuente de alimentación para Arduino

Tensión de Entrada: 220V AC
Tensión de Salida: 9v CC
Intensidad Máxima: 200mA (2VA)

¿Qué es un diodo?

Un diodo es un componente electrónico que se caracteriza por dejar pasar la corriente eléctrica en una única dirección, por eso su símbolo es una flecha indicando la dirección de conducción).

Un diodo tiene 2 terminales, denominados ánodo (A) y cátodo (K). Para identificarlos, el cátodo suele tener una marca. Un método para identificar el ánodo y cátodo en la representación esquemática es imaginar el símbolo como la unión de una A girada 90º que representa el ánodo y el cátodo a una K girada 180º.

Si conectamos el ánodo a una tensión positiva y el cátodo a una negativa el diodo
se comporta como un interruptor cerrado, y si al contrario conectamos el ánodo a una señal negativa y el cátodo a una señal positiva, el diodo se comportará como un interruptor abierto.

Gráfica de Tensión/Intensidad del diodo
(curva característica)
Si polarizamos positivamente (zona rosa del gráfico) , es decir el ánodo a + y el cátodo a - , y vamos incrementando la tensión (lado derecho de la gráfica) hasta que no superamos la tensión humbral (0,3v Germanio; 0,7v Silicio) la intensidad se mantiene residual.
A partir de este punto el diodo deja pasar libremente a la corriente eléctrica.
Si hacemos que circule mucha intensidad a través del diodo llegará un momento que el diodo se queme.
Si lo polarizamos negativamente vemos que el diodo no permite el paso de la corrriente, hasta que a una tensión inversa máxima se funde.

Al proceso de no dejar pasar las corrientes negativas se le llama rectificar, y se suele usar para convertir la corriente alterna en continua.

Si por ejemplo colocamos un diodo en un cable conectado a un enchufe (ojo!, es un ejemplo no hay que hacerlo, que estamos hablando de 220v!! ). como la corriente alterna tiene 50Hz (cambia 50 veces por segundo de polaridad), el diodo en los intervalos en los que la polaridad es negativa no conducirá.

Para evitar los intervalos en los que la tensión es nula, si utilizamos 4 diodos (puente rectificador) podemos redirigir la corriente, y conseguir una tensión con más componente positivo.

Para finalizar ponemos en paralelo con la salida un condensador que acumule tensión y la descargue cuando la tensión de los diodos sea menor que la del propio condensador.
Con este condensador (condensador de filtrado) hacemos que la tensión de salida sea "casi" continua en el tiempo ( a las pequeñas ondas se le llama "rizado".

Mira!!, sin darnos cuenta hemos hecho una fuente de alimentación!! sólo necesitamos un transformador al inicio que nos disminuya la tensión de 220 voltios a 10,5v. (Como la caída de tensión de los diodos es 0,7 => 10,5v-0,7x2=9,1v~9v)

Nota: Como el Paperduino tiene bornas de conexionado no es necesario ningún conector, pero para Arduino necesitarás un conector Jack de alimentación de 2,5mm de diámetro

Como el tanto el Arduino como el Paperduino tienen chip estabilizador (El paperduino también: LM7805) podemos alimentar el micro con esta placa.

Realización

El método Paper consiste en ayudarnos en unas pegatinas para facilitarnos el proceso de montaje y soldadura.

Primero imprimiremos el documento PaperDiodo (disponible en la parte inferior de esta página en el apartado de descargas):

Si quieres puedes proteger la paperetiqueta con un plástico transparente autoadhesivo:

Después recortamos la Paperetiqueta:

Le añadimos adhesivo de doble cara en la parte inferior

Necesitaremos cortar un trozo de placa de stripboard de 9 filas por 9 agujeros; lo podemos hacer con un cutter.

Con ayuda de una aguja colocamos la paperetiqueta en línea con la placa.

Con ayuda de una aguja perforamos todos los agujeros de la paperetiqueta:

Colocamos los diodos:

Y luego colocamos el condensador:

Soldamos los componentes, y añadimos un par de terminales a los que soldaremos el transformador. Tendremos que soldar también el cable de salida. (una vez soldados todos los elementos, podemos aislar la cara de las pistas con cinta aislante)

Ahora le toca el turno al transformador:

Como vemos en la foto utilizaremos los terminales 1-5 para 220v y 7-9 para la salida, así que recortaremos las innecesarias:

Ahora podemos introducir el transformador en la placa, y doblando los terminales introducidos previamente, los soldaremos a los terminales del transformador que atraviesan la placa.

Podemos utilizar un viejo cable de alimentación de ordenador...

Al que le cortamos el enchufe hembr, y soldaremos a los terminales del transformador que atraviesan la placa (220v-AC)

Si vamos a alimentar un Arduino, soldaremos un Jack de 2,5mm (rojo al interior y negro al exterior), si vamos a alimentar un Paperduino, (Con terminales de tornillo) puede ser interesante pelar las puntas del cable y aplicarlas estaño para endurecerlas.

Y ya tenemos nuestra fuente de alimentación

Como tenemos cables con 220v al aire, tenemos que meterlo en una caja:

Yo he usado una de esas de diapositivas.
¿Cómo, que no sabes que es eso?. No importa, usa cualquier caja, pero que no sea metálica !!

Enlaces de Interés

Información legal

Descargas

El esquema, descripción e imágenes están disponibles en el siguiente enlace:

Txapu-CNC: Hardware

2009-12-12T09:21:00.030+01:00

Descripción

TxapuCNC es una fresadora casera de 2,5D. Es decir permite realizar mecanizados sobre una superficie (X,Y) a distintas alturas (Z).

En el blog anterior vimos la parte de software, y ahora veremos la de hardware. La descompondremos en dos partes, la electrónica y la mecánica.

Electrónica

La parte electrónica está realizada fundamentalmente con módulos Paper:

1 Paperduino (puedes utilizar Perfboard, Stripboard , PCB o un Arduino) con el programa TxapuCNC_RX cargado.
3 PaperSteppers (puedes usar L293D, Unipolar, o L298N.)
1 PaperRelé si quieres gobernar el motor del cabezal desde el programa.
1 Paper-FTDI para conectar con el PC (si utilizas un Arduino en vez de un Paperduino no lo necesitarás)
... y por supuesto un PC con TxapuCNC_TX (con gambas y GNU-Linux)

NOTA: Si en vez de utilizar drivers PaperStepper, quieres utilizar drivers comerciales (tipo Pololu,Easydriver), que funcionen mediante señales "STEP" y "DIR", en vez de utilizar el sketch de Arduino TxapuCNC_RX, deberás utilizar el sketch TxapuCNC_RX_Pololu, que lo puedes descargar aquí.

El esquema de conexionado es el siguiente:

NOTAS

Puedes elegir otras patillas de entrada-salida modificando el archivo _init.pde dentro de TxapuCNC_RX.
Puedes utilizar cualquier PaperStepper en función del motor paso a paso que tengas (como ejemplo en los ejes X e Y se ha representado un motor bipolar y en el eje Z uno unipolar.
No es necesario utilizar el PaperRelé para comandar el motor del cabezal, puedes hacerlo a mano.
No es necesario utilizar finales de carrera para los límites máximos y mínimos de cada eje (yo no los he implementado en la fresadora, soy muy vago) , la fresadora funcionará, pero perderá el sincronismo si llegamos al tope de algún eje.
Las entradas de los finales de carrera no tienen una resistencia a 5V ya que todas las patillas de entrada de Arduino disponen de una resistencia Pull-Up interna.

NOTAS:

En la imagen anterior se han utilizado 3 paperSteppers L298N con tres motores unipolares, y no se representan los finales de carrera de los ejes.

Si no utilizas el PaperRelé puedes conectar el taladrín a la salida conmutada de 220v de la fuente de alimentación (el enchufe del monitor), para que al apagar la fuente se desconecte el cabezal.

El resultado es el siguiente:

y aquí un detalle de la alimentación del taladrín con el paperRelé:

Nota: el cable gris, está conectado internamente al enchufe de 220V conmutado de la fuente ( monitor ).

Nota: El interruptor de la fuente lo he colocado para que sea accesible (es conveniente que la fuente esté colocada con el ventilador hacia adelante para que el polvo y virutas del mecanizado no entren en la fuente).

Mecánica

Puedes utilizar la fresadora que quieras, pero yo he elegido la Mantis-CNC, una fresadora realizada con madera según las indicaciones de David Carr en su blog: make your bot

Los materiales que necesitarás son los siguientes:

Puedes descargar los planos de fabricación en la zona de descargas.
Los planos se pueden imprimir sobre una hoja DIN-A3 y pegarlas sobre la madera.

NOTA: Los planos están hechos para madera de 13mm de espesor, si utilizas otros espesores, hay que recortar la diferencia en los laterales (la base es de 276mm x 276mm)

NOTA: Al imprimir ten presente que los planos Mantis_Componentes_xx están preparados para imprimir sobre hojas DIN-A3, y el plano Mantis_Laser está preparado para imprimir sobre una hoja de 800x400, ten cuidado de no tener activada la opción "Ajustar a tamaño de página" al imprimir o los planos no estarán a escala. Una vez impresos puedes comprobar que están a escala sabiendo que la base es de 276x276mm.

Las piezas puedes hacerlas a partir de una pieza de madera contrachapeada de 15mm de 800x400mm (8,10€ en Leroy Merlín) o en MDF de 16mm 800x400mm(5,5€ en Leroy Merlín). Y puedes cortarlas tu mismo con una sierra de calar. (recuerda en ajustar los planos al espesor de la madera, o recortar los laterales para que encajen con la base).
Para que las varillas queden paralelas, te aconsejo que unas las piezas por parejas y las taladres simultáneamente (algunas piezas tienen unos pequeños agujeros de posicionado).
Si quieres, puedes encargar que te la corten por laser, también en la zona de descargas dispones de un archivo DXF preparado para ser cortado en una madera de 800x400:

Nota: he añadido un plano de conjunto para facilitar el montaje, este plano no está incluido en el archivo zip de descargas. Para acceder a él haz click en la imagen inferior.

Para fijar el taladrín, puedes quitar la tuerca de plástico que suelen tener en la parte delantera, medir su diámetro y comprobar que coincide con el mío. posteriormente tienes que realizar un agujero para poder introducir un tornillo de apriete.

En la realización de la fresadora he realizado las siguientes txapuzas:

En vez de utilizar un motor con su adaptador, la he adaptado a un taladrín para simplificar la fabricación.

Ya que hoy en día se pueden encontrar taladrines a bastante bajo precio:

En vez de utilizar un eje roscado con su tuercas especiales antiholguras que son bastante caras, he comprado 1 metro de varilla roscada de métrica 8 (paso 1,25) a 1,3€ y tuercas normales M8 (bueno por unos céntimos más las compré de latón para intentar disminuir el rozamiento) por 1,2€. Para disminuir en lo posible las holguras entre la varilla y las tuercas, he colocado dos tuercas en cada eje.

Las tuercas (al igual que los casquillos) las he fijado con "araldit rápido" (resina epoxi), mezclado con polvos talco para intentar hacer el adhesivo un poco más espeso. Con un palillo he ido retocándolo para que no se expanda demasiado. Es necesario que la varilla roscada esté introducida en las tuercas para que éstas permanezcan alineadas. Aquí vemos las tuercas del eje Z.

Las tuercas inferiores de la mesa (eje Y)

Y la fijación de las tuercas (fotografía desde abajo,debajo del motor paso a paso) del eje X:

La fijación de los motores X e Y es un poco demasiado "txapuzas", los fijé provisionalmente y como funcionó así lo dejé. Pero posteriormente he descubierto las barritas de adhesivo epoxi, que creo que se podrían fijar como el motor del eje Z.

La fijación del motor del eje Z la realicé primeramente con burlete adhesivo y adhesivo de doble cara (el "taco" y el "verde" que se utiliza para las protecciones en pelota mano) pero tenía demasiada holgura (como la unión eje-varilla era rígida creí que era mejor que el motor tuviera algo de movimiento). Lo que hice es fijar de forma rígida el motor con barritas adhesivas epoxi (dependiendo como la aplastes consigues el ángulo y posición correcto del motor) y realizar una unión flexible con la varilla mediante mangueras de PVC.

Como he comentado, para el acoplamiento del eje del motor con la varilla roscada he utilizado dos métodos:
Para el primero he utilizado un casquillo de plástico:

Taladré un agujero pasante con una broca del mismo diámetro que el eje del motor pasos a paso, y luego volví a taladrar hasta la mitad con una broca un poco más pequeña que el diámetro de la varilla roscada, de forma que se al introducir la varilla roscada se genere rosca en la pieza de plástico.
De esta forma la varilla se rosca por un extremo y entra a presión por el otro en el eje del motor. (acoplamiento eje X)

Este sistema tiene la desventaja de que la unión es rígida y no absorbe los descentramientos del taladrado de los agujeros y desviaciones de la varilla (si te fijas la varilla del eje Y está muy torcida). A pesar de que funciona creo que es mejor el segundo sistema:

Para este acoplamiento he utilizado dos trozos de manguera flexible de PVC:

Uno pequeño, de diámetro interior igual al eje del motor paso a paso, y de longitud igual a la longitud del eje del motor paso a paso. Y otro del doble de longitud y de diámetro interior aproximado al eje y al exterior del tubo pequeño:
Primero introducimos el tubo pequeño en el eje del motor:

Sobre él colocamos el tubo grande

Introducimos la varilla roscada. dependiendo de la separación entre el eje y la varilla roscada variaremos la flexibilidad de la unión. Quizás tengas que calentar el tubo para aumentar su flexibilidad y poder introducirlo.

Finalmente, (si es necesario), con un alambre impedimos que las mangueras deslicen, haciendo una Txapu-abrazadera (acoplamiento eje Z y eje Y).

Nota: para el acoplamiento del eje Y, puse un poco de cinta aislante entre el eje y el tubo de PVC, pero con el alambre no es necesario.

Creo que es bueno hacer unos "agujeros de acceso" en la madera de la base para permitir arreglar la máquina sin tener que desmontarla completamente.
Si no encuentras cojinetes de deslizamiento (no es necesario que tengan valona, yo los utilicé porque los tenía disponibles), creo que se podrían moldear con la barrita de epoxi cubriendo previamente el eje con film plástico (o tal vez aceite y moviéndolos hasta que se sequen para que no se peguen al eje).

Si nó, siempre puedes comprar unos cojinetes IGUS (11@1,13€/Ud):

Realización casera de casquillos

Si no tienes casquillos, puedes hacerte tú unos. Sólo necesitas los siguientes componentes: Una pistola de adhesivo térmico y papel de aluminio.

Cortaremos un réctángulo de papel de aluminio (el utilizado para envolver alimentos) de una longitud suficiente para que de 3 vueltas a la varilla de deslizamiento.
Envolvemos el papel de aluminio sobre la varilla y lo fijamos con cello.

Ahora con la pistola termoadhesiva vamos recubriendo el aluminio, girando lentamente la varilla.
Una vez frío, (podemos enfriarlo con agua), lo sacamos de la varilla, y eliminamos las dos vueltas de aluminio que no se han fijado al adhesivo. De esta forma conseguimos que tenga la holgura adecuada, y se deslice sin problemas.

El resultado es el siguiente:

Al hacer manualmente los casquillos, al unirlos sobre las plataformas deslizantes (con la varilla introducida, desde luego), habrá que fijarse que las varillas queden completamente horizontales sobre la plataforma.

Enlaces de Interés

Blog de David Carr donde se explica como construir una fresadora casera: make your bot.
Página de EMC2, dedicada al mecanizado en linux.

RepRap, creación de una máquina autoreplicante. Realización de piezas por deposición de material.

ReplicatorG, programa para producir código para RepRap a partir de ficheros stl
Contraptor realización de una fresadora utilizando perfiles perforados.

Aplicación en "processing" utilizada por contraptor para enviar archivos Gcode al controlador Arduino.
Gcodetools: Plug-in para inkscape que genera Gcode a partir del dibujo vectorial que hayamos dibujado (casi todos los archivos de ejemplo de TxapuCNC_TX los he creado con este fantástico plug-in).
HersheyFonts: Plugin para inkscape que genera textos con carácteres de una linea simple, ideales para simplificar el mecanizado.
PyCAM: Programa que genera archivos Gcode a partir de archivos STL (3D) o Archivos DXF o SVG (2D).

PaperStepper L298N: Uno de los drivers posibles para utilizar en TxapuCNC.
PaperStepper L293: Otro de los drivers posibles para utilizar en TxapuCNC (Yo he utilizado éste para la realización de la fresadora).
PaperStepper Unipolar: Otro de los drivers posibles para utilizar en TxapuCNC.
PaperStepper Unipolar: Otro de los drivers posibles para utilizar en TxapuCNC.
PaperRelé: Placa utilizada para gobernar el motor del cabezal.
PaperduinoStripboard: Posible placa de Arduino para controlar TxapuCNC.
PaperduinoPerfboard: Posible placa de Arduino para controlar TxapuCNC.
PaperduinoPCB: Posible placa de Arduino para controlar TxapuCNC.
CableFTDI: Si utilizas un Paperduino, será necesario que tengas un cable USB-RS232(TTL) para comunicarte con el PC.

mister_mst de forocoches está haciendo una TxapuCNC, mira sus progresos aquí

Galería

San ha realizado una evolución, (con la mesa de trabajo más grande y con otro modo de fijar las tuercas) del TxapuCNC:

Teneis más fotos de su trabajo en:
https://docs.google.com/#folders/folder.0.0B82NJbZaMceIODBjYjU5NDYtYTg0Mi00N2NlLWIwN2YtZTI2MjFjMmYwMDE5

Y los planos en formato PDF y Autocad realizados por Zumel los teneis aquí

(Teneis más información de sus trabajos en Forocoches)

Información legal

1. Propiedad intelectual

Todos los derechos de propiedad intelectual del contenido de Txapuzas eléctronicas, están bajo una licencia Creative Commons Share-Alike, cuyo contenido podéis revisar en este enlace.
Por tanto queda permitido copiar, distribuir, comunicar públicamente la obra y hacer obras derivadas de la misma, siempre que se respeten los términos de la licencia arriba reseñada.

3. Actualizaciones y modificaciones de Txapuzas electrónicas

El autor se reserva el derecho a actualizar, modificar o eliminar la información contenida en Txapuzas eléctrónicas, y la configuración o presentación del mismo, en cualquier momento, sin previo aviso, y sin asumir responsabilidad alguna por ello.

4. Indicaciones sobre aspectos técnicos

El autor no asume ninguna responsabilidad que se pueda derivar de problemas técnicos o fallos en los equipos informáticos, que se produzcan a causa de los circuitos e ideas expuestos en el blog de txapuzas electrónicas, así como de los daños que pudieran ocasionar.
El autor se exime de toda responsabilidad ante posibles daños o perjuicios que pueda sufrir el usuario a consecuencia de errores, defectos u omisiones en la información facilitada.

Descargas

Los planos, archivos para mecanizado, esquemas e instrucciones están disponibles en el siguiente enlace:

NOTA: El 3 de Abril de 2011 se actualiza el archivo de descargas

Notas

Para la realización de este proyecto se han utilizado los programas: Arduino, Inkscape, Openoffice, Gimp, Picasa, Fritzing, Gambas

Si encuentras algún fallo, se te ocurre alguna mejora, o simplemente quieres hacer algún comentario, te lo agradeceré: Gracias. :-)