Cubo de LEDs: Fase uno, terminada!

Hola a tod@s!

Como vieron en mi publicación anterior, estoy trabajando en un cubo de LEDs de 4x4x4. Hasta el momento, he terminado la etapa de prototipado: programado las animaciones y hecho el circuito en el protoboard. He utilizado todos los pines del Arduino UNO, no solo los de la parte superior (del 0 al 13), sino también los pines de entrada analógica (de A0 a A5, o como se llaman si se usan como los otros, del 14 al 19). Al final de la entrada haré una explicación (algo) técnica y algunos consejos, pero de momento veamos un par de fotos y el video 😀 (Pido disculpas por la calidad de las fotos y el video, los hice ambos con mi celular 😛 ):

El todo:

IMG_0169

 

La electrónica:

 

IMG_0170

 

Y el cubo:

IMG_0171

Y el video (de pésima calidad, prometo que cuando lo termine subo uno decente):

Prototipo cubo LEDs

En este momento estoy usando la tarjeta Arduino UNO, a diferencia de lo que mostré en la entrada anterior, en la que mostraba la Arduino MEGA (2560), debido a que cuando termine el proyecto, usaré el chip que usa la uno, así que es buena idea irme adaptando a las limitaciones de una vez. Las animaciones se reproducirán en orden aleatorio, pero de momento por razones de comodidad las tengo en orden, para ver si una animación en particular funciona bien, y para poder poner más cómodamente nuevas animaciones (si se les ocurre alguna les agradecería que me la compartieran en los comentarios 😀 ).

Como comente anteriormente, usé todos los pines disponibles. Esto se debe a que, debido a la estructura del cubo, hay 16 “torres”, que uso como positivo (5 voltios), y cuatro “pisos”, los cuales conecto a tierra mediante transistores; entonces, si sumamos, las 16 torres y los 4 pisos, requerimos de 20 (0 a 19) pines. Para las 16 torres uso los pines del 0 al 15, encendiéndolos (poniéndolos en HIGH) cuando quiero encender uno o más LEDs de esa columna. Pero, si sólo le pasamos energía al LED no se va a encender, ya que si la energía no tiene para donde ir, se almacena en el LED que termina estallando, ¿o no?. Ahí es donde entran en juego mis amados transistores, que son los encargados de activar los pisos haciéndolos conectarse a tierra (los pisos son las tierras, gracioso ¿no?).  Aquí podemos ver un poco cómo funciona:

Pantallazo-3

Como pueden ver, la energía entra por la segunda columna, y sale por la tercera, haciendo que solo se prenda el LED marcado como un 0. A la derecha están, también, unas X, que marcan por donde no sale energía, y por ende, los LEDs no se encienden.

Tan pronto cómo lo termine, subiré los esquemas y el código (que aún no los he hecho), junto con un video decente.

Si tienen alguna propuesta, duda o comentario, no olviden ponerlo abajo 🙂

Saludos.

Tarjeta de desarrollo AVR [Actualizado]

Buenas a todos.

Hacía ya unos días que no publicaba nada, pero la verdad fue porque no hice nada que valiera la pena publicar (sin contar conque tuve examen 😛 ). El caso es que hace unos días diseñé una tarjeta de desarrollo para microcontroladores AVR, que, en teoría, es universal (bueno, no soporta micros de montaje superficial pero debería soportar los demás).

Como ya he comentado, he empezado a ver programación de AVRs en C, y debo admitir que usar la protoboard para las conecciones no es muy cómodo, así que diseñé esta tarjeta para facilitar un poco el asunto, y como soy flojo decidí hacerla universal, así no tenía que hacer varias para cada micro.

Aquí les dejo un par de imágenes:

DSC07101

DSC07138

Actualización: Jajaja, lo siento. Anoche olvidé explicar que era cada cosa:

DSC071552

  1. Conección del programador. Los 4 pines se conectan al micro. De arriba para abajo son: Sck, Reset, Miso y Mosi.
  2. Reset. Está adaptado para conectarse a cualquier lugar de la tarjeta, o para no conectarse.
  3. Zona principal. Aquí se conecta el micro y se hacen todas las conecciónes, ya sea alimentación de energía, cconecciónes al cristal o entradas/salidas.
  4. Tierra
  5. Voltaje
  6. Alimentación. Decidí usar un conector USB ya que generalmente están regulados a 5V. Tiene un LED que indica que está encendido.
  7. Cristal. Está diseñado para poder cambiar de cristal y de conección al micro.

Las demás fotos las pueden encontrar en mi Flickr.

El esquema y el diseño de pcb (que no usé, pero si diseñé) los pueden encontrar aquí. Siéntanse libres de modificarlos 🙂 .

Saludos.

[Linux] Usar AVRdude sin ser super usuario

Buenas noches.

Estoy comenzando a programar microcontroladores AVR en C, para lo cual necesito usar un programador, a diferencia de Arduino. La verdad llevo un par de días haciendo todos los comandos a mano, y en ese caso usar sudo con avrdude no es un inconveniente, pero quise probar Eclipse, ya que Atmel Estudio no esta disponible para Linux. Desafortunadamente, para acceder a los puertos usb del computador necesito los privilegios de root, razón por la cual siempre me votaba un error. Después de un rato, logré hacerlo funcionar. He aquí como lo hice:

Nota: Estos pasos funcionaron en mi instalacion de Debian 8 (Jessie) con un programador USBasp.

Primero necesitamos saber un par de datos de nuestro programador. Para ver esta información, con el programador conectado ejecutamos:

lsusb

A mí me salió esto:

Bus 001 Device 006: ID 16c0:05dc Van Ooijen Technische Informatica shared ID for use with libusb

(Yo para saber cual era, ejecuté el comando con el programador conectado y luego sin el programador 😉 )

La información que necesitamos son los números que van después de “ID”, que son 16c0 el “Vendor ID” y 05dc el “Product ID”.

Ahora tenemos que crear un archivo con las reglas de nuestro programador:

sudo nano /lib/udev/rules.d/41-atmega.rules  (Reemplaza nano por el editor que prefieras)

Y luego le ponemos las siguientes líneas:

#Nombre para identificarlo. Este es un comentario
SUBSYSTEM==”usb”, ATTR{product}==”<NOMBRE DEL PROGRAMADOR>”, ATTR{idVendor}==”<VENDOR ID>”, ATTR{idProduct}==”<PRODUCT ID>”, GROUP=”dialout”, MODE=”0666″

No olvides poner la información de tu programador. Por ejemplo, el mío quedó así:

#USBasp
SUBSYSTEM==”usb”, ATTR{product}==”USBasp”, ATTR{idVendor}==”16c0″, ATTR{idProduct}==”05dc”, GROUP=”dialout”, MODE=”0666″

Con esto permitimos a todos los usuarios del grupo “dialout” acceder al programador. Ahora tenemos que meter a nuestro usuario en el grupo dialout:

sudo gpasswd -a <USUARIO> dialout

Y, finalmente, reiniciamos el daemon de udev para que podamos empezar a usarlo:

sudo udevadm trigger

O reiniciamos el equipo.

Fuentes: avr-eclipse micahcarrick

Espero les sea útil. Pienso hacer un pequeño tutorial de programación en AVR con C, por si les interesa 🙂

Saludos.

5 mitos comunes de Arduino (que no son verdad) [Traducción]

Hola de nuevo!

Hace un par de días, a través de la página de Arduino en Facebook, llegué a este artículo de James Lewis acerca de 5 mitos comunes de Arduino, y me pareció buena idea traducirlo al español. Al final de la entrada dejaré mis comentarios acerca de cada mito. Que lo disfruten 😉

“5 Mitos comunes acerca de Arduino (Que no son verdad)

Habiendo ocupado estos últimos 6 años escribiendo código para Arduino, he notado una serie de mitos provenientes tanto de los recién llegádos como de los expertos. Aquí está el Top 5 de los mitos que más he visto en los foros, clases e IRCs.

1. Arduino usa su propio lenguaje

Este mito no es ayudado por la página principal de arduino.cc, que dice: “El microcontrolador en la placa es programado usando el lenguaje de programación Arduino“. Aún cuando la estructura de los programas de Arduino parece única, es realmente solo C++ con un poquito de preprocesamiento [Nota del traductor: No estoy seguro si el término preprocessing tenga algún uso distinto. De ser así, por favor avísenme]. Los usuarios escribiendo “código Arduino” en realidad estan programando en C++ con, como yo lo llamo, la Librería Arduino. Funciones como digitalWrite() son solo eso, funciones de C++.

Mientras la librería Arduino hace un excelente trabajo haciendo muy simple la programación de microcontroladores, no es un lenguaje por si misma.

2. El pin 13 tiene una resistencia

Incontables tutoriales han atraído a novatos a esta trampa. La primera placa Arduino, de la cual fueron producidas como 200, tenía un LED y una resistencia en serie en el pin 13. Esa fue la única placa que la tenía. Así que nunca nunca nunca conectes un LED al pin 13 sin una resistencia!

3. Los productos comerciales no usan Arduino

Corolario: los ingenieros “reales” no usan Arduino!

De acuerdo, intentaré no entrar mucho en el tema, pero yo soy un “ingeniero real”. Tu ya lo sabes: esta en mi nombre de twiter y en la URL. He aquí cierta información confidencial: yo uso Arduino. Si vas a tu tienda de electrónica preferida, no encontrarás muchos (si hay) productos con una calcomanía que diga “Arduino inside”. Como sea. Arduino es una plataforma de desarrollo. Tú no vaz a enviar una placa UNO con cada producto. En cualquier caso, tu deberías desarrollar un producto con Arduino y usar un Atmega328 en el producto final. O, más probablemente, prototipar la idea, proponerla para financiarla en sitios de crowd funding y entonces rediseñarla.

Tienes que definir que signifíca “comercial”, pero hay varios ejemplos de productos que iniciaron usando Arduino. Haz oído hablar de las impresoras 3D?

4. La función analogWrite() es analógica

Esta abarca a todos los que no entienden realmente el Pulse-Width Modulation [o PWM, en español “Modlación del largo del pulso”]. Con la excepción de la placa “Due”, las placas Arduino no tienen señales de salida “analógicas”. (Nota. Tal vez quieras ver este video acerca de la diferencia entre señales analógicas y digitales [En inglés, la nota hace parte del artículo original]) Las señales PWM son realmente señales digitales, en las que cambias el largo de los estados “encendido”[on] y “apagado”[off].

5. Los espacios entre los Headers fue un error (o no lo fue)

Si tu sabes algo acerca del orden de los pines de Arduino, debes saber que el espacio entre los pines 7 y 8 no es 0.1″. En una parte del FAQ de la página de Arduino dice que fue un “error de  última hora”. Aunque también dice que es para evitar que los escudos se conecten al revés. Ahora, no estoy seguro si el espacio entre los headers fue intencional, pero un beneficio de eso es que se evita que los escudos se pongan al revés.

Una desventaja clara de esto es que hace difícil conectar la placa al protoboard, o conectar un escudo al protoboard.Como sea, los cables jumpers mágicos existen, lo cual resuelve el “problema”.

Bien, esos fueron los 5 mitos que encuentro más comunes. Que otros mitos haz oído o haz intentado desmentir? Déjalos abajo.”

Fuente

Personalmente encuentro el artículo muy interesante. Hay un par de mitos que yo creía. Ahora, mi opinión sobre cada mito:

  1. Si había oído hablar de que se usaba C++, pero yo siempre me sentí más usando Processing.
  2. Esa si me tomó por sorpresa. Me he puesto a mirar los archivos de la UNO y la MEGA 2560 (Que son las que tengo), y, efectivamente, en ninguna hay una resistencia. Lo que sí tienen ambas es un led (con su respectiva resistencia) en paralelo con el pin en el que nosotros conectamos el cable, pero va directo a tierra, por lo cual, el pin en sí, no tiene resistencia.
  3. Esta me la sospechaba. Como menciona James, Arduino es una plataforma de prototipado, aunque sirve para el producto final.
  4. Esa sí me la sabía 🙂 . En el curso que seguí para iniciarme en Arduino, si mencionan la diferéncia. El video aquí.
  5. De este había visto en un video que estaban separados tal y como están clasificados los pines en el Atmega328 (PORTB, PORTC y PORTD).

Bien, espero les halla parecido interesante el artículo.

Saludos.

Dado electrónico con Arduino y un Attiny45

Hola a todos. Aprovechando que empezó el año, voy a poner a mover el blog un poco.

Hace un tiempo me encontré en Maker Shed un dado electrónico. Al ver que usa un microcontrolador Pic, me pareció simpático hacerle un “hermano” en Arduino usando uno de mis queridos Attiny45.

Ya que nunca había utilizado antes la funcion random() de Arduino, me puse a investigar al respecto. Yo sabía de antemano que los números aleatorios generados por máquinas no son del todo aleatorios, pero no me esperaba encontrarme siempre con el mismo inicio (2, 2, 6, 3, etc…). Al ver un poco más al respecto, encontré un truco usando randomSeed() y los pines analógicos, pero, por algún motivo, no funcionó. Después de leer un par de tutoriales en los que hablaban de usar el ruido atmosférico o la decadencia radioactiva (cosa que, por supuesto no pienso usar, ya que es algo caro y aparatoso), me puse a pensar en una solución sencilla del problema. Después de pensar un poco, me acordé de los Mips, los millones de instrucciones por segundo que puede ejecutar un microcontrolador (Tanto el Atmega328P-PU que usa el Arduino UNO como el Attiny45 tienen 20 Mips con un cristal de 20 Mhz, así que supuse que con el cristal interno del Attiny de 1 Mhz tenemos 1 Mips 😉 ).

Cambiando el numero un millón de veces por segundo, el “numero elegido” depende de el microsegundo (0.000001 segundos, o una millonésima de segundo) exacto en el que se presione el botón, cosa que, en teoría, debería hacerlo aleatorio.

Aquí el dibujo de Fritzing:

Y el esquema:

El código, las imágenes y el archivo del esquema los pueden encontrar en el repositorio de Github.

Espero les sea útil. Saludos.