viernes, 27 de abril de 2012

USART en microcontroladores AVR

Como su nombre lo indica, el módulo USART soporta la transmisión sincrónica y la transmisión asincrónica, así como también soporta el modo de reloj maestro y esclavo.

En la USART, un baudio equivale a un bit por segundo y esta tasa de transferencia depende de la frecuencia de reloj y de los valores de configuración almacenados en los registros de control. Se pueden generar tramas de 5, 6, 7, 8 y 9 bits con uno o dos bits de parada que señalan el final de una trama (en la comunicación asincrónica) según la configuración que ingrese el usuario.

El bit de paridad es un bit de control opcional que se envía al final de una trama antes del bit de parada para verificar si existe algún error en la comunicación. Este bit se calcula contando el número de bits '1' que se envían: si se escoge paridad par, este bit será '1' si el número de '1's es par, y será '0' en caso contrario; si se escoge paridad impar, el bit de paridad será '0' si el número de '1's es par y '1' en caso contrario.

El bit de paridad se genera por hardware en el transmisor de la USART realizando una or exclusiva entre todos los bits de una trama; y es verificado en el receptor también por hardware. Este bit sirve para detectar si ocurrió un error en la comunicación, pero no sirve para asegurar que todos los bits llegaron correctamente.

En una transmisión asincrónica, una trama de datos inicia con un bit de arranque, seguido del bit menos significativo de información y cada uno de los siguientes bits hasta un máximo de 9, terminando con el bit más significativo. Si la paridad está habilitada, el bit de paridad se envía inmediatamente después de los datos, seguido de los bits de parada. Cuando se termina de enviar la trama, se puede enviar otra inmediatamente o se puede dejar el canal libre esperando otra trama.

A continuación se muestra un ejemplo de uso de transmisión y recepción serial entre el ATMEGA16.

Para realizar este ejemplo se creó una librería con funciones comunes de la USART: inicializar el módulo, transmitir un dato, recibir un dato y transmitir una cadena. Estas funciones se muestran en el código a continuación:

/* usart.h: Librería para el manejo del USART */
#ifndef USART_H
#define USART_H

#include<avr/io.h>

void USART_Init( unsigned int baud);
void USART_Transmit( unsigned char data);
unsigned char USART_Receive( void );
void USART_TransmitString(char cadena[]);

/* Función inicializar USART */
void USART_Init( unsigned int baud )
{
    // Se establece la tasa de baudios con el valor ingresado a
    // la funcion
    UBRRH = (unsigned char)(baud>>8);
    UBRRL = (unsigned char)baud;
    // Se habilita la recepción y la transmisión de datos
    UCSRB = (1<<RXEN)|(1<<TXEN);
    // Se establece el formato de la trama: 8 bits de datos, 
    // 2 bits de parada, sin bits de paridad
    UCSRC = (1<<URSEL)|(1<<USBS)|(3<<UCSZ0);
}

/* Función transmitir datos */
void USART_Transmit( unsigned char data )
{
    // Espera hasta que el buffer esté vacio
    while ( !( UCSRA & (1<<UDRE)) );
    // Pone el dato en el buffer de transmisión, envía el dato
    UDR = data;
}

/* Función recibir datos */
unsigned char USART_Receive( void )
{
    // Espera a recibir datos
    while ( !(UCSRA & (1<<RXC)) );
    // Devuelve el dato leido
    return UDR;
}

/* Transmitir una cadena */
void USART_TransmitString(char cadena[])
{
    int i; // Índice

    for(i=0;cadena[i]!='\0';i++) // Recorre la cadena
        USART_Transmit(cadena[i]); // Transmite el dato
}
#endif

El programa principal se muestra a continuación:

//***************************************************************
// Programa de prueba de envío y recepción de datos por USART
//
// Descripción: Este programa inicializa el módulo USART, envía
// datos caracter por caracter para formar la cadena "hola". 
// Luego envía una cadena de prueba y a continuación queda en un 
// ciclo infinito a la espera de los datos que ingresa el usuario
// y los envía nuevamente por el USART.
//    
// Creado:        04/06/2010
// Modificado:    21/06/2010
// Autor:         L.A. Mongua - A.F. Quiceno
//***************************************************************

// Dispositivo = ATMEGA16
// Fclk = 8.0MHz
#include "usart.h" // Librería con las funciones del USART

int main()
{
    // Se declaran las variables en las que se almacenarán los
    // datos recibidos
    unsigned char recibido;
    // Se ajusta la tasa de baudios en 9600
    USART_Init(51); //Tabla 70 hoja de datos ATMEGA16 (pag. 164)
    // Se transmite la cadena "hola"
    USART_Transmit('h');
    USART_Transmit('o');
    USART_Transmit('l');
    USART_Transmit('a');
    USART_Transmit(' '); // Se transmite un espacio
    USART_TransmitString("esto es una prueba");
    USART_Transmit(13); //Fin de línea
    while(1){
        // Cada vez que se reciba un dato
        recibido=USART_Receive();  
        // Se transmite nuevamente el mismo dato
        USART_Transmit(recibido);
    }    // El programa se queda esperando a que un nuevo dato 
        // sea recibido
}

lunes, 9 de abril de 2012

Plataforma de proyectos Redmine


Redmine es un aplicativo Web que permite la administración y gestión de proyectos de todo tipo, pero se encuentra enfocado especialmente a proyectos de ingeniería y de sistemas. El lenguaje de programación sobre el que corre la plataforma es Ruby. Ruby es un lenguaje interpretado que ha tomado un gran auge en los últimos años, en especial por su alta funcionalidad en aplicativos tipo Web.


La plataforma tiene un motor de base de datos que permite almacenar toda la información de manera estructurada y organizada. Dicho motor de base de datos no solo le va a brindar mayor seguridad a la información de la plataforma (ya sea información del aplicativo o información del usuario), sino que prestará mayor rapidez al usuario final.

La plataforma tiene la ventaja de ser una herramienta web: lo anterior garantiza su ubicuidad, ya que actualmente casi todo equipo de cómputo tiene un navegador web y está conectado a internet. La plataforma se puede trabajar concurrentemente por múltiples usuarios en múltiples equipos y la limitación sólo radicará en el hardware empleado para el montaje de la plataforma y la conexión del mismo con internet.

La aplicación Redmine incluye los siguientes módulos por defecto:

Vistazo

En vistazo, el usuario puede darse una rápida impresión del alcance del proyecto, ya que allí se informa de manera gráfica los usuarios del proyecto discriminados en los diferentes grupos que lo componen, los subproyectos del mismo y un resumen de las peticiones.

Actividad

En actividad se puede ver un histórico de las modificaciones hechas al proyecto, donde además se muestra quién lo hizo y qué hizo. Esto puede contribuir significativamente en la trazabilidad rápida del proyecto ya que informa sobre los cambios  específicos sin tener que incurrir en una revisión minuciosa de todo lo documentado.

Peticiones

Las peticiones son una herramienta valiosísima de la plataforma, ya que permiten segmentar los problemas y proyectos en unidades mucho más básicas que puedan ser resueltas por uno o por varios usuarios y que, además, puedan ser asignadas, revisadas, auditadas por otros usuarios del proyecto. Las peticiones tienen muchos campos que ofrecen una gran cantidad de información sobre el desarrollo de las mismas, tales como asignado, tiempo estimado, tiempo total, prioridad, etc.

Cuando se ha dividido el proyecto en peticiones, se puede apreciar un diagrama de tiempos donde aparezca cada una de ellas con su respectivo porcentaje de realización, así como también se puede observar en un calendario qué peticiones están activas por usuario.

Noticias

Al llevar a cabo varios proyectos que incluyan diferentes desarrolladores en cada uno, el módulo noticias permite informar sobre los asuntos relevantes a todos aquellos incluidos en la plataforma, de tal modo que todos se puedan enterar de los avances de cada proyecto sin necesidad de entrar en el detalle netamente técnico. Las noticias buscan siempre la información global sobre la particular.

Documentos

De la gestión documental de un proyecto depende su éxito. Manejar el proceso de documentación sobre la plataforma es muy sencillo. Existen 3 módulos que permiten dividir la información de manera concreta como lo son Documentos, Wiki y Archivos. En documentos existe la posibilidad de adjuntar archivos a la plataforma de la forma de un anexo, es decir, un documento posiblemente de otros autores o que por no estar tan relacionado con el proyecto no se incluye dentro del cuerpo del mismo. Allí se puede hacer una descripción del documento y se puede crear una sección completa relacionada con el mismo, todo en formato wiki.

Wiki

Hoy día se habla mucho de wikis por la alta penetración al mercado de internet. Una wiki es una herramienta de edición colaborativa de textos dónde no se requiere mucho conocimiento de herramientas ni de formatos, ya que todo puede ser editado con texto plano y con simples interfaces web. El objetivo de esto es que de manera rápida se puedan modificar los archivos y hacer documentos que no requieran descargas locales sino que se puedan trabajar siempre desde el modo web. A la hora de generar informes, se puede exportar los creado a formato html y a formato txt.

Archivos

En archivos se puede montar toda aquella información que no tenga una relevancia muy alta y que no requiera texto que la acompañe, por ejemplo imágenes que pudieran llegar a ser útiles pero que no hagan parte de los anexos, versiones intermedias de documentos, etc.

Adicional a los módulos que vienen preinstalados por defecto en la aplicación Redmine, es posible incluir muchos más plugins que le pueden brindar capacidades adicionales a la plataforma. Entre los plugins más útiles encontramos:

DMSF

Este plugin es una evolución del módulo "Archivos" que viene preinstalado por defecto. DMSF permite organizar archivos por carpetas, control de cambios por autor y por versiones, registros de descarga de los archivos y envío por correo de los mismos.

HALTR

Este es un módulo desarrollado para la generación de facturas e información de empresas. Es útil para generar todo tipo de información contable de una compañía, y permite exportar las facturas a formato PDF, incluyendo impuestos, moneda del país y logotipo de la empresa.

A continuación les dejo unas cuantas capturas de pantalla del aplicativo. Se puede encontrar mayor información en la página Web del proyecto (http://www.redmine.org/).






Si siguen estos links, se encontrarán con sitios implementados en Redmine:

lunes, 2 de abril de 2012

Recepción de correo en Python por IMAP

En la entrada de blog anterior se explicó como realizar envíos de correo de forma automática a través de un script en Python. En este caso, voy a explicar en qué consiste el protocolo IMAP (Internet Message Access Protocol), y mostraré un ejemplo de acceso a la cuenta de correo, búsqueda de un mensaje en la bandeja de entrada e imprimirlo en la pantalla de la consola.

El protocolo IMAP permite acceder a mensajes de correo electrónico que se encuentran almacenados en un servidor. A diferencia del protocolo POP, el cual también es usado para acceder a mensajes de correo electrónico de un servidor, permite especificar carpetas, y visualizar los mensajes sin necesidad de descargarlos, como en el caso de POP.

El protocolo IMAP generalmente es escuchado por el servidor en el puerto 143.

Código ejemplo

En el código que se muestra a continuación se hace uso de la librería imaplib de Python, la cual permite conectarse a un servidor IMAP (para este caso el de Gmail), e incluye funciones para búsqueda y recuperación de mensajes recibidos.

En este caso, el programa ejemplo se autenticará a una cuenta de Gmail, se dirigirá a la bandeja de entrada, y buscará los mensajes que contengan en el campo “Asunto”, la cadena que se asigne a la variable string_busqueda. Finalmente, contará los mensajes que cumplen con el criterio de búsqueda, e imprimirá el más reciente en la consola.

Se debe tener en cuenta que si el mensaje contiene imágenes o archivos adjuntos, se mostrará el binario de los mismos, representado en caracteres. Adicionalmente, se imprimirán encabezados y otra información de los mensajes, la cual generalmente no se muestra en los aplicativos Web para acceso al correo.


# vim: set fileencoding=utf-8 :

# Importación de librerías
import imaplib
import email

# Conexión a la cuenta de correo
mail = imaplib.IMAP4_SSL('imap.gmail.com') # Servidor IMAP de GMAIL
mail.login('pepito.perez', 'passxxx')    # Usuario y contraseña

# Lista mensajes de correo electrónico
mail.list()

# Selección de bandeja de entrada por defecto
mail.select()

# String de búsqueda
string_busqueda="Informe"

# Búsqueda de mensajes con el anterior criterio en el campo "Asunto"
typ, resBusq = mail.search(None, '(ALL SUBJECT "' + string_busqueda + '")')

# Se muestran resultados de la búsqueda
if resBusq[0] == '':
  print 'No se encontraron mensajes con la cadena "%s" en asunto' % (string_busqueda)
else:
  resBusq = resBusq[0].split(' ')
  print 'Se encontraron %s mensajes con la cadena "%s" en asunto' % (len(resBusq), string_busqueda)

# Se recupera el mensaje más reciente que cumpla con el criterio de búsqueda
typ, data = mail.fetch(resBusq[-1], '(RFC822)')

# Se convierte el mensaje de String a mensaje de la clase email
msg = email.message_from_string(data[0][1])

# Se imprime en pantalla el mensaje
print msg

# Cierra sesión en la cuenta de correo
mail.logout()