Parpadeo: El ' 10 Print "Hola" ' de los Microcontroladores.

En mis tiempos... si, ya habían coyotes, y eran coyotes dientes de sable.... El primer lenguaje que uno aprendía a programar era BASIC y lo primero que uno aprendía a programar en BASIC era:

10 PRINT "Hola"

Run
Hola

Ese arcaísmo de allá arriba lo único que lograba es que una computadora dijera hola. Sin embargo uno debe siempre empezar por algo.

El equivalente a esta practica en cuanto a microcontroladores e refiere es el parpadeo de un led. Es igual de inútil, pero cuando uno lo logra por primera vez, y aun mas cuando logra variar la velocidad del parpadeo suena la musica de fondo de "Odisea 2001" con nosotros interpretando al chango mas listo. Ok, esto ultimo jue una alegoría.

Primero vamos a conectar el foquito. Partiendo de que ya conectamos nuestro programador al Atmega8 y que lo tenemos conectado al puerto USB. El programador tomara 5v de la conexión con la computadora y alimentara al AVR así que no necesitaremos otra fuente de energía para probar nuestro circuito. Necesitaremos un led y una resistencia de 1Kohm. La siguiente ilustración indica como debemos conectarlo. Recuerda que la patita mas larga va conectada al pin 14 del AVR ya que entrega la señal positiva.


Vamos a entender a donde hemos conectado el dichoso foquito.


En esta ilustración podemos ver que el chip tiene 3 puertos de entradas/salidas programables PORTB, con 8 bits disponibles PORTC, con 7 bits disponibles y PORTD con 8 bits a su vez. El patillaje nos dice, por ejemplo que el bit 0 (lsb) del PORTB es la terminal 14 del chip. Tal vez se pregunten ¿Por que están los bits todos fuera de orden? La razón recae en que así es mas fácil soldar las terminales a la pastilla de silicón dentro del encapsulado. Para quien haya usado un 4017 alguna vez esto no sera una sorpresa.

Ahora bien preparemonos para programar. La programación se hace en lenguaje C. No te espantes, yo tampoco lo había usado nunca y se aprende en 3 patadas, al menos lo suficiente como lo para aprovechar estos tutoriales/ejemplos.

Abrimos el CodeVisión por primera vez. En caso de que nos aparezca un programa en la pantalla, este sera el ultimo que usamos. En tal caso elegimos File -> Close All.

Vamos a llamar al asistente Code Wizard que tiene un engrane como icono.

Las imágenes de CodeVision, el programa y nombre CodeVision AVR C Copmiler y demás material incluido en esta son propiedad de HP Info Tech© y se encuentran protegidas por los derechos de autor correspondientes. Se usan con fines meramente didácticos sin perjuicio económico ni moral. Si algún representante debidamente identificado lo solicita serán removidas de este sitio.

Este asistente nos permite configurar el tipo de AVR que usaremos, que tipo de reloj utilizara y la configuración de sus puertos para conectarlo a diversos dispositivos. Lo primero que haremos sera configurar el tipo de chip como Atmega8 quedando de la siguiente manera. (Recuerde que al hacer click en las imágenes estas se muestran mas grandes).

Aquí estamos indicando que nuestro AVR es un Atmega8, que trabajaremos a 1Mhz y que haremos una aplicación.

Una vez hecho esto, vamos a configurar el puerto B (PORTB) como salida. Quedando como sigue:

Una vez hecho esto elegimos File-> Generate, Save and Exit y pediremos que guarde los tres archivos con el nombre 1.cwp, 1.c y 1.prj respectivamente. Usaremos la carpeta c:\atmega8 claro que esta puede ser la que uno desee, pero para fines de mantener este sitio comprensible siempre usaremos esa carpeta.


Ok ahora en el fondo de la pantalla se genero el siguiente script. Recuerda que el signo // significa comentario y es ignorado por el microcontrolador. Solo se agrega para poder dar un mejor seguimiento al programa.

/*****************************************************
This program was produced by the
CodeWizardAVR V2.03.6 Evaluation
Automatic Program Generator
© Copyright 1998-2008 Pavel Haiduc, HP InfoTech s.r.l.
http://www.hpinfotech.com

Project :
Version :
Date    : 18/05/2009
Author  : Freeware, for evaluation and non-commercial use only
Company :
Comments:


Chip type           : ATmega8
Program type        : Application
Clock frequency     : 1.000000 MHz
Memory model        : Small
External RAM size   : 0
Data Stack size     : 256
*****************************************************/

#include <mega8.h>

// Declare your global variables here

void main(void)
{
// Declare your local variables here

// Input/Output Ports initialization
// Port B initialization
// Func7=Out Func6=Out Func5=Out Func4=Out Func3=Out Func2=Out Func1=Out Func0=Out
// State7=0 State6=0 State5=0 State4=0 State3=0 State2=0 State1=0 State0=0
PORTB=0x00;
DDRB=0xFF;

// Port C initialization
// Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In
// State6=T State5=T State4=T State3=T State2=T State1=T State0=T
PORTC=0x00;
DDRC=0x00;

// Port D initialization
// Func7=In Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In
// State7=T State6=T State5=T State4=T State3=T State2=T State1=T State0=T
PORTD=0x00;
DDRD=0x00;

// Timer/Counter 0 initialization
// Clock source: System Clock
// Clock value: Timer 0 Stopped
TCCR0=0x00;
TCNT0=0x00;

// Timer/Counter 1 initialization
// Clock source: System Clock
// Clock value: Timer 1 Stopped
// Mode: Normal top=FFFFh
// OC1A output: Discon.
// OC1B output: Discon.
// Noise Canceler: Off
// Input Capture on Falling Edge
// Timer 1 Overflow Interrupt: Off
// Input Capture Interrupt: Off
// Compare A Match Interrupt: Off
// Compare B Match Interrupt: Off
TCCR1A=0x00;
TCCR1B=0x00;
TCNT1H=0x00;
TCNT1L=0x00;
ICR1H=0x00;
ICR1L=0x00;
OCR1AH=0x00;
OCR1AL=0x00;
OCR1BH=0x00;
OCR1BL=0x00;

// Timer/Counter 2 initialization
// Clock source: System Clock
// Clock value: Timer 2 Stopped
// Mode: Normal top=FFh
// OC2 output: Disconnected
ASSR=0x00;
TCCR2=0x00;
TCNT2=0x00;
OCR2=0x00;

// External Interrupt(s) initialization
// INT0: Off
// INT1: Off
MCUCR=0x00;

// Timer(s)/Counter(s) Interrupt(s) initialization
TIMSK=0x00;

// Analog Comparator initialization
// Analog Comparator: Off
// Analog Comparator Input Capture by Timer/Counter 1: Off
ACSR=0x80;
SFIOR=0x00;

while (1)
 {
  // Place your code here

 };
}

Vamos a concentrar nuestra atención en la parte que dice #include<mega8.h>. Es en esta zona del programa donde indicaremos las librerias que utilizaremos. Debajo de esa linea vamos a agregar #include<delay.h> que es la librería que nos permite hacer un retraso de tiempo.

Quedando (el fragmento) así:

Data Stack size     : 256
*****************************************************/

#include <mega8.h>
#include <delay.h>

// Declare your global variables here

Despues localizaremos la parte donde el verdadero programa debe escribirse. Es facil encontrarlo, se encuentra al final e incluye el comentario //Place your code here.

while (1)
 {
   // Place your code here

 };
}

Todo lo que se encuentre entre la llave { y la llave }; de esta zona se repetira infinitamente mientras el chip este encendido y no se indique otra cosa. Una vez klocalizado esto escribimos los siguientes comandos:

PORTB.0=1; // Esto pone el bit 0 (pin 14) del puerto B en nivel alto (casi 5v).
delay_ms(200); // Esto produce un retardo de 200 milisegundos.
PORTB.0=0; // Esto pone el bit 0 (pin 14) del puerto B en nivel alto (casi 0v).
delay_ms(200); // Esto produce un retardo de 200 milisegundos.

Quedando el fragmento de la siguiente manera.

while (1)
 {
   // Place your code here
 PORTB.0=1;
 delay_ms(200);
 PORTB.0=0;
 delay_ms(200);
 };
}

De este modo le hemos ordenado al chip que prenda y apage el foco en intervalos de 200ms continuamente.

Ahora vamos a compilar y ensamblar el codigo ejecutable 1.hex. Para eso podemos pulsar Shift +F9 o bien dar click en el siguiente icono:



Si hemos hecho las cosas correctamente, debera aparecer la siguiente ventana:


Si hemos cometido un error nos lo indicara en la parte de abajo de la ventana genereal, los errores mas comunes a esta altura son:

1.- No terminar los comandos con ;
2.- Escribir PORTB en minusculas (portB, PortB, portb, etc)
3.- Escribir la vocal O en lugar del numero 0
4.- Errores ortograficos ejemplos: dilay_ms(200); o PARTB.0=1;

Corrijamos e intentemos compilar de nuevo.

Bien pues solo falta montar nuestro programa. Para ello abriremos la consola de Windows (boton Inicio-> Ejecutar -> cmd):

El logotipo de Windows asi como la marca registrada Windows© y demas imagenes propias de dicho sistema operativo son propiedad de Microsoft© y son usadas para fines meramente didacticos. Si algun representante debidamente identificado de dicha empresa lo solicita seran retiradas de este blog.

Nos colocamos en la carpeta c:\atmega8\Exe que es donde se guardo el ejecutable (1.hex). Despues llamaremos al comando avrdude con las opciones -p m8 que es nuestro avr, -c usbasp que es nuestro programador, -e que indica que borre todo programa anterior, -u par que no use el modo seguro (mas lento), -V para que no verifique si se cargo correctamente (tambien mas lento) y por ultimo -U flash:w:1.hex que significa cargar el progrma 1.hex en la memori flash en modo de escritura.

En pantalla luce así:



Al dar Enter el programa se cargara en el AVR y en segundos el LED empezara a parpadear.

Si no lo hace:
1.- Revisa las conexiones y la polaridad del LED.
2.- Prueba que tu led no este quemado.
3.- Compila y Monta de nuevo.
4.- Intenta empezar todo de nuevo.
5.- Agrega un comentario solicitando ayuda (probablemente necesite una foto de tu protoboard). Incluye tu correo electronico.

Cosas que hacer una vez que logramos que este primer programa/aplicación funcione: (recuerda compilar y montar cada vez que hagas cambios para que estos funcionen)

* Juega con los valores de delay_ms(); para producir pulsos asimetricos.
ejemplo:

PORTB.0=1;
delay_ms(50);
PORTB.0=0;
delay_ms(500);

*Agrega mas lineas de encendido y apagado.
ejemplo:

PORTB.0=1;
delay_ms(50);
PORTB.0=0;
delay_ms(50);
PORTB.0=1;
delay_ms(50);
PORTB.0=0;
delay_ms(200);

* Intenta conectar el led en el bit PORTB.1 (patita 15) y cambia la programación.
Ejemplo:

PORTB.1=1;
delay_ms(200);
PORTB.1=0;
delay_ms(200);

Recuerda que la patita mas larga del led debera ir a la pata en cuestion (en este caso la 15) del avr y la mas corta del led en serie con la resistencia de 1kohm a tierra (gnd) (patita 8 del avr).

Pues bien, esto es todo para esta entrada, de momento hemos conseguido un ne555 muy caro, pero no se preocupen, en la siguiente se empezara a notar un poco mas de provecho jeje. Buena Suerte

Nota: Escribir esto se me hizo eterno jeje. Recuerden que la mayor parte de mis imagenes son originales y estan protegidas por la Ley Federa de Derechos de Autor y su Reglamento. Asi que si desean usarlas en otros sitios deberan mantenerlas sin modificación y mencionar este sitio como fuente. En caso de utilizarse con fines comerciales requeriran una autorización por escrito que podra o no tener un costo.