sábado, 21 de mayo de 2011

holaM_tiny.c paso a paso

En la entrada anterior observamos como crear un programa simple para el microcontrolador ATTiny 48/88. La explicación del código fuente del programa viene a continuación:

#define F_CPU 4000000UL

La constante F_CPU sirve para indicarle a la libreria de retardos la frecuencia de operación del microcontrolador. En caso de que no definir la constante F_CPU los retardos generados por la libreria no serán precisos y el compilador mostrará una advertencia.

#include <avr io.h/avr>

Archivo cabecera con todas las definiciones de constantes del microcontrolador. Por ejemplo, DDRD aparece definido como "#define DDRD _SFR_IO8(0x0A)", significa que altera la dirección de memoria 0x0A. En la anterior dirección de memoria configura el modo de entrada o salida del puerto D.

static void init_system(void);

Prototipo de  función, para configurar los osciladores internos del microcontrolador.

int main(void)
{

Inicio de la función principal del programa.

init_system();

Función para configurar el oscilador interno del microcontrolador.

DDRD = (1 << PD3) ;

Corrimiento a la izquierda de 1 hasta la posición de PD3.

for ( ; ; )
{

Inicio del bucle infinito del programa, en otras palabras la sección del programa que siempre se ejecutará.

PORTD = (1 << PD3);

Pone a 1 el bit PD3 en el puerto D. Estrictamente hablando primero se hace un corrimiento a la izquierda de 1 hasta la posición PD3, éste valor pasa a PORTD.

_delay_ms(500);

Función de retardo de 500 milisegundos.

PORTD = (0 << PD3);

Pone a 0 el bit PD3 en el puerto D. Actúa de forma similar a "PORTD = (1 << PD3)" lo único que cambia ahora es que se escribe un 0 en la posición de PD3.

_delay_ms(500);
}

Retardo de 500 milisegundos y fin del bucle infinito.

static void init_system(void)
{

Inicio de la definición de la función init_system. Static indica al compilador que la memoria reservada a la función siempre se mantenga, aún cuando termine la función. El primer void sirve para indicar que la función no retorna ningún valor. Finalmente el último void sirve para decir que la función no necesita ningún parámetro.

asm("ldi r16, 0x80");

Para insertar código en ensamblador en el programa escrito en lenguaje C se usa "asm("");". El nemotecnico ldi carga el valor 0x80 al registro r16.

asm("sts 0x61, r16");

El nemotecnico sts carga el valor contenido en el registro r16 en la dirección de memoria 0x61. La dirección de memoria 0x61 corresponde a la configuración del oscilador interno del microcontrolador, al cargar el valor 0x80 en la dirección de memoria 0x61 le permite al microcontrolador cambiar el valor del divisor para oscilador interno del microcontrolador.

asm("ldi r16, 0x01");

Carga en el registro r16 el valor de 0x01.

asm("sts 0x61, r16");
}

Pasa el valor de r16 a la dirección de memoria 0x61. Al pasar el valor 0x01 a la dirección de memoria 0x61 el microcontrolador pone un divisor de 2 al oscilador interno, con lo cual queda configurado a una frecuencia de 8Mhz/2=4Mhz. Al final aparece el indicador de fin de función.

Queda terminada la explicación del código de programa para holaM_tiny.c, a partir de este post en adelante sólo explicaré código que haga alguna función especial. Por ejemplo, ya no mencionaré que hace "asm("");".

miércoles, 13 de abril de 2011

Páginas con información útil

Hoy vamos a platicar sobre dos sitios en internet con información bastante interesante de microcontroladores AVR y FPGA.

El primer sitio es: www.avrfreaks.net

Contiene un foro de usuarios con excelente información sobre la familia de microntroladores AVR. Lo interesante del foro es que muchos de sus usuarios son gente con experiencia en la industria usando microcontroladores AVR. También se puede encontrar guías de proyectos completos para principiantes, hasta desarrollos profesionales. No dejen de visitar este sitio, y un agradecimiento a mí profesor de microcontroladores en la universidad, M. C. Carlos E. Canto Quintal por la recomendación del sitio avrfreaks.

El segundo sitio es: www.fpga4fun.com

Un sitio con información detallada sobre FPGA. Hay alrededor de 23 proyectos para construir o implementar en una tarjeta de desarrollo para FPGA. También se encuentran tutoriales, algunos mencionan que son los FPGA, como funcionan, tutoriales de lenguajes de descripción de hardware Verilog y VHDL. Sitio muy completo para iniciar con FPGA. La información más interesante son las secciones que explican como implementar puertos de comunicación en un FPGA, entre los puertos hay serie, I2C, SPI y JTAG.

domingo, 20 de marzo de 2011

Guía iniciación AVR ATtiny 48/88

Los microntroladores ATtiny 48/88 son una familia de microcontroladores de 8 bits. Sus características son:
  • Microcontrolador de 8-bit, de bajo consumo y alto rendimiento.
  • Concebido para ser programado en lenguaje C.
  • 123 instrucciones, la mayoría sólo necesitan un 1 ciclo de reloj.
  • 32x8 registros de proposito general.
  • 4K/8K Bytes de memoria flash programable en circuito.
  • 64 bytes de memoria EEPROM.
  • 256/512 bytes de memoria interna SRAM.
  • Un 8-bit Timer/counter  con prescaler separado y modo de comparación.
  • Un 16-bit Timer/counter  con prescaler, modo de comparación y captura.
  • 6 o 8 canales ADC de 8-bit.
  • Interfase serie SPI maestro/esclavo.
  • Interfase serie de 2 hilos (compatible con I2C Philips).
  • Perro guardian con oscilador separado.
  • Sistema de programación en circuito via SPI.
  • Oscilador interno.
  • 24 líneas programables de entrada/salida.
  • Velocidad de reloj de 4 a 12 Mhz. 

Requisitos para entorno de trabajo:

  • Computadora con sistema operativo LINUX, Windows XP o superior.
  • Programa para entorno de trabajo Atmel AVR Studio 4.18 SP3, página de descarga(solo Windows). 
  • Programador AVRISP mkII o similar.
  • Paquete de compilador y librerías WinAVR , página de descarga (sólo Windows).
  • En los sistemas LINUX instalar los siguiente paquetes:  avr-lib, binutils-avr y gcc-avr.
Una de las mejores formas para aprender a manejar microcontrolares es escribir programas. El primer programa es un equivalente al hola mundo de los programas de computadoras, este programa consiste en encender y apagar un led. Como primer paso hay que crear un archivo con el nombre holaM_tiny.c con un editor de texto de su preferencia. El archivo debe contener el siguiente código fuente:


#define F_CPU 4000000UL
 

#include <avr/io.h>
#include <util/delay.h> 

static void init_system(void);


int main(void)
{
     init_system();
     DDRD = (1 << PD3);

     for ( ; ; )
     {
          PORTD = (1 << PD3);
          _delay_ms(500);
          PORTD = (0 << PD3);
          _delay_ms(500);
     }
}


static void init_system(void)
{
     /* configurar oscilador a 4MHz*/
     asm("ldi r16,0x80");
     asm("sts 0x61,r16");
     asm("ldi r16,0x01");
     asm("sts 0x61,r16");
}



El funcionamiento básico del código es encender y apagar un led, dura encendido 500ms y otros 500ms apagado. El siguiente diagrama muestra como hay que conectar el microcontrolador:


El diagrama utiliza el microcontrolador ATtiny 48/88 en encapsulado PDIP, el número de pin de cada puerto cambia de orden según el tipo de encapsulado. 

Método de compilación en LINUX, en una terminal de comandos  escribir:

$ avr-gcc -g -Os -mmcu=attiny88 -c holaM_tiny.c
avr-gcc -g -mmcu=attiny88 -o holaM_tiny.out holaM_tiny.o

Comando para crear archivo hex. 

$ avr-objcopy -j .text -O ihex holaM_tiny.out holaM_tiny.hex 

Todos los comandos anteriores deben lanzarse usando como carpeta de trabajo en la ubicación del archivo holaM_tiny.c .

Método de compilación en sistemas Windows. El primer paso es abrir el programa AVR Studio 4, después dentro del menú "Project", seleccionar  Project Wizard.

 En la ventana emergente que aparece seleccionar "New Project".

 Después, marcar la opcón de "Project type" en AVR GCC, también seleccionar "Create initial file" "Create folder". En el campo "Project name" poner "holaM_tiny" y en "Initial file" colocar "holaM_tiny".

 En el siguiente paso poner "Debug platform" en "AVR Simulator 2" y en "Device" colocar "ATtiny88". Terminar presionando el botón de "Finish".

 Quedará una ventana con un editor de texto, en este editor de texo colocar el código fuente anterior. Para compilar el proyecto y obtener el archivo hex, hay que ir al menú "Build" y seleccionar "Build".



Para terminar el proyecto sólo hay que cargar el archivo holaM_tiny.hex con el programador de nuestra preferencia. En la siguiente entrada vamos a explicar que realizan cada una de las ordenes del programa. Si alguien tiene alguna duda puede ponerla en la sección de comentarios o mandarme un correo electrónico.
  

domingo, 6 de marzo de 2011

Nueva apertura del sitio

Después de algunos años sin publicar nada en el blog, por fin me he decido a realizar una serie de artículos orientados a conocer los microcontroladores AVR.

La familia de microcontroladores AVR no es muy utilizada en México, lo más común es encontrar gente manejando PICs. Como formación sería bueno que se incluyeran más los microntroladores AVR en los planes de estudio de escuelas mexicanas. Tienen algunas ventajas con respecto a los PIC, una de ellas puede ser que un microcontrolador AVR puede realizar una instrucción por ciclo de reloj, mientras que en un PIC son 4 ciclos de reloj por instrucción (no aplica a todos los modelos).

El primer modelo de microcontrolador a estudiar es el ATtiny48/88.

Continuando con el tema del blog, las publicaciones vendrán con referencia bibliográfica. Ya sea libros, artículos de algún investigador de renombre, hojas de datos, etc. para darle más valor formal a la información publicada.

Después de esta breve introducción no queda más que comenzar.

domingo, 19 de julio de 2009

Guía de instalación ISE 10.1 Archlinux

Para tener nuestro entorno de trabajo con FPGA se requiere instalar alguno de los programas de desarrollo que ofrecen Altera, Xilinx, etc. En nuestro caso se instalará ISE de Xilinx en su versión 10.

Para esta guía se da por hecho que el usuario ya tiene conocimientos básicos sobre instalación y manejo de software en la distribución linux en la que desea instalar estos entornos.

Requisitos de software que se deben tener instalados:

  • El paquete de librerías libmotif3.
  • El paquete portmap.
  • Las librería libusb-dev o sólo libusb si la distribución no quita las cabeceras de desarrollo.
  • El paquete fxload.
  • El programa 7zip.

El paquete completo de instalación se llama ISE Design Suite 10.1, contiene los siguientes programas:

  • ISE
  • EDK
  • Chipscoope
  • Plan Ahead

Con estos programas se tiene un entorno completo de desarrollo  para FPGA de la marca Xilinx.

Paso 1

Lo primero será obtener el programa, podemos descragar una versión gratuita de la página de Xilinx o podemos obtener el programa por otros medios. Para esta guía emplearemos un archivo del DVD de instalación, una imagen de DVD ISO.

Ya tenemos listo el archivo de imagen ISO, lo podemos montar en nuestro árbol de archivos de Linux, y una vez montado se procede a lanzar el instalador gráfico de los programas. La instalación a partir de este momento debe realizarse como usuario root desde una terminal de comandos.

Para montar el archivo se proceda a lanzar el comando como se muestra a continuación:

[usuario@maquina]$su /*para obtener permisos de administrador o usuario root*/
[usuario@maquina]$mount -o loop Xilinx_ISE_DS.iso /media/carpetademontaje/

Hemos conseguido montar el archivo de imagen ISO, procedemos a lanzar el instalador gráfico del programa.

[usuario@maquina]$cd /media/carpetademontaje/ /*nos ubicamos en la raíz del CD*/
[usuario@maquina]$./setup /*lanzador del instalador gráfico*/

Con lo anterior ya tenemos en nuestra pantalla ejecutándose el instalador gráfico. Como es muy parecida su instalación a cualquier programa tipo Windows, se omitirán estos pasos y nos centraremos en las partes que involucran más al sistema Linux. Solo como recomendación instalar los programas en la siguiente dirección /opt/Xilinx/10.1/ ; es casi seguro que el instalador nos ponga esta ruta por defecto, pero en caso que no lo haga lo podemos hacer de forma manual.

PASO 2

Ya se cuenta con la instalación de paquetería completa, lo que debemos hacer ahora es declarar las variables de entorno para poder trabajar con los programas y que estos sean capaces de cargar la librería que maneja el programador de las tarjetas FPGA. Como nota sólo necesitamos estar como usuario normal en la carpeta home de este usuario.

Debemos editar el siguiente archivo y anexar las siguientes líneas:

[usuario@maquina]$nano .bashrc /*debemos estar ubicados en home*/

##anexar las siguiente lineas al archivo anterior
export XILINX=/opt/Xilinx/10.1/ISE
export PATH=$PATH:/opt/Xilinx/10.1/ISE/bin/lin64


export XILINX_EDK=/opt/Xilinx/10.1/EDK
export PATH=$PATH:/opt/Xilinx/10.1/EDK/bin/lin64

Las últimas palabras de las carpetas nos dice lin64; con esto nos damos una idea que esto depende del sistema que estemos usando, ya sea de 64 bits o 32 bits. Para 64 bits debe terminar en lin64. Para 32 bits debe terminar en lin.

PASO 3

El entorno está listo, pero tenemos que el programador Impact no detecta nuestras tarjeta
cuando las conectamos a la computadora. Necesitamos una librería que se descarga de la
siguiente página web:

http://rmdir.de/~michael/xilinx/

Una vez descargado el archivo, tenemos que descomprimirlo. Se puede usar el comando
siguiente como ejemplo:

[usuario@maquina]$tar -xvf usb-driver-HEAD.tar.gz

Se debe haber creado una carpeta nueva y procedemos a ingresar en ella:

[usuario@maquina]$cd usb-driver/

Ya dentro de la carpeta procedemos a compilar la librería:

[usuario@maquina]$make

Se debe haber creado el archivo de librería libusb-driver.so .

PASO 4

Con la librería anterior, ya podremos usar Impact para programar los FPGA. Con el siguiente comando crearemos una carpeta donde se encontrará. Con esto se supone que todavía nos encontramos en la carpeta donde se compiló la librería.

[usuario@maquina]$mkdir ~/flexm

Copiamos la librería a la carpeta que acabamos de crear.

[usuario@maquina]$cp libusb-driver.so ~/flexm

Ahora sólo falta cargar la librería en el espacio de ejecución de una terminal, esto lo hacemos agregando las siguientes líneas al archivo .bashrc .

[usuario@maquina]$cd ~ /*nos ubicamos en la carpeta home del usuario*/
[usuario@maquina]$nano .bashrc

#se insertan las siguientes líneas al archivo
export LD_PRELOAD=/home/ente/flexm/libusb-driver.so

PASO 5

Para terminar necesitamos que al insertarse la tarjeta, por medio del puerto USB. Se cargue el firmware de programación de Xilinx. Para conseguirlo vamos a necesitar de UDEV de linux.

Se tienen que copiar el archivo de reglas de udev que nos proporciona Xilinx. Todo se realiza como usuario root.

[usuario@maquina]$su /*cambio a usuario root*/
[usuario@maquina]$cd /opt/Xilinx/10.1/ISE/bin/lin64/
[usuario@maquina]$cp xusbdfwu.rules /etc/udev/rules.d/

Hay que crear un archivo de reglas que permita que el dispositivo brinde permiso de acceso a todos los usuarios. Para hacerlo realizamos lo siguiente:

[usuario@maquina]$cd /etc/udev/rules.d/

[usuario@maquina]$nano libusb-driver.rules

#se le inserta las siguientes líneas al archivo
ACTION=="add", BUS=="usb", SYSFS{idVendor}=="03fd", MODE="666"

Sólo resta copiar los archivos de programación a la siguiente carpeta:

[usuario@maquina]$cd /opt/Xilinx/10.1/ISE/bin/lin64/
[usuario@maquina]$cp xusb*.hex /usr/share/

Con este último paso ya tenemos todo el entorno listo para trabajar con el programa ISE, ahora hay que reiniciar la computadora para que los cambios realizados a udev surtan efecto.

Una vez que se reinicio la computadora procedemos a verificar que se carguen los firmware necesarios en las tarjeta. Una vez que se conectó por USB una tarjeta empleamos el siguiente comando:

[usuario@maquina]$lsusb /*va a listar todos los dispositivos USB*/

Aparecerá en una de las líneas lo siguiente:

ID 03fd:0008 Xilinx sistems

o una frase similar lo importante es ID 03fd:0008 .

Ya tenemos todo listo para trabajar con ISE.

Para los que les sea más comodo aquí se encuentra la guía en  formato PDF, sólo recordando que es para la distribución Archlinux.

Guía instalación ISE

martes, 14 de julio de 2009

Requsitos para los proyectos

Para comenzar con la serie de artículos sobre los proyectos en VHDL y electrónica, se necesita saber que es lo necesario para comenzar con los desarrollos. He aquí la lista:

  • Computadora con Sistema Operativo Linux, en lo personal uso ARCH Linux pero cualquier distribución es válida.
  • ISE Webpack de Xilinx versión 10.1 o superior.
  • Spartan-3AN Starter Kit o Spartan-3E Starter Kit.

En la parte del sistema operativo de la computadora puede ser también alguna versión de Windows, pongo Linux como base porque es el que uso comúnmente.  Sólo como nota final la mayoría de las técnicas de programación y desarrollo para FPGA se aplican a otras marcas como Altera, Cypress, etc. Por lo que alguien que use otras marcas diferentes a las que se manejan aquí podrá adaptar fácilmente cualquier proyecto a sus necesidades.

domingo, 21 de junio de 2009

Apertura de Blog de electrónica

La apertura del Blog se debe a la necesidad de públicar un sitio con contenidos de electrónica digital, en especial con los circuitos programables.
Espero una vez a la semana públicar un proyecto, que puede ir desde una simple máquina de estados lógicos hasta un controlador de memoria RAM. La idea es ir desarrollando un catálogo de proyectos. La mayoría de proyectos serán de mi autoría, por lo que los códigos fuente tendrán una licencia, ya sea del tipo GPL o BSD. Esto esoy aún por decidirlo.
También espero haya retroalimentación por parte de las personas que le sirva ésta información, para que envíen sugerencias o mejoras en algún código.