Max Hernandez

Laberinto - Ejemplo de Canvas en HTML5

viernes, 25 de mayo de 2012

Android y hola mundo

Para el proyecto he decidido trabajar en el sistema operativo Android, he decidido investigar un poco acerca de este.


[Imagen obtenida de: http://www.azuma-kinba.com/wp-content/uploads/2012/05/Android-Make-Google-Loss-in-2010.png]


¿Qué es android?

Android es un sistema operativo inicialmente pensado para teléfonos móviles, basado en Linux, un núcleo de sistema operativo libre, gratuito y multiplataforma. El sistema operativo proporciona todas las interfaces necesarias para desarrollar aplicaciones que accedan a las funciones del teléfono (como el GPS,cámara, etc.) de una forma muy sencilla en un lenguaje de programación muy conocido como es Java.

Las aplicaciones  a pesar de estar hechas en java no son completamente java si no un lenguaje java modificado al cual se le llama Dalvik el cuál también es interpretado como java. En las librerías se incluye un administrador de interfaz gráfica (surface manager), un framework OpenCore, una base de datos relacional SQLite, una Interfaz de programación de API gráfica OpenGL ES 2.0 3D, un motor de renderizado WebKit, un motor gráfico SGL, SSL y una biblioteca estándar de C Bionic.

Características
  • Framework de aplicaciones: permite el reemplazo y la reutilización de los componentes.
  • Navegador integrado: basado en el motor open Source Webkit.
  • SQlite: base de datos para almacenamiento estructurado que se integra directamente con las aplicaciones.
  • Multimedia: Soporte para medios con formatos comunes de audio, vídeo e imágenes planas (MPEG4, H.264, MP3, AAC, AMR, JPG, PNG, GIF).
  • Máquina virtual Dalvik: Base de llamadas de instancias muy similar a Java.
  • Telefonía GSM: dependiente del terminal.
  • Bluetooth, EDGE, 3g y Wifi( dependiente del hardware.)
  • Cámara, GPS, brújula y acelerómetro(dependiente del hardware)
  • Pantalla Táctil.

Arquitectura
La arquitectura desde su nivel mas bajo, es el kernel de linux, después viene la maquina virtual Dalvik , las librerías dle núcleo y librerías de las que hablamos en características, sobre esto vienen los recursos que utilizamos para codificar nuestras aplicaciones y arriba las aplicaciones y sus tipos.


[imagen obtenida de: http://developer.android.com/images/system-architecture.jpg]

Hola mundo de Android en Eclipse
Mi primer paso fue comenzar creando un nuevo proyecto, eclipse por defecto crea una nueva carpeta de proyecto y la distribuye sus partes de una funcional. Para esto existe un botón en el lugar que se muestra en esta imagen.


Después encojemos  "Android proyect" y le damos "Next"".

Ahora escogeremos el nombre del proyecto.
 Y después escogemos la versión de Android con la que vamos a trabajar.
 Ahora elegimos la arquitectura de directorios en la cual estaran nuestros códigos ".java" para la aplicación.
 Antes de poder probar nuestra applicación es necesario tener un dispositivo en el cuál instalarla en nuestro caso utilizaremos un dispositivo virtual, para probar el hola mundo. Para esto vamos a "Window>AVD Maganger" y ahí elegímos la opción new.
 Ya aquí podemos escoger el nombre de nuestro dispositivo virtual, el tamaño de nuestra tarjeta SD, en skin podemos elegir el tamaño que abarcara nuestra la ventana del dispositivo y en hardware podemos agregar la opción de emular los componentes que ahí se mencionan. Mi configuración fue la siguiente:

 Ahora este es el código que nos genera por defecto Eclipse, para correrlo damos click con el boton derecho a la carpeta de proyecto y elegimos la opción "Run As>1Android Application"
 Y este es el resultado:


Referencias:
http://developer.android.com/guide/basics/what-is-android.html
http://www.xatakandroid.com/sistema-operativo/que-es-android
http://es.wikipedia.org/wiki/Android

Seguridad en dispositivos móviles


 [Imagen obtenida de: http://www.muypymes.com/wp-content/uploads/2011/09/seguridad_movil.jpg]
Seguridad en dispositivos móviles

Hoy en día los todas las personas permaneces constantemente conectadas a la web utilizando dispositivos móviles, nuestro mundo se mueve entorno a nuestras cuentas de facebook o twitter, revisamos nuestros matriculas de universidad, por medio de correos por la web pasa información sobre nuestros gustos, nuestro hogar. Manejamos tarjetas de crédito o nuestros cuentas de gastos. Y un camino a toda esta información queda grabado en nuestros dispositivos. Es crucial que la seguridad de nuestros dispositivos sea la adecuada y que conozcamos las medidas que debemos de tomar para proteger nuestra información.

Principales tipos de ataques móviles
Ataques malware
Los ataques de malware por lo general están dirigidos a los componentes de las redes convencionales y deben ser abordados a través de la protección de este entorno.Por lo general están dirigidos a los componentes de las redes convencionales y deben ser abordados a través de la protección de este entorno. Tu puedes obtener uno de estos descargando y ejecutando apps y programas con instrucciones maliciosas.


Sincronizar
Esto sucede cuando sincronizas datos con tu PC y el dispositivo móvil puede verse afectado por un malware que afecte a la PC


Desbordamiento de búfer
Esto sucede cuando un programa no administra de forma correcta la cantidad de memoria a utilizar y sobrepasa los limites de memoria de un bloque designado entonces podría terminar modificando datos que no le corresponden. La principal afectación podría ser la perdida de información valiosa y se debe a errores de los programación.


Ataque de denegación de servicio
es un ataque a un sistema de computadoras o red que causa que un servicio o recurso sea inaccesible a los usuarios legítimos. Normalmente provoca la pérdida de la conectividad de la red por el consumo del ancho de banda de la red de la víctima o sobrecarga de los recursos computacionales del sistema de la víctima.

Phishing
En este tipo de arque una persona podría utilizar cualquier medio de comunicacion (chat, sms, llamadas telefonicas) para engañar a una persona para que le revele información valiosa al atacante.
Un ejemplo de esto puede ser: Cuando una persona recibe un mensaje de una compañia ficticia y esta le pide que le regrese su contraseña o datos personales para verificar el funcionamiento de algún servicio.


Seguridad en Android

[Imagen obtenida de: http://www.sectorandroid.com/wp-content/uploads/seguridad_android_sectorandroid.jpg]


Android busca ser el mas seguro y usable sistema operativo para móviles. Tiene los mas tradiciones sistemas de control de seguridad para protejer datos, recursos del sistema y aislamiento de aplicaciones.

Según la página oficial de Android, Android prove las siguientes caracteristicas clave de seguridad:
Una fuerte seguridad a nivel sistema operativo a travez del kernel de linux
Obligatoria aplicación sandbox para todas las aplicaciones
Aplicacion de firmas
Se aplican tambien permisos definidos y otorgados por el usuario.

linux Kernel
Bueno al ser un sistema operativo basado en linux, Android tiene algúnas de las caracteristicas de seguridad que prove el kernel, como son:
  • Un modelo basado en permisos de usuario
  • Aislamiento de procesos
  • Mecanismos extensivos para para la comunicacioon intra procesos del kernel
  • La posibilidad de remover partes inecesarias o potencialmente inseguras del kernel
  • Ademas de características de seguridad entre usuarios del mismo dispositivo

La aplicación Sandbox
Esta medida de seguridad es muy simple, a todas las aplicaciones del dispositivo se les asigna un identificador, en un principio todas las aplicaciones tienen privilegios muy limitados. Entonces cuando intentan acceder a la información de una aplicación con otro id, el sistema operativo protege esa información ya que no pertenece a esa aplicación.

Permisos de Android

En Android una aplicación que no tiene los permisos otorgados por el usuario, no sera capaz de hacer nada que pueda impactar la información del usuario o su experiencia con el dispositivo.

Asignando los permisos a mi aplicación de Android

Para desarrollar mi aplicación debo de tener en cuenta como configurar de manera correcta los permisos de la aplicación que voy a desarrollar.

En Android todos los permisos se declaran en el archivo "AndroidManifest.xml" usando la etiqueta "" 

La etiqueta puede llevar los atributos:
  • ProtectionLevel: Este atributo se requiere para notificarle al sistema como el usuario sera informado de que la aplicación requiere permisos, o quien esta dentro del rango de los permisos.
  • permissionGroup: Este atributo es opcional y es únicamente utilizado para ayudar al sistema a desplegar los permisos al usuario. Normalmente este parámetro se configurara para grupos del sistema entandar.
  • Description y label: Un atributo puede apuntar hacia un String que contenga esta información osea, una pequeña descripción de para que usara los permisos y un pequeño texto para los permisos.

Ejemplo en mi aplicación

    

    
    

En el ejemplo estoy tratando obtener permisos para acceder a la camara del dispositivo, para detectar superficies si quiero implementar las librerias de realidad aumentada.

referencias:
http://www.delitosinformaticos.com/04/2012/noticias/tipos-de-ataques-ciberneticos
http://es.wikipedia.org/
http://www.pandasecurity.com/homeusers/security-info/types-malware/
http://tecno.elespectador.com/index.php/2011/02/09/top-ten-de-seguridad-para-dispositivos-moviles/
http://www.diariopyme.com/2010/10/decalogo-de-seguridad-para-dispositivos-moviles/
http://www.muycomputerpro.com/2009/07/08/expertosexpertosla-seguridad-movil_we9erk2xxda8od98rjoo2fkylbhs3qztay7y0mxt3vkv8gwgzqj1cqntjt1mcp9y/
http://hackmageddon.com/2011/08/11/one-year-of-android-malware-full-list/
http://developer.android.com/guide/topics/security/security.html

jueves, 24 de mayo de 2012

Moviendo servomotor en Arduino

¿Qué es un servomotor?

Un servomotor es un componente electromecánico en el cual una entrada electrica determina la posición del motor y/o la velocidad de giro del mismo.

El motor del servo tiene algunos circuitos de control y un potenciómetro (una resistencia variable) esta es conectada al eje central del servo motor. Este potenciómetro permite supervisar el ángulo actual del servo motor. Si el eje está en el ángulo correcto, entonces el motor está apagado. Si el circuito chequea que el ángulo no es el correcto, el motor girará en la dirección adecuada hasta llegar al ángulo correcto.

Ejemplo arduino - controlando un servomotor

Diagrama de conexion:


[Imagen obtenida de: http://blog.bricogeek.com/img_cms/1674-conexionServos.jpg]

Código:

   #include   
       
    Servo servo;  // Crea un Objeto servo  
       
    void setup()  
    {  
      servo1.attach(7);  // Selecionamos el pin 7 para transmision serial  
    }  
       
    void loop()  
    {  
      
      posicion = 0;
      servo1.write(150);
      delay(150);
    } 
 
Video:


Referencias:


http://people.ee.duke.edu/~cec/final/node59.html
http://en.wikipedia.org/wiki/Servomechanism
http://principialabs.com/arduino-serial-servo-control/

Multiplexador y Demultiplexador.

Cuando intentaba programar el cubo de leds, me dí cuenta que algunos leds comparten conexiones con otros por eso me dí a la tarea de investigar diferentes formas para enviar información por un canal.

Multiplexación

La multiplexacion es utilizada para combinar varios canales de información en un solo medio, se logra combinando o sincronizando señales por diferentes métodos. El dispositivo que transmite los mensajes es llamado multiplexor.

Tipos de multiplexación

La multiplexación por división de tiempo:
Es un medio de transmitir dos o mas camañes de información en el mismo circuito utilizando una técnica de tiempo compartido, es muy útil para señales binarias puesto que solo requieren una unidad de tiempo.

Multiplexión por división de frecuencia

En este tipo de multiplexion se utiliza para transmitir varios canales, el espectro de frecuencias, donde cada canal ocupa continuamente una pequeña fracción del espectro de frecuencias transmitido.

Multiplexado estadístico o asíncrono
Este es un caso particular de la division por tiempo y consiste en que los tiempos de espera entre una señal y otra dependen del tráfico existente por cada canal en cada momento así que se podría decir que es adaptativo.

Ejemplos de aplicacion del método:
  • Telegrafia
  • Telefonia
  • Procesamiento digital
  • transmisiones digitales
  • Transmisiones analogas


Código ejemplo - Contador hexagesimal con dos displays

Como ejemplo para esta publicación construí un código de un contador hexagesimal con dos display que comparten el mismo canal para encender las lineas que forman los números.

Materiales:

  •     2 display de cátodo
  •     7 resistencias de 220 Ohms
  •     PIC16F628A
  •     7805-CT Regulador Tension 5V
Diagrama de conexiones:

Código:

#include "pic16f628a.h"
#define __16f628a

unsigned int __at 0x2007 __CONFIG = _INTOSC_OSC_CLKOUT &
  _WDT_OFF&                                                                                                                                           
  _LVP_OFF&                                                                                                                                 
  _DATA_CP_OFF&                                                                                                                              
  _PWRTE_ON;


unsigned short int i, j, z; //Declara 3 variables contadores
unsigned short int contador[2] = {0,0};//Un contador para cada display


int main(void){

  TRISB = 0x00;// Define los puertos del registro TRISB como salidas
  TRISA = 0x00;// Hace lo mismo para el registro TRISA
  PORTA = 0b00000000;
  PORTB = 0x00;

  while(1){
    for(i = 0; i < 20; i++){// Aquí es donde se lleva a cabo el multiplexado
      for( z = 0; z < 2; z++){
          if( z == 0){
              PORTA = 0b00000001;//Aquí manda los datos por el primer canal
          }else{
              PORTA = 0b00000010;//Aquí manda los datos por el segundo canal
          }
          if(contador[z] == 0) PORTB =  0b01111110;// Todos estos if mapean un número con los elementos con los elementos que deben encenderen el display.
          if(contador[z] == 1) PORTB =  0b01001000;
          if(contador[z] == 2) PORTB =  0b00111101;
          if(contador[z] == 3) PORTB =  0b01101101;
          if(contador[z] == 4) PORTB =  0b01001011;
          if(contador[z] == 5) PORTB =  0b01100111;
          if(contador[z] == 6) PORTB =  0b01110111;
          if(contador[z] == 7) PORTB =  0b01001100;
          if(contador[z] == 8) PORTB =  0b01111111;
          if(contador[z] == 9) PORTB =  0b01001111;
          if(contador[z] == 10) PORTB = 0b01011111;
          if(contador[z] == 11) PORTB = 0b01110011;
          if(contador[z] == 12) PORTB = 0b00110110;
          if(contador[z] == 13) PORTB = 0b01111001;
          if(contador[z] == 14) PORTB = 0b00110111;
          if(contador[z] == 15) PORTB = 0b00010111;

          for( j = 0; j < 1000; j++);//Este es el tiempo de espera para que tenga tiempo de encenderse el display
      }
    }

      if( contador[0] == 15){// Estas instrucciones sirven como contador
        contador[0] = 0;
        contador[1] = 0;
      }else{
        if(contador[1] == 15){
            contador[0]++;
            contador[1] = 0;
        }else{
            contador[1]++;
        }
      }


  }

  return 0;

}

Video:



Como puede observarse hay cierto parpadeo mientras se muestra el número debido a que se turnan las señales entre canal, pero aun así los números en los display son legibles así que por esas razones fue que elegí esta técnica para mapear el juego de la vida en la matriz de leds para el proyecto PIC.

Referencias:
http://www.slideshare.net/ggordillo/que-es-la-multiplexacin-presentation
http://www.mitecnologico.com/Main/TecnicasDeTransmisionMultiplexacionYConmutacion

miércoles, 23 de mayo de 2012

Microcontroladores

Uno de los temas de la materia este semestre es microcontroladores con lo cual estaremos trabajando con programadores PIC para este tema, para esto decidí que seria muy útil investigar que es y las características de estos.

[Imagen obtenida de:http://www.sxmicro.com/wp-content/uploads/2008/07/sxchips.jpg]
¿Qué es?

Se considera una computadora sencilla puesto que tiene todas las características de la misma, en un circuito integrado, contiene un cerebro o procesador, Una memoria flash y una RAM (comúnmente de pequeña capacidad) e interfaces periféricas de entrada y salida. Los microcontroladores son utilizados en aplicaciones integradas.

Un sistema integrado es una combinación de software y hardware con ciertas capacidades fijas que fue específicamente diseñada para una función en particular.

Ejemplos de sistemas integrados:
  •  Teléfonos celulares
  •  Reproductores mp3
  •  Relojes despertadores
  •  Alarmas
  •  Receptores RFID
  •  Juguetes

¿Qué tipos de microcontroladores existen?


[imagen obtenida de: http://files.spogel.com/enewsline/p-00362--types_of_microcontrollers.jpg]

Los microcontroladores pueden ser clasificados tomando en cuenta las caracteristicas de el ancho de bus interno, de la orientación de su conjunto de instrucciones, la arquitectura de memoria o de su familia de controladores.


Microcontroladores de memoria interna o integrada.
Se considera microcontroladores integrados los que ya tienen todas los componentes de hardware y software necesarios para su correcto funcionamiento(En especial su memoria). Pocos componentes externos son utilizados( o ninguno) para el funcionamiento y control de los procesos que se llevan a cabo por este microcontrolador. Un ejemplo de esto es un microcontrolador PIC que necesita un oscilador externo para funcionar.

Se considera un microcontrolador de memoria externa a un sistema integrado que tiene no tiene todos los componentes necesarios para su correcto funcionamiento y en especial me refiero a componentes de hardware de memoria. Estos tienen una gran cantidad si no es que toda de la memoria, en componentes externos conectada utilizando un circuito llamado circuito pegamento.


Ancho de bus
Los tres anchos de bus mas utilizados en microcontroladores son:
  • Microcontroladores de 8-bits
  • Microcontroladores de 16-bits
  • Microcontroladores de 32-bits
El ancho de bus es la cantidad de bits en la que se maneja cada instrucción, como vimos en ensamblador esta capacidad tiene que ver directamente con la longitud de palabra de una instrucción del procesador y operaciones que pueden ser soportadas por este.


Arquitectura Cisc and Risc
Existen dos tipos de arquitectura de procesador utilizados en los microcontroladores, estos son:
  • Computadoras con un conjunto de instrucciones complejo (CISC):
    En este las instrucciones compuestas son decodificadas internamente y ejecutadas con una serie de microinstrucciones almacenadas en una ROM internamente lo cual puede resultar lento.
  • Computadoras con un conjunto de instrucciones reducido (RISC):
    En este las instrucciones compuestas residen en la memoria externa y son compiladas directamente como instrucciones internas del procesador lo cual se cree que resulta maás eficiente.


Arquitectura de la memoria
Arquitectura de Harvard
En esta se tienen instrucciones separadas y por tanto controles de señal separados para transferir datos.

Arquitectura de Princeton
En esta se tiene un espacio de direcciones de memoria en común utilizado por la memoria del programa y los datos.

Mi primer Hola mundo

Como ejemplo para este tema, voy a mostrar el código que obtuve mientras jugaba con los puertos de mi PIC, el programa que hice presenta una secuencia de leds en un protoboard, que me sirvio para empezar a entender un poco sobre los registros de mi microcontrolador PIC.

Herramientas utilizadas:
  • SDCC para programar en Ansi C el PIC (lo utilice en ambiente Linux)
  • IC-PROG (Lo utilice en ambiente Windows)
Materiales:
  • Protoboard
  • PIC 16F628A
  • 8 leds
  • 8 resistencias
  • Un 7805 regulador de voltaje
Código:

#include "pic16f628a.h"
#define __16f628a

unsigned int __at 0x2007 __CONFIG = _INTOSC_OSC_CLKOUT & _WDT_OFF&
_LVP_OFF& // Configuraciones de fuses
A_CP_OFF&
_PWRTE_ON;


unsigned short int i; // variable contador

int main(void){

  TRISB = 0x00;// Esto declara los pines como salidas
  TRISA = 0x00;// Los pines se dividen en dos registros por eso estos tambien se declaran
  PORTA = PORTB = 0x00;

  PORTB = 1; //Se ponen todos los pines del registro PORTB como salidas positivas
  while(1){
      for( i = 0; i < 50000; i++);
      if( PORTB == 128){ 
         PORTB = 1; //Se asigna un uno binario a los registros
      }else{
          PORTB = PORTB*2;// Se usa el registro para operaciones multiplicandolo por dos
                          // logramos que se prenda 00000001 *2 = 00000010 el siguiente led
      }
  }

  return 0;

}

El código lo que hace es prender cada led de la fila uno por uno utilizando el registro PORTB como una variable, primero lo igualamos a uno y despues vamos multiplicando por dos con lo cual va a obtener en binario numero con un solo bit en uno avanzando de derecha a izquierda o de derecha a izquierda ya en el protoboard.

Vídeo del programa funcionando



Referencias: 
http://en.wikipedia.org/wiki/Microcontroller
http://www.webopedia.com/TERM/E/embedded_system.html
http://my.safaribooksonline.com/book/electrical-engineering/semiconductor-technology/9788131759905/types-selection-and-applications-of-microcontrollers/section_1.2
http://www.societyofrobots.com/microcontroller_tutorial.shtml

martes, 22 de mayo de 2012

Matrices de leds y probando el cubo de leds

Para llevar a cabo del proyecto de PIC, en algún momento tuve que armar y probar el cubo, antes de poder utilizar el algoritmo de el juego de la vida, aquí quiero compartir un poco de la información que adquirí y mi como probé el funcionamiento del cubo.

Matriz de leds


[imagen obtenida de: http://pcbheaven.com/wikipages/images/howkeymatricesworks_1277658667.png]

Una matriz de leds es un grupo de estos componentes conectado en forma de matriz de tal forma que se puede encender solo un led o la cantidad deseada jugando con los cátodos y ánodos de los mismos.
Las matrices de leds son bastante utilizadas, podemos verlas en todos lados algunos ejemplos de esto son:
  • En anuncios panorámicos, en mi caso en las avenidas
  • En relojes
  • En obras de arte.
  • En carteles

¿Como funciona?


En esta imagen de abajo se muestra como son las conexiones de una matriz de leds donde las columnas corresponden las conexiones a tierra y las filas corresponden a las conexiones a corriente. Al producir corriente a una fila, esta corriente es capaz de pasar por toda la fila y al conectar a tierra una columna toda la columna puede conducir la corriente que pase por esta. Así produciendo corriente en una fila y conectando a tierra la columna cerramos el circuito y hacemos que un led en especifico se encienda. Controlando esto con un microcontrolador podemos crear diferentes figuras o números, en realidad esta funciona de forma muy parecida a un display común y corriente.

[imagen obtenida de:http://galaxi0.files.wordpress.com/2009/06/diagrama-de-pines-catados-en-columna.png?w=500]

Cubo de leds


Un cubo de leds es una estructura bastante similar a la matriz, con la diferencia que los cátodos se mapean como una matriz de cero a nueve, por lo cual necesitamos nueve pines y un ánodo para cada nivel. Lo cual quiere decir que podemos controlar el encendido controlando cada columna y su nivel. Para construirla me base en el siguiente blog: http://roberto-mtz.blogspot.mx/2012/04/cubo-leds-3x3x3-arduino-bt.html el cual tiene publicaciones muy interesantes y me parece muy bueno.

Probando el cubo de leds
Una vez armado me dí a la tarea de generar un código para probarlo, el controlador lo que hace es encender fila por fila para revisar que las conexiones y el soldado esten correctos, despues al final enciende todos los leds al mismo tiempo para verificar que tengan el voltaje necesario.

Materiales:

  •     27 Leds
  •     9 resistencias de 220 Ohms
  •     3 resistencias de 330 Ohms
  •     3 transistores 2N2222
  •     PIC16F628A
  •     7805-CT Regulador Tension 5V

Diagrama de conexiones:

Este diagrama de conexiones lo encontre en una pagina donde querian lograr algo parecido, las conexiones son las mismas, solo que en el PIC cambio los pines de salida RB0-RB7 y RA0 son los catodos y RA1 a RA3.

[Imagen obtenida de: http://www.instructables.com/files/deriv/FGC/TB26/GIYWWDPB/FGCTB26GIYWWDPB.MEDIUM.jpg]

Código:
#include "pic16f628a.h"
#define __16f628a


unsigned int __at 0x2007 __CONFIG = _INTOSC_OSC_CLKOUT &// Internal 
  _WDT_OFF&
  _LVP_OFF&
  _DATA_CP_OFF&                                                                                                                              
  _PWRTE_ON;

unsigned short int i;//variable contador

int main(void){

  TRISB = 0x00;//Configura los pines de PORTA como salidas
  TRISA = 0x00;//Configura los pines de PORTA como salidas
  while(1){
 PORTA = 0b00001110;// Todos los niveles siempre estan encendidos

 PORTB = 0b00000001; // Estado inicial
 for( i = 0; i < 50000; i++);

 PORTB = 0b00000010; //Enciende la segunda columna y espera
 for( i = 0; i < 50000; i++);

 PORTB = 0b00000100;
 for( i = 0; i < 50000; i++);

 PORTB = 0b00001000;
 for( i = 0; i < 50000; i++);

 PORTB = 0b00010000;
 for( i = 0; i < 50000; i++);

 PORTB = 0b00100000;
 for( i = 0; i < 50000; i++);

 PORTB = 0b01000000;
 for( i = 0; i < 50000; i++);

 PORTB = 0b10000000;
 for( i = 0; i < 50000; i++);

 PORTB = 0x00;
 PORTA = 0b00001111;
 for( i = 0; i < 50000; i++);

 PORTB = 0b11111111; // Enciende todos los leds
 PORTA = 0b00001111;
 for( i = 0; i < 50000; i++);

  }

  return 0;

}


 
Ahora uno de los problemas a los que me enfrente en este punto es que todos los leds de un nivel comparten conexión, por tanto si trato de implementar algunas secuencias se encienden leds que no deberían, para resolver este problema utilice una técnica de conexión llamada multiplexado de la cual hablare en la próxima publicación.

Referencias:
http://pcbheaven.com/wikipages/How_Key_Matrices_Works/
http://galaxi0.wordpress.com/about/salidas-y-entradas-digitales/matriz-de-leds/
http://pcbheaven.com/wikipages/How_Key_Matrices_Works/

lunes, 21 de mayo de 2012

Proyecto de Integrados - Arduino Facebook RSS Reader

Descripción:

Mediante una pequeña pantalla LCD de 16x2, el Arduino muestra las notificaciones de un determinado usuario de Facebook(en este caso yo). Estas notificaciones son descargadas por un script de Python, que usando la librería feedparser graba las últimas 10 notificaciones, y las envía mediante conexión serial al Arduino, que después las mostrará en el LCD.

Materiales:
  • Arduino UNO R3
  • Protoboard
  • Display LCD 16x2(JHD 162A)
  • Potenciómetro rotacional lineal.
  • Cable para conexiones
  • Cable USB-Arduino
Diagrama de Conexiones

Circuito

Para conectar el display LCD al arduino, se conectan los siguientes pines:
  • Pin LCD RS al pin digital 12
  • Pin LCD Enable al pin digital 11
  • Pin  LCD D4 al pin digital 5
  • Pin  LCD D5 al pin digital 4
  • Pin  LCD D6 al pin digital 3
  • Pin  LCD D7 al pin digital 2
  • Pin LCD Bklt - a GND.
  • Pin LCD Bklt + al pin 13 del Arduino.
Adicionalmente, se conecta un potenciómetro de rotación lineal a +5V y GND del Arduino, con su salida al pin VO(pin 3) del display LCD.

Funcionamiento

Funcionamiento del Display LCD

El LCD tiene un interfaz paralelo, significando esto que el microcontrolador tiene que manipular varios pines del interfaz a la vez para controlarlo. El interfaz consta de los siguientes pines:
  • Un pin de selección de registro (RS) que controla en qué parte de la memoria del LCD estás escribiendo datos. Puedes seleccionar bien el regisro de datos, que mantiene lo que sale en la pantalla, o un registro de instrucción, que es donde el controlador del LCD busca las instrucciones para saber cual es lo siguiente que hay que hacer.
  • El pin de lectura/escritura (R/W)que selecciona el modo de lectura o el de escritura.
  • Un pin para habilitar (enable) que habilita los registros.
  • 8 pines de datos (D00-D07). Los estados de estos pines (nivel alto o bajo) son los bits que estás escribiendo a un registro cuando escribes, o los valores de lectura cuando estás leyendo.
Hay también un pin de contraste del display (Vo), pines de alimentación (+5V y GND) y pines de retro-iluminación (Bklt+ y Bklt-), que te permiten alimentar el LCD, controlar el contraste del display, o encender y apagar la retro-iluminación, respectivamente.

El proceso de controlar el display involucra la colocación de los datos que componen la imagen de lo que quieres mostrar, en los registros de datos, y luego, colocar las instrucciones, en el registro de instrucciones. La librería LiquidCrystal te simplifica todo este proceso de forma que no neesitas saber las instrucciones de bajo nivel.

Los LCD-s compatibles con Hitachi pueden ser controlados de dos modos: 4 bits u 8 bits. El modo de 4 bits requiere siete pines de E/S de Arduino, mientras el modo de 8 bits requiere 11 pines. Para mostrar texto en la pantalla, puedes hacer la mayoría de las cosas en modo 4 bits.

Funcionamiento del Arduino
El Arduino sirve de interfaz entre el script de python que descarga las notificaciones, y como se muestran en el display. El IDE de Arduino tiene una librería llamada LiquidCrystal, que ayuda bastante al manejo de un display conectado con el Arduino. Esta librería permite a la placa Arduino controlar displays LCD basados en el chipset Hitachi HD44780 (o compatibles), que se encuentra en la mayoría de LCDs de texto. La biblioteca trabaja en modo 4-bit o en 8-bit (es decir, por medio de 4 u 8 líneas de datos, además de RS, ENABLE, y, opcionalmente, las líneas de control RW).

Contiene funciones como:
  • begin(). Usada para definir las dimensiones del display.
  • clear(). Usada para borrar los contenidos del display.
  • write(), print(). Usadas para mostrar contenido en el display.
  • setCursor(). Usada para definir donde escribir en el display.
También cuenta con una función para poder hacer scroll al texto, es decir moverlo fuera de la pantalla para poder mostrar largas cadenas de texto que normalmente no podrían ser mostradas. Pero yo no hice uso de esta función, ya que el scroll que hace es total, y al mover todo el texto, cosas que yo deseo sean estáticas también se moverían por lo tanto tuve que implementar un scroll propio, que será explicado el el código.

Entonces, la función del Arduino es recibir las notificaciones desde el script de python mediante una conexión serial, para después imprimirlas en la pantalla LCD. La conexión serial me permite enviar una cadena de texto u otra información char por char, entonces para que el Arduino pueda identificar que información se está enviando, antes de enviar cualquier cosa, el primer char es un identificador, como la letra "N" para las notificaciones, o la letra "T" para actualizar el reloj. Con esto podemos asegurarnos que no se confunda la información. 

Funcionamiento del Código Python

El código en Python es un script simple, que usando la librería feedparser, descarga las notificaciones de mi Facebook personal(copiando el link rss de mi Facebook, por lo cual EN EL CÓDIGO QUE PUBLICARÉ SERÁ OMITIDO, Y ES IMPORTANTE SI DESEAN PROBARLO ESPECIFICAR SU PROPIO LINK RSS DE FACEBOOK).

Después de descargarlas, les realizo varias funciones a cada notificación, como quitarles acentos para evitar problemas en el display, cortarlos a un tamaño que pueda ser mostrado, y demás.Primero el código establece la conexión con el Arduino, después actualiza la hora con la hora de la computadora, entonces las notificaciones son enviadas al Arduino. Y el código espera hasta que se cumple un tiempo determinado(5 minutos aproximadamente por defecto) para poderse reiniciar y actualizar las notificaciones.


Imágenes del Circuito en Funcionamiento





Video


Código Python:

#!usr/bin/python
import serial, time
import feedparser
import unicodedata
  
#Funcion usada para quitar los acentos de las notificaciones, para poder evitar errores al
#mostrar caracteres en el display LCD
def reemplazar_acentos(s):
   return ''.join((c for c in unicodedata.normalize('NFD', s) if unicodedata.category(c) != 'Mn'))
 
#Funcion que maneja operaciones para cortar las notificaciones a una longitud que pueda ser
#mostrada por el display LCD.
def cortar_notificacion(notif):
 string = ""
 list_string = notif.split()
  
 if "evento" in notif:
  for i in range(len(list_string)):
   if list_string[i] == "evento":
    string+=list_string[i]
    string+=" "
    break
   else:
    string+=list_string[i]+" "
  string+=list_string[i+1]+" "
  string+=list_string[i+2]+"."
  
  
 elif "solicitud" in notif:
  for i in range(len(list_string)):
   if list_string[i] == "solicitud":
    string+=list_string[i]
    string+="."
    break
   else:
    string+=list_string[i]+" "
   
 else:
  for i in range(len(notif)):
   if notif[i] == ":":
    string+="."
    break
   elif notif[i] == ".":
    string+=notif[i]
    break
   else:
    string+=notif[i]
 if len(string) > 60:
  new_string = ""
  for i in range(57):
   new_string+=string[i]
  new_string+="..."
  string = new_string
 return string
 
#Funcion que descarga las notificaciones y las guarda en una lista, con el string de la notificacion, y su fecha(no usada actualmente)
def get_notificaciones():
 parser = feedparser.parse('Mi link al RSS de mis notificaciones')
 notificaciones = []
 for i in range(0, 10):
  notificaciones.append(cortar_notificacion(reemplazar_acentos(parser.entries[i].title)))
 return notificaciones
 
#Funcion que da formato a la fecha descargada
def formatear_fecha(fecha):
 datos = fecha.split()
 dia = datos[2]
 mes = datos[3]
 hora = datos[4]
 new_hora = ""
 for i in range(len(hora)-2):
  new_hora += hora[i]
 hora = new_hora
 datos = "%s/%s %s"%(dia, mes, hora)
 return datos
  
if __name__ == "__main__":
 try:
  #Abrimos el puerto serial, este puede variar dependiendo de la conexion, en este ejemplo es
  #COM3
  print "Abriendo puerto serial"
  ser = serial.Serial('/dev/ttyACM0', 9600, timeout=1)
  #Esperamos 2 segundos, es importante o se puede perder la primera escritura en la conexion
  while True:
   time.sleep(2)
   #Actualizamos el reloj y obtenemos las notificaciones
   print "Actualizando el reloj"
   notificaciones = get_notificaciones()
   #Damos el formato de fecha que deseamos al tiempo actual, y lo enviamos al Arduino
   tiempo = time.strftime("%H:%M:%S", time.localtime())
   ser.write("T")
   ser.write(tiempo)
   print tiempo
   #Obtenemos el tiempo actual para compararlo despues y reiniciar cuando llegue a un
   #determinado tiempo para actualizar las notificaciones
   t = time.time()
   control = True
   i=0
   #Repetimios hasta que control cambie a false(se cumpla el tiempo de actualizacion)
   while(control):
    #Leemos un string enviado desde el arduino, este string debe ser un 'YES' o un
    #'NO', esto para poder saber si el Arduino esta listo para recibir una nueva
    #notificacion
    string = ser.read(100)
    #Si esta listo, y aun no enviamos las 10 notificaciones, escribimos una notificacion
    if "YES" in string and i<10:
     print 'yes'
     ser.write("%")
     ser.write(notificaciones[i].encode('utf-8'))
     print "Escribiendo notificacion: %s"%notificaciones[i]
     i+=1
    #Comparamos el tiempo actual con el inicial, si se cumplio el tiempo solicitado salimos
    #del while
    if (time.time() - t)>  300:
     control = False
   #Abrimos y cerramos el puerto para reiniciar la conexion, y actualizar, esperamos de nuevo 2 segundos
   print "Reiniciando"
   ser.close()
   ser.open()
    
 except serial.SerialException as e:
  print e

Código Arduino:

#include <TimedAction.h>
#include <LiquidCrystal>
//Variable LCD que usaremos para controlar la pantalla
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
//Variables para controlar el reloj
byte hora = 12, minu = 0, seg = 0;
//Variable usada para contar el tiempo que paso desde
//otra comparacion de tiempo, y saber cuando se cumple
//1 segundo sin usar delays
long previousMillis = 0;  
//Strings usadas para almacenar las notificaciones
String string = "";
String notifications[10];
//Variables para controlar cual notificacion se 
//muestra actualmente
int currentString = 0, maxim = 0, num = 0;
//Especie de threads, que corren cada cierto tiempo
TimedAction scrollAction = TimedAction(250, scroll);
TimedAction readSerialAction = TimedAction(1, readSerial);

//Setup del Arduino, definimos el LCD, y encendemos el pin 13
//que esta conectado al backlight del display LCD
//Tambien inicializamos una conexion serial con 9600 de baud rate
//e imprimimos YES para dar a conocer al script de python que
//es posible leer  una notificacion
void setup(){
  lcd.begin(60, 2);
  pinMode(13, OUTPUT);
  digitalWrite(13, HIGH);
  Serial.begin(9600);
  Serial.print("YES");
}

//Funcion simple que converte los numeros del reloj(ints)
//en un string, agregandole un 0 si es menor a 10 para poder
//mostrarlo correctamente.
String getClockShowNumber(int number){
  if(number < 10){
    return ("0"+number);
  }
  else{
   return (""+number); 
  }
}
//Funcion que actualiza el reloj si ya se cumplio 1 segundo
//desde la ultima vez que se actualizo
void updateDisplay(){
    delay(250);
    unsigned long currentMillis = millis();
    if(currentMillis - previousMillis > 1000) {
      previousMillis = currentMillis; 
      Clock();
      char text_buffer[51];
      sprintf(text_buffer,"<%02d/%02d>%02d:%02d:%02d                                   ", 
      num+1, maxim, hora, minu, seg);
      lcd.setCursor(0, 0);
      lcd.print(text_buffer);
      text_buffer[8] = 0; 
    }
}
//Funcion que checa los valores del reloj para sumarlos
//correctamente
void Clock(){
    //updateDisplay();
    seg = seg + 1;
    if(seg > 59){
      seg = 0;
      minu = minu + 1;
      if(minu > 59){
        minu = 0;
        hora = hora + 1;  
        if(hora>23){
          hora = 1;
        }
      }
    }
  }
 
//Funcion que hace un scroll especial al LCD, dando scroll
//solamente a la segunda linea del display, y dejando la
//primera intacta
void scroll(){
  String temp_string = notifications[num] + "   ";
  for(int i = 0; i < temp_string.length()-16; i++){
    lcd.setCursor(0, 1);
    for(int j=i; j<16+i; j++){
        //readSerialAction.check();
        lcd.print(temp_string[j]); 
    }
    updateDisplay();
  }
}

//Funcion que actualiza el reloj despues de recibir la hora
//actualizada desde el script de python en la computadora
void updateClock(String time){
   //Arreglo[hora, min, seg]
   String temp[3] = {"", "", ""};
   int currentString = 0;
   for(int index = 0; index < time.length(); index++){
     if(time[index] == ':'){
       currentString++;
     }
     else{
       temp[currentString] += time[index]; 
     }
   }
   //Serial.print(temp[0]+":"+temp[1]+":"+temp[2]);
    hora = temp[0].toInt();
    minu = temp[1].toInt();
    seg = temp[2].toInt();
}

//Funcion que lee trafico desde la conexion serial, identifica
//que tipo de datos se recibiran, y los almacena o actua dependiendo
//del tag especificado. 
void readSerial(){
  int i = 0;
  boolean control = true;
if(Serial.available()){
          switch(Serial.read()){
            case '!':
              Serial.print("NO");
              //Serial.print("Reset");
              for(int i=0; i<10; i++){
                notifications[i] = "";
              }
              lcd.clear();
              currentString = 0;
              maxim = 0;
              num = 0;
              Serial.print("YES");
              break;
              
            case '%':
              Serial.print("NO");
              //Serial.print("Notification");
              while(control){
                updateDisplay();
                string = "";
                char c;
                while(Serial.available() > 0){
                     control = false;
                     c = Serial.read();
                     string+=c;
                }
              }
              notifications[currentString] = string;
              currentString++;
              maxim = currentString;
              Serial.print("YES");
              break;
            case 'T':
              Serial.print("NO");
              //Serial.print("Clock");
              String time = "";
              while(control){
                updateDisplay();
                char c;
                while(Serial.available() > 0){
                     control = false;
                     c = Serial.read();
                     time+=c;
                }
              } 
              updateClock(time);
              Serial.print("YES");
              break;
          }
        }
        else{
         updateDisplay();
         if(maxim > 0){
          i = 0;
           lcd.setCursor(0, 1);
           while(notifications[num][i]!= '\0'){
              lcd.write(notifications[num][i]);  
              i++; 
           }  
            if(num < maxim-1){
                num++;
            }
            else{
                num = 0;
            }
            scrollAction.check();
            
          }
        }
}

//Loop, simplemente checa cada cierto tiempo si hay trafico serial
void loop(){
        readSerialAction.check();

  }

Referencias: 

domingo, 20 de mayo de 2012

Llamadas al sistema

Una llamada al sistema es cuando un programa llama a un servicio del Kernel del sistema operativo. Generalmente estos servicios se encuentran disponibles como instrucciones de lenguaje ensamblador pero algunas veces también pueden llamarse (sin tener conocimiento de ello) desde lenguajes de alto nivel.


Kernel o núcleo
Este se considera el principal componente de los sistemas operativos sirve de interfaz entre aplicaciones y el proceso de los datos de bajo nivel hecho por el hardware del equipo. Entre sus funciones están administrar los recursos del sistema como memoria , uso de CPU por las aplicaciones o acceso a interfaces de entrada y salida del equipo.

Ejemplos de esto son:
  • Exit: Para terminar la ejecución de un programa.
  • Fork: Para crear hilos de ejecución.
  • Time: Para ver la hora actual.
  • Open: Para abrir archivos
  • Close: para cerrar archivos
 Como puede observarse estas son funciones muy utilizadas en cualquier lenguaje de programación pero sin darnos cuenta estas son administradas por el núcleo del sistema operativo.

Llamadas al sistema en linux 

Conceptos útiles:

El espacio kernel: En este espacio residen todas las subrutinas que forman parte del kernel tales como módulos o drivers y cualquier otra que tenga que ver con la interfaz kernel.

 El espacio de usuario: En este espacio se encuentran los programas que utiliza el usuario final, tales como shell y cualquiera de los programas que he estado programando de ejemplos en ensamblador.




Existen diferentes implementaciones en el mundo Linux en los procesadores x86 más antiguos se utilizaban interrupciones para migrar de un espacio de usuario a un espacio Kernel ( lo cuál es un objetivo intermedio de las llamadas al sistema).
En Linux en las llamadas al sistema se utiliza el registro "%eax" para identificar la llamada al sistema que se quiere invocar, la cual se especifica en una biblioteca de Ansi C. Para empezar la llamada al sistema se invoca al vector de interrupción de Linux (0x80) que contiene las direcciones de memoria de los controladores de interrupciones. Cuando una llamada al sistema es generada, el sistema operativo salva el estado de ejecución del proceso y empieza la ejecución del controlador de llamadas al sistema en el vector de interrupciones.

Una vez esto el controla de llamadas al sistema provoca la ejecución de la función "system_call", esta función controla todas las llamadas al sistema, y toma como parámetro el valor contenido en el registro %eax para identificar la llamada en especifico. Una vez realizadas una serio de verificaciones se invoca la llamada real al sistema utilizando la funcion "system_call_table" y el indice en "%eax". Una vez que el kernel termina su ejecución invoca ala función "system_call_exit" y se llama a las transiciones de resumen "resume_userspace" nuevamente para regresar al espacio de usuario para regresar a la aplicación del usuario.




Por último en la página que esta abajo encontré la lista de llamadas al sistema implementadas en el Kernel de Linux, que utilicé como guía para mi ejemplo de este tema.


Ejemplo de llamada al sistema en ensamblador x86


Parametros

En la tabla de llamadas al sistema de linux se puede ver que en a partir de la tercera columna se encabezan nombres de registros y en las celdas tipos de variables. Esto es por que estos registros se utilizan como parámetros para las funciones de llamadas al sistema, el primer parámetro va en el registro "%ebx" el segundo va en "%ecx", el tercero en "%edx" y el cuatro en "%esi", el quinto en "%edi" y el sexto y ultimo en "%ebp".


Hilos usando llamadas al sistema
Como ejemplo de una llamada al sistema decidí implementar la llamada al sistema numero dos del kernel de linux con el que cuento, esta de lo que se encarga es de partir nuestro proceso en dos y crear una copia exacta del mismo que corre de manera independiente del proceso del cual fue creado.
 
.LC0:
 .string "A: %d\n"
.LC1:
 .string "B: %d\n"
.LC2:
 .string "%d\n"
  
 
.globl A  ;Esta función solo sirve para imprimir el resultado
A:             ;con el nombre del thread que lo manda.
 pushq %rbp
 movq  %rsp,  %rbp

 movq 16(%rsp), %rsi
 movq $.LC0,   %rdi 
 movl $0,   %eax
 call printf

 leave
 ret

.globl B  ;Esta hace lo mismo con el threadB
B:
 pushq %rbp
 movq  %rsp,  %rbp

 movq 16(%rsp), %rsi
 movq $.LC1,   %rdi 
 movl $0,   %eax
 call printf

 leave
 ret


.globl threads
threads:
 pushq %rbp  ;Recuperamos la base y el top de la función en el stack de memoria 
 movq %rsp,  %rbp  
 subq $8, %rsp

 movq $50, 16(%rsp)
 movq  $2,  %rax  ;Aquí es donde se define el parámetro al kernel de la función del sistema a la cual queremos llamar
 int $0x80 ;Aquí se hace la interrupción y la llamada a system_call
 
 cmpq  $0, %rax ;El parametro de la llamada se devuelve en el registro %eax
 jz .threadA           ;Si el valor es cero significa que se esta en el proceso padre
 
 cmpq  $0, %rax ; En caso contrario se esta en un proceso hijo
 jg .threadB
 
 cmpq  $0, %rax
 jl .threadB

 
.threadA: ; estas funciones solo aumentan y disminuyen el valor en 16(%rsp), despues salen y terminan su ejecución
 addq $1, 16(%rsp) ; aquí se aumenta
 pushq 16(%rsp)
 call A
 popq %rax
 
 cmpq $100, 16(%rsp)
 jge  .fin

 cmpq $2000, 16(%rsp)
 jl .threadA

.threadB:
 subq $1, 16(%rsp) ; aqui se disminuye
 
 pushq 16(%rsp)
 call B
 popq %rax

 cmpq $0, 16(%rsp)
 jle  .fin

 cmpq $0, 16(%rsp)
 jg .threadB

.fin:
 movq $1, %rax
 int $0x80
 

Lo que imprimió en la terminal es lo siguiente:

Como puede observarse cada impresión en la terminal se hace de forma asíncrona entre las dos funciones, ademas de que a pesar de que parece que comparten la misma dirección de memoria como contador, eso no es verdad pues como vemos la misma variable tiene valores diferentes para cada thread, lo cual nos dice que el kernel nos asigna un nuevo stack de memoria exclusivo para el nuevo thread.


jueves, 17 de mayo de 2012

Proyecto PIC - Cubo de leds de 3x3x3 - Conway's game of life


[imagen obtenida de: "http://www.instructables.com/image/FVPNNP2GE7L7F11/LED-Cube-3x3x3-with-ATMEGA8.jpg"]

¿Qué es el juego de la vida?
El juego de la vida es un autómata celular creado en 1970 por el matemático británico John Horton Conway. Este juego es de cero personas esto quiere decir que para interactuar con el se crean configuraciones iniciales y se observa como avanzan en tiempos discretos.

Reglas del juego

El juego representa seres vivos que interactúan entre si, se representa por medio de una malla cuadrada de dos dimensiones, y cada célula puede tener dos estados, vivo o muerto. El sistema avanza en estados discretos y el estado siguiente de cada célula depende de la cantidad de vecinos en un estado anterior.

Las reglas del juego son las siguientes.
Cada célula viva con menos de dos vecinos vivos, muere por desolación.
Cada célula viva con dos o tres vecinos vivos sobrevive al siguiente estado.
Cada célula viva con mas de tres vecinos vivos muere por sobre población.
Cada célula muerta con exactos tres vecinos vivos se convierte en una célula viva, por que se reproducen.

Juego de la vida en un cubo



[Imagen obtenida de: "http://aeytimes.com/files/1fbccafac86894e5.jpg" ]

El juego de la vida cambia cuando se presenta en tres dimensiones debido a que la cantidad de vecinos posible por cada célula aumenta , por tanto es necesario cambiar los rangos de vida o muerte de la función, para eso en una página (El enlance en referencias) encontré un método para hacer mas estable el cubo poniendo los rangos de vida y muerte en un vector con cuatro valores.

En este método una célula vive en el siguiente estado si la cantidad de vecinos es mayor igual a R[0] y menor igual a R[1] y estará muerto al siguiente estado si la suma de vecinos es mayor que R[2] y menor que R[3].


Materiales:
  • 27 Leds (En este caso tenemos leds verdes claros)
  • Cautín
  • Estaño
  • 9 resistencias de 220 Ohms
  • 3 resistencias de 330 Ohms
  • 3 transistores 2N2222
  • Un trozo de madera
  • PIC16F628A
  • 7805-CT Regulador Tension 5V

Diagrama conexiones
[Imagen obtenida de: "http://www.instructables.com/files/deriv/FGC/TB26/GIYWWDPB/FGCTB26GIYWWDPB.MEDIUM.jpg"]


Funcionamiento
El cubo de Leds se construye por capa, donde cada capa tiene nueve Leds soldados unos con otros utilizando los alambres de sus cátodos, en los Leds que están encima de otros todos se encuentran soldados por su ánodo. Poniendo corriente negativa a cada nivel y positiva a cada ánodo de la capa base de el cubo para encender un solo led en cualquier nivel.
Cada ánodo(nueve) y cada cátodo(tres) del cubo esta conectada a un pin del PIC configurado como salida del PIC. Para encender un led se debe dar salida positiva en el pin del PIC a la columna del led y a su nivel.  Para cerrar el circuito al darle salida positiva a los pins de los ánodos no hay ningún problema pero para los cátodos utilizo un transistor 2N2222 como un operador "AND", conectando el emisor al cátodo del nivel del cubo,  el colector a la salida positiva del PIC asociada a el nivel y la base a tierra.


Código


#include "pic16f628a.h"
#define __16f628a

unsigned int __at 0x2007 __CONFIG = _INTOSC_OSC_CLKOUT &// Internal oscillator                                                                                         
  _WDT_OFF&// No Watchdog                                                                                                                                              
  _LVP_OFF&// No Low-Volt Program.                                                                                                                                     
  _DATA_CP_OFF&// No Code Protect                                                                                                                                      
  _PWRTE_ON;

#define len 3
unsigned short int cube[len][len][len] = {{
 {0, 0, 0},
 {0, 1, 0},
 {0, 0, 0}
 },
 {{0, 0, 0},
 {0, 1, 0},
 {0, 0, 0}
 },
 {{0, 0, 0},
 {0, 1, 0},
 {0, 0, 0}
 }};

unsigned short int vecinos[len][len][len] = {{{0, 0, 0},{0, 0, 0},{0, 0, 0}},{{0, 0, 0},{0, 0, 0},{0, 0, 0}},{{0, 0, 0},{0, 0, 0},{0, 0, 0}}};

static unsigned short int R[] = {6,6,5,3};
unsigned short int i,j,l, z, d;
short int i2,j2,l2;

void calcular_vecinos(){
 vecinos[i][j][l] = 0;
    for( i2 = i-1; i2<=i+1; i2++){
     for( j2 = j-1; j2<=j+1; j2++){
   for( l2 = l-1; l2<=l+1; l2++){
    if( (i2>=0) && (j2>=0) && (l2>=0) && (i2<3) && (j2<3) && (l2<3) ){

     if( ( cube[i2][j2][l2] == 1 ) && ( (i2 != i) || (j2 != j) || (l2 != l) ) )
      vecinos[i][j][l]++;
    }
   }
  }
 }
}

void siguiente_estado(void){
    for( i = 0; i<3; i++){
     for( j = 0; j<3; j++){
   for( l = 0; l<3; l++){
    calcular_vecinos();
   }
  }
 }

    for( i = 0; i<3; i++){
     for( j = 0; j<3; j++){
   for( l = 0; l<3; l++){

    if( cube[i][j][l] == 1 ){
     if( (vecinos[i][j][l] > R[2]) || (vecinos[i][j][l] < R[3]) )
      cube[i][j][l] = 0;
    }else{
     if( (vecinos[i][j][l] >= R[0]) || (vecinos[i][j][l] <= R[1]) )
      cube[i][j][l] = 1;
    }
   }
  }
 }
}

int main(void){
 TRISB = 0x00; // Set port B as all outputs
 TRISA = 0x00; // Set port A as all outputs 

 while(1){
  for( z=0; z<20; z++){

    for( i = 0; i<3; i++){
      for( j = 0; j<3; j++){
        for( l = 0; l<3; l++){
   if( cube[i][j][l] == 1 ){
     
     if( l == 0) PORTA = 0b00000010;
     if( l == 1) PORTA = 0b00000100;
     if( l == 2) PORTA = 0b00001000;
     if(( i == 0)&&(j == 0)) PORTB = 0b00000001;
     if(( i == 0)&&(j == 1)) PORTB = 0b00000010;
     if(( i == 0)&&(j == 2)) PORTB = 0b00000100;
     if(( i == 1)&&(j == 0)) PORTB = 0b00001000;
     if(( i == 1)&&(j == 1)) PORTB = 0b00010000;
     if(( i == 1)&&(j == 2)) PORTB = 0b00100000;
     if(( i == 2)&&(j == 0)) PORTB = 0b01000000;
     if(( i == 2)&&(j == 1)) PORTB = 0b10000000;
     if(( i == 2)&&(j == 2)) PORTA = PORTA + 0b00000001;

                          for( d = 0; d<500; d++);
     PORTB = PORTA = 0;
   }
        }
      }
    }
  }
  siguiente_estado();
  
        }
 return 0;
}


Video demostrando el funcionamiento.


Referencias:
http://www.bitstorm.org/gameoflife/
http://www.ibiblio.org/e-notes/Life/Game.htm
http://es.wikipedia.org/wiki/Juego_de_la_vida