Documentos de Académico
Documentos de Profesional
Documentos de Cultura
CURSO BÁSICO-INTERMEDIO DE
PROGRAMACIÓN EN C DE LOS
MICROCONTROLADORES ATMEL
dinfante29@hotmail.com
dinfante@itmorelia.edu.mx
Revisión 8.0
Septiembre del 2008
He sido:
• Asesor en más de 70 temas de titulación de licenciatura y 1 de Maestría.
• Sinodal en más de 70 exámenes de titulación de licenciatura y 6 de maestría.
• 17 Artículos publicados en congresos y simposios nacionales de electrónica y
computación.
• 18 Ponencias en congresos y simposios nacionales de electrónica.
• Participación como asesor con proyectos en 19 eventos de creatividad en sus
distintas fases.
• Asistencia en calidad de participante en 15 cursos de robótica,
instrumentación, redes de PLCs, Paneles de Operador, termografía y
microcontroladores COP, HC08, MSP430, AVR.
• Impartición de 12 cursos de microcontroladores PIC, HC08, AVR, DSPs de
Texas Instruments, procesamiento de señales y de PLCs en eventos nacionales
• 7 veces jurado en eventos académicos de electrónica
• Como estudiante participé en los concursos de Ciencias Básicas durante 3
años en sus distintas etapas.
• Obtención de una de las 10 becas nacionales para telecomunicaciones en
CINVESTAV Guadalajara
Experiencia profesional
Desde que cursaba la carrera de ingeniería electrónica a la fecha he usado los siguientes
microprocesadores, microcontroladores y DSPs:
Los COP son muy poco usados en el ambiente industrial, y resultan caros, además de que
no cuentan con novedades en su diseño, los 8051 de Intel están en plena desaparición y los
que hay son únicamente para reemplazo.
Los microcontroladores MSP de Texas Instrumentes son económicos, son potentes y tiene
herramientas gratuitas, sin embargo son dispositivos para uso portátil por lo que su voltaje
es de 3.3 V y son de montaje superficial lo que dificulta el diseño de prototipos.
Los microcontroladores PIC son los peores microcontroladores que existen, son muy lentos
que trabajan a baja velocidad, tiene un set de instrucciones muy pequeño que obliga a
programas muy extensos y lentos, tiene únicamente un work register cuando un procesador
RISC debe tener al menos 16 registros, de todos los microcontroladores que existen en el
mercado son los peores en el desempeño, algunas empresas comenzaron a hacer sus
equipos con estos procesadores y después al detectárseles fallas como bloqueos o
reinicialización por ruido sacaron del mercado sus productos. En países desarrollados no se
usan ya que no tienen aplicación industrial o comercial, únicamente en escuelas de países
Los Microcontroladores AVR de Atmel tiene 4 veces más instrucciones que los PICs, tiene
32 registros de trabajo, el pic sólo 1, el ADC es más potente, el TIMER es mucho más
complejo que el del PIC, y son más económicos. Los AVR de Atmel se usan en teléfonos
celulares, en receptores satelitales, en robótica, etc. Son microcontroladores muy rápidos y
de alto desempeño y son de bajo costo, existen muchos proyectos, tutoriales y herramientas
gratuitas en la red.
Tipos de datos
Nuestras variables pueden ser del siguiente tipo:
unsigned char x,y,temperatura; //Con esto estoy indicando que son 3 variables sin signo y
//que son tipo char por lo que el rango que pueden manejar son desde 0 a 255
unsigned int var1; // Es una variable entera sin signo que llamamos var1
signed char z=20,x=10,m; //z inicia con un valor de 20 decimal, x con 10, m no
la //inicializo a ningún valor
Ejemplos:
x=20; // x es 20 decimal
x=0x14; //x es 14 hexadecimal que convertido a decimal es 20 decimal
x=0b00010100; //x se manejado en binario que es equivalente a 20 decimal
x=024; //x se maneja en octal que es 20 decimal
Las variables deben ser ubicadas en RAM. Solamente se hace declarándolas como
unsigned o signed luego el tipo y finalmente el nombre de las variables;
Que es equivalente a:
Se puede guardar un carácter en flash para ello ponemos el carácter entre comillas simples (
´)
1.4 Arreglos
Ejemplo
flash char arreglo1 [3]={0x0a,0x38,0x23};
flash y const son lo mismo ya que guardan los datos en flash, pero por compatibilidad con
el lenguaje C usaré dentro de este manual la palabra const.
flash char arreglo1 []={0x0a,0x38,0x23}; //Note que no se colocó el tamaño del arreglo
Se puede declarar un arreglo de dos dimensiones que se interpretaría como fila y columna
ejemplo:
Cuando declaramos variables el compilador decidirá donde colocar las variables dentro de
RAM, pero también podemos nosotros decirle en qué dirección colocarla usando
@dirección por ejemplo:
Podemos guardar bits de manera individual y esto se hace usando la palabra bit nombre del
bit y su valor ejemplo
bit var1=1; //La variable Var1 es de un bit y se guarda en un registro del AVR y vale 1
bit var2=0;
bit var3=1;
Se guardan de manera individual esos bits en los registros R2 al R14 del procesador del
AVR. Recuerde que el microcontrolador AVR tiene 32 registros desde R0 hasta R31.
El lenguaje C reconoce instrucciones como if, for, while, etc; pero el lenguaje C no tiene
instrucciones para el manejo de puertos, de timers, del ADC, de interrupciones, etc.
Entonces para poder manejar los periféricos del microcontrolador se usan librerías donde
están declarados esos registros y su ubicación, aunque esto lo veremos después.
Símbolo Operación
+ Suma
- Resta
* Multiplicación
/ División
% División Módulo, y el resultado es el
residuo
Programación en C de los microcontroladores ATMEL Autor: David Infante Sánchez
e-mail: dinfante29@hotmail.com www.comunidadatmel.com
Var1=Var2/12; //Si Var2=40, Var1 será 3;
Var1=Var2%12; //Si Var2=40, Var1=4 que es el residuo. Útil para convertir
// números a BCD
Símbolo Descripción
& And Bit a Bit
| OR bit a Bit
^ Or exclusivo Bit a Bit
<< Corrimiento a la Izquierda
>> Corrimiento a la derecha
~ Complemento a unos
(inversión de bits)
Ejemplos:
Importante. No olvide poner los operadores =, | o el & dos veces en la evaluación del if,
while o do while, ya que un soló = significa asignación y dos veces == significa
comparación, un sólo & significa AND bit a bit y dos veces && significa Y TAMBIÉN a
modo de evaluación. Si lo coloca una sóla vez el programa tendrá resultados inesperados.
Operador Descripción
> Mayor que
>= Mayor o igual que
< Menor que
<= Menor Igual que
== Igual que
!= Distinto de
&& Y también si
|| O si
La estructura if else es: si se cumple el if se hace lo que está abajo del if y sino se cumple se
hace lo que está debajo del else
if (Var1==10)
{
Var1=0;
Var2=20;
x=14;
}
else
{
Var1=++;
x=20;
}
Donde se cumpla la condición rompe las siguientes comparaciones, no evalúa todas, pero si
se cumple hasta abajo habrá evaluado todas las comparaciones.
if (Var1==10)
Var1=0;
else if (Var1==09)
Var1=1;
else if (Var1==08)
Var1=2;
else
Var1=3;
También se puede hacer el programa anterior con varios if, pero aunque se cumpla una
condición sigue comparando las posteriores.
Cuando se tiene una variable que dentro del programa va, digamos, desde 0 hasta 100
decimal, podemos declararla como unsigned char var1, pero si ponemos unsigned int var1,
también funcionará el programa, pero en el último caso estamos apartando dos bytes (int)
cuando solo ocupamos uno sólo, por lo que el programa quedará mas grande y más lento
porque el microcontrolador deberá manipular dos bytes en lugar de uno sólo. Es importante
que vea cuál es el rango de la variable y aparte el tamaño adecuado.
Cuando una variable que ocupa un tamaño grande le apartamos uno más pequeño se puede
crear condiciones que no se cumplen, vea el siguiente ejemplo:
signed char var1; // var1 es signada con lo que rango va de -128 a 127
var1++;
If (var1==200)
var2=0;
La condición del if nunca se cumplirá porque var1 es tipo char unsigned, esto es que su
rango es de -128 a 127 decimal y nunca llega a ser mayor a 127.
Si se declara como tipo unsigned char o tipo int si habrá un punto en el que la condición es
válida.
El while evalúa lo que hay entre los paréntesis y mientras se cumpla ejecuta lo que está
debajo del while.
A diferencia del while, esta instrucción ejecuta por lo menos una vez lo que está abajo del
do, después evalúa el while y si es válido ejecuta nuevamente lo que está abajo del do.
do
{
Portb++ ; //Si porta=0 y Var1=0, se incrementa en uno el portb
}
While ((porta==0x01) &&(Var1==0))
Este programa realiza por lo menos un incremento del portb, sin importar la condición, si la
condición del while se cumple continua en el ciclo incrementando el portb, hasta que no sea
válida la condición en el while.
for (i=0;i<=10000,i++)
{
var1++; //i tendría que ser declarado como int para que cumpla con el rango
}
for (i=100;i<=0;i--); //Decrementa i desde 100 hasta 0 y cuando llega a 0 sale del //for,
note el “;” donde se colocó y es porque no hay //instrucciones
que ejecutar abajo del for
for(;;)
{
Se ejecuta infinitamente las instrucciones aquí colocadas
}
while(1)
{
Se ejecuta infinitamente las instrucciones aquí colocadas
}
Se puede terminar un ciclo for, while y do while mediante el break sin necesidad de
terminar las iteraciones o de que se vuelva falsa la condición.
for (i=0;i<=10000,i++)
{
var1++;
if (var2==0) //Si var2=0 se rompe ciclo, quedando el i en donde se haya cumplido el var2
break;
}
var3=i; //Si var2 nunca es verdadera en el ciclo, var3=10000
//Si Var2 se hizo verdadera en i=25 se rompe ciclo y var3=25
Primero recordemos que cada bit tiene un peso dentro del byte y este peso es una potencia
de 2. Por ejemplo si la variable es de 8 bits el peso de esos bits es: 128 64 32 16 8 4 2 1, el
bit menos significativo tiene un peso de 1 y el más significativo de 128.
Si escribimos:
variable|=0x08
Es equivalente a: variable=variable|0x08
B7 b6 b5 b4 b3 b2 b1 b0
Variable 1 0 0 0 0 1 1 1
0x08 0 0 0 0 1 0 0 0
Resultado 1 0 0 0 1 1 1 1
De la Or
Si deseara prender el bit0 y el bit6 al mismo tiempo sin afectar los otros bits tendría que
escribir:
b7 b6 b5 b4 b3 b2 b1 b0
Variable 1 1 0 0 1 0 1 1
~0x01 1 1 1 1 1 1 1 0
Resultado 1 1 0 0 1 0 1 0
De la AND
Vemos en el ejemplo anterior que apaga el b0 de la variable y los demás bits no los
modifica.
Suponga que deseara probar si el bit 0 y el bit 2 de la variable var están en 0, entonces
deberá usar el siguiente esquema:
Vemos que el resultado no se guarda en ningún lado, sino solamente se prueba si están en 0
esos bits.
Suponga que desea probar si el bit 1 de la variable var está en 1 deberá escribir:
if ((var &(0x02)==0x02) //Se prueba que el bit 1 esté en 1 por eso se compara con 0x02
Para probar los bits 0,1,2,3,4,5,6 y 7 se usan sus pesos que son 0x01, 0x02, 0x04, 0x08,
0x10, 0x20,0x40 y 0x80.
Pero es más fácil si en vez de usar sus pesos usamos definiciones, que es lo que usaremos
en este curso, ejemplo:
De la manera anterior estamos diciendo que la etiqueta elbit0 =0x01, que el bit1=0x02, etc.
Aunque podemos usar cualquier etiqueta, sólo hay que tener cuidado de no usar las
palabras reservadas para instrucciones, es por ello que no usé la palabra bit que está
reservada, y por eso utilice una etiqueta que llamé elbit1, etc.
Hasta este momento no hemos usado ningún registro del microcontrolador, por ejemplo
uno de estos registros es el del puerto A del microcontrolador, vamos a suponer que ya
configuró el puerto como salida, entonces si escribe: porta=0x0f; está indicando que los 4
primeros pines del microcontrolador los ponga en 1 lógico, es decir, 5 Volts y los 4 más
significativos los ponga en 0 lógico, que es 0 Volts.
Pero si deseará afectar un sólo pin, sin modificar a los otros puede utilizar lo que se vio en
los subtemas anteriores del 1.12.1 y 1.12.2, pero el compilador que usaremos (codevision)
permite modificar de una forma más fácil los bits de los registros y se hace de la siguiente
manera:
Nombre_del_registro.x=valor
Por ejemplo si deseamos poner a 1 el pin 6 del puerto A, sin modificar los otros debemos
escribir:
porta.6=1;
Con lo anterior estamos poniendo a 1 el pin 6 del puerto sin modificar los otros pines, y
esta manera de manejar bits de manera individual lo podemos usar con los primeros 32
registros, cualquier registro mapeado arriba de la dirección 0x1F se hace con las técnicas
mostradas en los subtemas 1.12 y 1.12.1.
La instrucción if (pina.0==0); Prueba que el pin0 del porta esté en 0 (si es que lo
configuramos como entrada).
Una función es un conjunto de instrucciones que puede ser llamada en el momento que se
desee. Las funciones son útiles por dos razones:
1. Permiten estructurar el programa, por ejemplo se puede utilizar una función para
inicializar variables, otra función para inicializar el hardware, otra función para
inicializar el timer, etc. Así podemos visualizar de una forma más rápida el
funcionamiento del programa.
La parte anterior sólo es la definición de las funciones que utilizará el programa. El llamado
de las funciones dentro del programa se hace así:
ejemplofuncion1 ();
ejemplofuncion2 (variable1,variable2);
variablex=ejemplofuncion3 ();
En la función 4 se retorna un valor tipo char y se envía un parámetro tipo int, y su llamado
se haría así:
variabley=elemplofuncion4(variable1);
Programación en C de los microcontroladores ATMEL Autor: David Infante Sánchez
e-mail: dinfante29@hotmail.com www.comunidadatmel.com
Hasta este punto se ha visto cómo se declaran las funciones y cómo se llaman, falta
únicamente cómo se estructura la función.
void ejemplofuncion1(void)
{
//Código de usuario
}
La función lleva void al inicio y entre paréntesis porque esa función no recibe parámetros
ni retorna ningún parámetro o valor.
Aquí lleva void al inicio indicando que no retorna parámetro y entre paréntesis se coloca a
y b que indica que son los parámetros que se reciben, cuando se hizo el llamado se hizo así:
ejemplofuncion2 (variable1,variable2); entonces la función envía dos parámetros variable1
y variable2, que recibe la función en a y b, entonces a=variable1 y b=variable2; Se
asignan según su posición.
int ejemplofuncion3(void)
{
//Código de usuario
return variable
}
char ejemplofuncion4(int a)
{
//Código de usuario
return variable
}
Programación en C de los microcontroladores ATMEL Autor: David Infante Sánchez
e-mail: dinfante29@hotmail.com www.comunidadatmel.com
Aquí se indica que la función regresará un char y que recibe un parámetro int en a, ya que
en el llamado de la función se escribió: variabley=elemplofuncion4(variable1);
Hemos visto sólo el envío de parámetros que son variables, pero pueden enviarse también
arreglos, o punteros.
Estructura de la función
void ejemplofuncion1(void)
{
//Código de usuario
}
void ejemplofuncion2(char a, char b)
{
//Código de usuario
}
int ejemplofuncion3(void)
{
//Código de usuario
return variable
}
char ejemplofuncion4(int a)
{
//Código de usuario
return variable
}
• En los ejemplos que coloqué envíe como parámetros variables, pero también pueden
ser constantes. ejemplofuncion2(char a, 200); En este ejemplo se envía el valor de
la variable a y se envía la constante 200.
• El retorno del valor de la función que puse como ejemplo fue el retorno de una
variable, pero también puede retornarse una constante como return 100;
Importante. Los PICs y los HC08 sólo tienen un sólo registro de trabajo, el PIC le llama
Work Register y el HC08 le llama acumulador y recomiendan que no use variables
locales en los programas, ya que las variables locales se guardan en la pila a través de
instrucciones de PUSH y PULL, haciendo el manejo de variables locales muy lentas, en
cambio los AVR tienen 32 registros de trabajo, y es ahí donde se guardan las variables
locales haciéndose más rápido el manejo de este tipo de variables. En los programas
que haga con estos microcontroladores AVR trate de usar siempre variables
locales en lugar de variables globales, por las siguientes razones: el programa se ejecuta
más rápido, es más compacto y no usa la RAM. El manejo de variables locales es de 4 a
8 veces más rápido el manejo en los AVR que en los PICs o que en los HC08.
2.1 Introducción
Los modos de direccionamiento del AVR es más amplio, pudiendo inclusive manejar
direccionamientos con post y pre incrementos, lo cual eficienta el manejo de tablas y
programas.
El microcontrolador tiene un oscilador interno que trabaja a 8 MHz que viene dividido por
8 de fábrica, así que trabaja a 1MHz interno, pero puede colocar un cristal externo en las
terminales 7 y 8, y en ese caso tendría que seleccionar que esos pines no sean entradas o
salidas de datos sino que sean configurados como terminales donde se colocará el cristal
externo que puede ser de hasta 20 MHz, pero para nuestras aplicaciones y para reducir
costos, diseño del PCB, reducción de componentes, etc, se trabajará con el oscilador interno
de fábrica cuya frecuencia interna es de 1 MHz, aunque puede operar hasta 8 Mhz y si se
desea una velocidad más alta deberá colocar un cristal externo que puede ser hasta de 20
MHz. Debe tener en cuenta que a mayor velocidad se incrementa el consumo de energía. Si
se coloca el cristal de 20MHz puede trabajar a 20 MHz internos, recuerde que otros
microcontroladores como los PICs, los HC08 de motorola, etc. la velocidad interna es el del
cristal dividido entre 4. Así que de entrada tenemos que el ATMEL es 4 veces más rápido
que cualquier otro microcontrolador trabajando con el mismo cristal.
Deberá instalar estos tres programas (primero descomprima el CVAVRE que abrirá un
SET-UP)
En el tema 1.7 se explicó que el lenguaje C no tiene instrucciones para manejar timers,
ADC, puertos de entrada-salida, etc, es decir, los periféricos del microcontrolador, entonces
para poder manejarlos se usan las librerías donde se incluyen las declaraciones de estos
registros y su manejo. Es precisamente el programa Code Vision AVR quien tiene esas
librerías. El primer programa instala el AVR Studio que es el simulador, el segundo
(WinAVR-20071221 ) instala el programador y el tercer SET-UP instala el compilador.
Importante. Use sólo estas versiones, ya que están probadas, versiones más nuevas o viejas
pueden tener problemas con el programador, compilador y/o simulador. En el caso de que
tenga probados versiones más nuevas colocaré el link para su descarga en mi página
www.comunidadatmel.com
Programación en C de los microcontroladores ATMEL Autor: David Infante Sánchez
e-mail: dinfante29@hotmail.com www.comunidadatmel.com
2.3 Puertos de entrada y salida
Por ejemplo con el registro DDRB especificamos la dirección del pin correspondiente, un 0
es para indicar que el pin es de entrada y un 1 de salida. Por ejemplo si se quiere que los
primeros cuatro pines del puerto A sean entrada y los 4 más significativos sean de salida se
programa así: DDRB=0xf0; aunque recordemos que esta configuración la realiza el
codevision.
Importante. Cuando son configurados como entradas las terminales de un circuito integrado
deben colocarse resistencias de pull-up para evitar que queden flotadas (sin conectarse),
porque de quedarse flotadas el C.I. consume mayor corriente y el estado del pin oscilará
vea el primer caso de la figura 4, lo correcto es poner una resistencia de pull-up (segundo
caso), si el interruptor no se presiona leerá el pin un 1 lógico por la resistencia conectada a
5V, si se presiona el interruptor leerá un 0 lógico, pero este microcontrolador permite al
diseñador ahorrar hardware ya que tiene resistencias de pull-up internas que pueden ser
habilitadas.
Cualquier otro microcontrolador de otros fabricante sólo tienen un sólo registro para leer o
escribir al puerto, pero en elcaso de ATMEL se tienen dos dando la ventaja de que de esa
forma el acceso a puertos es más rápido cuando se va usar como entrada un determinado
pin y posteriormente se va usar como salida, es otra ventaja que tenemos con este tipo de
arquitectura.
Importante. Limitantes Físicas de los pines: Máximo pueden dar 40 mA por pin, pero el
Circuito Integrado máximo debe manejar 200mA, es decir que sumando la corriente de los
pines y la que consume el microcontrolador no deben exceder más de 200mA.
Importante. El pin 1, que es la terminal PC6 tiene a la vez la función de RESET, esta
terminal no la podemos utilizar como pin de entrada/salida, ya que a través de ella se hace
la programación del microcontrolador. En otras palabras NO HAGA PROGRAMAS
DONDE UTILICE ESA TERMINAL, YA QUE NO LA PODEMOS USAR. Es posible
deshabilitarle la función de reset y que quede como pin de entrada/salida digital, pero ya no
podremos programar al microcontrolador nuevamente.
/*****************************************************
This program was produced by the
CodeWizardAVR V1.25.7a Evaluation
Automatic Program Generator
© Copyright 1998-2007 Pavel Haiduc, HP InfoTech s.r.l.
http://www.hpinfotech.com
Project :
Version :
Date : 13/09/2008
Author : Freeware, for evaluation and non-commercial use only
Company :
Comments:
#include <mega48.h>
void main(void)
{
// Declare your local variables here
// 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=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
PORTD=0x00;
DDRD=0xFF;
// Timer/Counter 0 initialization
// 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
// OC2A output: Disconnected
// OC2B output: Disconnected
ASSR=0x00;
TCCR2A=0x00;
TCCR2B=0x00;
TCNT2=0x00;
OCR2A=0x00;
OCR2B=0x00;
};
}
Project :
Version :
Date : 14/09/2008
Author : Freeware, for evaluation and non-commercial use only
Company :
Comments:
#include <mega48.h>
#include <delay.h> //Esta libreria hay que colocarla para poder utilizar las funciones de retardo
void main(void)
{
// Declare your local variables here
// 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;
// Timer/Counter 0 initialization
// Clock source: System Clock
// Clock value: Timer 0 Stopped
// Mode: Normal top=FFh
// OC0A output: Disconnected
// OC0B output: Disconnected
TCCR0A=0x00;
TCCR0B=0x00;
TCNT0=0x00;
OCR0A=0x00;
OCR0B=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
// OC2A output: Disconnected
// OC2B output: Disconnected
ASSR=0x00;
TCCR2A=0x00;
TCCR2B=0x00;
TCNT2=0x00;
OCR2A=0x00;
OCR2B=0x00;
while (1)
{
PORTB++; // Incrementa en una unidad el valor del Puerto B
delay_ms(1000); //Se hace un retardo de 1 segundo
// Place your code here
};
}
Para este programa deberemos configurar todo el Puerto B como salida, y los pines C0, C1,
C2 y C3 como entradas con sus resistencias de pull-up, ya que cuando no se cierre el
interruptor quedará a 1 lógico el pin por la resistencia de pull-up interna, y cuando se cierre
el interruptor leerá 0 el pin.
En los cursos que he dado normalmente los participantes dicen que una forma de hacer el
programa es con if para probar todas las combinaciones y quizás es la forma que se le ha
ocurrido para hacerlo. Es decir algo de esta forma:
Etc...
La forma descrita no es incorrecta, pero tiene los siguientes puntos en contra: ocupa
demasiadas instrucciones ya que se deben probar todas las posibilidades que es que el
puerto C valga 0 hasta que valga 9, ocupando mucha memoria y haciendo lento el
programa.
PORTB=tabla7segmentos[PINC];
De la manera anterior logramos que el programa quede más compacto, y mucho más rápido
que usando instrucciones de if.
Project :
Version :
Date : 14/09/2008
Author : Freeware, for evaluation and non-commercial use only
Company :
Comments:
#include <mega48.h>
unsigned char variable;
const char tabla7segmentos [10]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7c,0x07,0x7f,0x6f};
void main(void)
{
// Declare your local variables here
// Port C initialization
// Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In
// State6=T State5=T State4=T State3=P State2=P State1=P State0=P
PORTC=0x0F;
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
// Mode: Normal top=FFh
// OC0A output: Disconnected
// OC0B output: Disconnected
TCCR0A=0x00;
TCCR0B=0x00;
TCNT0=0x00;
OCR0A=0x00;
OCR0B=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
// OC2A output: Disconnected
// OC2B output: Disconnected
ASSR=0x00;
TCCR2A=0x00;
TCCR2B=0x00;
TCNT2=0x00;
OCR2A=0x00;
OCR2B=0x00;
while (1)
{
variable=PINC&0x0f; //Enmascaramos los 4 bits menos significativos
//del puerto A ya que los demás no interesan.
if (variable<10)
PORTB=tabla7segmentos[variable];
Project :
Version :
Date : 14/09/2008
Author : Freeware, for evaluation and non-commercial use only
Company :
Comments:
#include <mega48.h>
#define boton PINC.0
const char tabla7segmentos [10]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7c,0x07,0x7f,0x6f};
void main(void)
{
// Declare your local variables here
// 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=P
PORTC=0x01;
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
// Mode: Normal top=FFh
// OC0A output: Disconnected
// OC0B output: Disconnected
TCCR0A=0x00;
TCCR0B=0x00;
TCNT0=0x00;
OCR0A=0x00;
OCR0B=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;
while (1)
{
if (boton==0)
var1++;
if (var1==10)
var1=0;
PORTB=tabla7segmentos [var1];
};
}
El registro del Puerto C es PINC y el bit que deseamos accesar es el 0, entonces PINC.0 es
accesar el bit 0 del PINC, que es la terminal C0
Cuando el botón se presiona, es decir que vale 0, ya que cuando no está presionado lee 1
lógico debido a la resistencia de pull-up, incrementa en 1 la variable var1
if (boton==0)
var1++;
Se utiliza una variable que se nombró var1, aunque puede ser cualquier nombre. Como se
está utilizando la tabla que convierte a 7segmentos el número, sólo se pueden desplegar
números de 0 hasta 9, así que si la var1 es igual a 10 se regresa a 0, porque números
superiores al 10 desplegarían basura ya que no existen en la tabla accesando localidades no
inicializadas.
if (var1==10)
var1=0;
Cuando programe el microcontrolador y arme el circuito verá que cuando presione el botón
se incrementará muy rápidamente el display y la razón de eso es porque el programa
detecta el nivel de 0, es decir, cuando valga 0 el pin se incrementará el valor a mostrar en el
display; aunque nosotros presionemos y soltemos el botón muy rápido el programa leerá en
es pequeño lapso de tiempo miles de veces un nivel lógico de 0.
Si deseáramos que se modificara el valor sólo una vez cuando se presione el botón deberá
hacerse que funcione por flancos, es decir cuando cambie el pin de 1 a 0. Vea el diagrama
de la figura 2.8.
Para poder trabajar por flancos es necesario tener el valor del botón anterior y del botón
actual, por ejemplo en 1 y 2 el botón pasado vale 1 y el botón actual vale 1, con eso
sabemos que no ha sido presionado el botón; ahora en el punto 2 y 3 el punto 2 es botón
pasado y el 3 es botón actual y ambos valen 1, así que no ha sido presionado el botón; en el
punto 3 y 4 el botón pasado vale 1 y el botón actual vale 0 eso significa que se presionó el
botón y que hubo un flanco de bajada de 1 a 0 ese cambio nos sirve, por ejemplo, para
incrementar la variable. Después el punto 4 vale 0 y el punto 5 vale 0 que son botón pasado
y actual respectivamente eso significa que no hay cambio de flanco, cuando esté en los
puntos 7 y 8 tanto botón pasado como actual valen 0 por lo que no hay cambio, en el punto
8 y 9 el botón pasado y actual valen 0 y 1 ese es un cambio de flanco de subida; en el punto
9 y 10 los valores de botón pasado y actual valen 1 por lo que no hay cambio de flanco.
La inicialización se hará igual que el programa anterior, vea el video_p5 donde está cómo
se inicializa el microcontrolador.
/*****************************************************
This program was produced by the
CodeWizardAVR V1.25.7a Evaluation
Automatic Program Generator
© Copyright 1998-2007 Pavel Haiduc, HP InfoTech s.r.l.
http://www.hpinfotech.com
#include <mega48.h>
void main(void)
{
// Declare your local variables here
// 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=P
PORTC=0x01;
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
// Mode: Normal top=FFh
// OC0A output: Disconnected
// OC0B output: Disconnected
TCCR0A=0x00;
TCCR0B=0x00;
TCNT0=0x00;
OCR0A=0x00;
OCR0B=0x00;
// Timer/Counter 1 initialization
// Timer/Counter 2 initialization
// Clock source: System Clock
// Clock value: Timer 2 Stopped
// Mode: Normal top=FFh
// OC2A output: Disconnected
// OC2B output: Disconnected
ASSR=0x00;
TCCR2A=0x00;
TCCR2B=0x00;
TCNT2=0x00;
OCR2A=0x00;
OCR2B=0x00;
while (1)
{
// Place your code here
if (boton==0)
botona=0;
else
botona=1;
};
}
if (boton==0)
botona=0;
else
botona=1;
botonp=botona;
Esto es porque el valor del botona (botón actual) se convierte en el valor del botonp (botón
pasado), cuando regrese a la parte de arriba del programa se leerá el valor del botona (boton
actual) entonces de esta manera tenemos el valor actual (botona), así como el valor pasado
inmediato (botonp). Cuando llegue a la parte de abajo el botona (botón actual) será el valor
pasado, porque después se leerá el valor del botón actual, y así consecutivamente.
Ya que se tiene el valor actual y pasado del botón se tienen las instrucciones de y con el
primer if se prueba si hubo cambio de flanco de 1 a 0 ya que se prueba si botonp==1 y que
botona==0, con estas dos pruebas sabemos que hubo cambio de flanco de 1 a 0, y si lo
hubo se incrementa la variable, entonces solo cuando se presiona el botón se incrementará
la variable, sin importar cuánto dure en 0, ya que funciona el programa por flanco de bajada
y no de subida.
vea el siguiente diagrama donde se aprecia que cuando se presiona un interruptor, éste se
abre y cierra varias veces por que el cerrado no es instántaneo; de la misma forma cuando
se abre el interruptor se generan rebotes y éstos se pueden generar durante periodos de 40
mS.
Si hiciéramos un programa que cada vez que se presiona una tecla incrementara un valor y
no quitáramos los rebotes y se generará los rebotes del diagrama anterior veríamos que se
incrementaría la variable 5 veces en lugar de 1 vez debido a que los rebotes generan varios
cambios de nivel de 1 a 0 y de 0 a 1 tanto al presionar el interruptor como al soltarlo.
Project :
Version :
Date : 14/09/2008
Author : Freeware, for evaluation and non-commercial use only
Company :
Comments:
#include <mega48.h>
#include <delay.h>
// Declare your global variables here
#define boton PINC.0
bit botonp;
bit botona;
unsigned char var;
const char tabla7segmentos [10]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7c,0x07,0x7f,0x6f};
void main(void)
{
// Declare your local variables here
// 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=P
PORTC=0x01;
// 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
// Mode: Normal top=FFh
// OC0A output: Disconnected
// OC0B output: Disconnected
TCCR0A=0x00;
TCCR0B=0x00;
TCNT0=0x00;
OCR0A=0x00;
OCR0B=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
// OC2A output: Disconnected
// OC2B output: Disconnected
ASSR=0x00;
TCCR2A=0x00;
TCCR2B=0x00;
TCNT2=0x00;
OCR2A=0x00;
OCR2B=0x00;
while (1)
{
if (boton==0)
botona=0;
else
botona=1;
PORTB=tabla7segmentos [var];
botonp=botona;
};
}
La diferencia con respecto al programa 5 es que en las instrucciones donde detecta el flanco
de 1 a 0 se colocó la instrucción de delay_ms(40); esa instrucción dura 40 mS y ahí se
queda ese tiempo el programa, entonces cuando vuelva a checar el valor del botón ya los
rebotes ya no existen porque ya pasaron 40mS
Teclado Matricial
Si deseara manejar digamos 16 botones y lo hiciera poniendo un botón en cada pin gastaría
16 pines del microcontrolador, en vez de esto se puede hacer un teclado matricial, el cual
ahorra pines. Por ejemplo una matriz de 4*4 puede manejar 16 teclas, una matriz de 5*5
puede manejar 25 teclas. En el primer caso se ocuparían 4 pines de salida y 4 de entrada, en
el segundo se ocupan 5 pines de salida y 5 de entrada. Aquí vemos el ahorro, para 16 teclas
se ocupan 8 pines en lugar de 16 pines si se hiciera el teclado conectando cada pin a un
botón, y el ahorro es mayor cuando se ocupan 25 teclas, ya que se ocupan 10 pines en total
en lugar de 25 pines si se conecta cada botón con cada pin.
Para probar la segunda columna se envía en los pines de salida “101” y si no se presiona
ninguna tecla se leerá en la entrada “111”, pero si se presiona el boton 5 se leerá “101”, si
se presiona el botón 6 se leerá “110”. Si se presiona los botones B1 a B3 o B7 a B9 se
leerán en los 3 pines de entrada “111” debido a que se está probando la segunda columna.
Las resistencias de 100 ohms que se ponen a la salida de los 3 pines es para prevenir cortos
circuitos y dañar el puerto del microcontrolador, suponga que no se pusiera esas
resistencias y que se envía el dato “101” y se presiona al mismo tiempo el botón B1 y B4
vemos que en B1 hay 1 (5 volts) y en B4 hay 0 (0 Volts) entonces se generaría un corto
circuito. Pero al poner esa resistencia de 100 ohms no sucede el corto ya que se limita la
corriente por ese resistor.
Para probar la primera columna (botones B1 a B3) se envía en los pines de salida “011”
Para probar la segunda columna (botones B4 a B6) se envía en los pines de salida “101”
Para probar la tercera columna (botones B7 a B9) se envía en los pines de salida “110”
Si se envió el código “011” y se lee en los pines de entrada “011” entonces se presionó el
botón B1.
Si se envió el código “011” y se lee en los pines de entrada “101” entonces se presionó el
botón B2.
Si se envió el código “011” y se lee en los pines de entrada “110” entonces se presionó el
botón B3.
Si se envió el código “101” y se lee en los pines de entrada “011” entonces se presionó el
botón B4.
Si se envió el código “101” y se lee en los pines de entrada “101” entonces se presionó el
botón B5.
Si se envió el código “101” y se lee en los pines de entrada “110” entonces se presionó el
botón B6.
Si se envió el código “110” y se lee en los pines de entrada “011” entonces se presionó el
botón B7.
Si se envió el código “110” y se lee en los pines de entrada “101” entonces se presionó el
botón B8.
Si se envió el código “110” y se lee en los pines de entrada “110” entonces se presionó el
botón B9.
Si cuando se envían los códigos “011”, “101” y “110” no se presiona ningún botón se leerá
en los pines de entrada “111”
En el teclado matricial a los pines de entrada hay que activarles la resistencia de pull-up
para que cuando no se presione ningún botón se lea 1 lógico en cada pin y no quede flotado
Las resistencias de 100 ohms a la salida de los pines que son los que envían el código son
para proteger contra corto circuitos, por ejemplo si se enviara en la primera columna un 0 y
en la segunda un 1 y se presionará el botón 1 y 4 habría un corto ya que en una línea hay 5
volts y en el otro 0, así que al tener la resistencia de 100 Ohms la corriente se ve limitada y
no sucede nada al presionar dos teclas al mismo tiempo.
Como son botones los que están conmutando a tierra hay que quitarle los rebotes, tal y
como lo hicimos en el programa 6. Aunque en este programa que se hará no se quitarán los
rebotes.
Este ejemplo de 3*3 se puede usar como base para diseñar cualquier teclado matricial 5*5,
6*6, etc.
/*****************************************************
This program was produced by the
CodeWizardAVR V1.25.7a Evaluation
Automatic Program Generator
© Copyright 1998-2007 Pavel Haiduc, HP InfoTech s.r.l.
http://www.hpinfotech.com
#include <mega48.h>
void main(void)
{
// Declare your local variables here
// Port C initialization
// Func6=In Func5=In Func4=In Func3=In Func2=Out Func1=Out Func0=Out
// State6=T State5=P State4=P State3=P State2=1 State1=1 State0=1
PORTC=0x3F;
DDRC=0x07;
// 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
// Mode: Normal top=FFh
// OC0A output: Disconnected
// OC0B output: Disconnected
TCCR0A=0x00;
TCCR0B=0x00;
TCNT0=0x00;
OCR0A=0x00;
OCR0B=0x00;
// Timer/Counter 1 initialization
// Clock source: System Clock
// Clock value: Timer 1 Stopped
// Mode: Normal top=FFFFh
// Timer/Counter 2 initialization
// Clock source: System Clock
// Clock value: Timer 2 Stopped
// Mode: Normal top=FFh
// OC2A output: Disconnected
// OC2B output: Disconnected
ASSR=0x00;
TCCR2A=0x00;
TCCR2B=0x00;
TCNT2=0x00;
OCR2A=0x00;
OCR2B=0x00;
while (1)
{
//C0 A C2 son de salida y son para
//Probar las 3 columnas
//Se prueba la primera columna se envía 110
PORTC=0b00111110;
//C3, C4 y C5 son las entradas del teclado
//Por eso se enmascaran con 00111000
lectura=PINC&0b00111000;
if (lectura==0b00110000)
tecla=7;
if (lectura==0b00101000)
tecla=8;
if (lectura==0b00011000)
tecla=9;
PORTB=tabla7segmentos [tecla];
};
}
1. PORTB=0b11001111;
2. PORTB=0b11001100;
3. PORTB=0b11000011;
En los 3 casos al puerto B le escribiría 1100 en la parte alta, la parta baja aparentemente no
se modificaría porque están configurados como entradas, pero sucede lo siguiente:
Cuando un pin es configurado como entrada y se le escribe a través del PORTX un 1 en ese
bit le activará la resistencia de pull-up.
Cuando un pin es configurado como entrada y se le escribe a través del PORTX un 0 en ese
bit le desactivará la resistencia de pull-up.
Entonces en el caso 1: le está activando la resistencia de pull-up interna a los 4 bits menos
significativos. En el caso 2 le está desactivando la resistencia de pull-up a los 2 bits menos
significativos y le está activando la resistencia de pull-up interna a los 2 pines siguientes.
Por ello en el programa cuando se deseaba que C2,C1 y C0 fuera 110 se escribió
PORTC=0b00111110; para no desactivar las resistencia de pull-up en los pines C3,C4 y C5.
Entonces recuerde que si un puerto lo tiene configurado unos pines como salida y otros
como entrada, y además a los de entrada a unos pines les activó la resistencia de pull-up y a
otro no, deberá escribir a través del PORTX un 1 en la posición de los pines que les activó
la resistencia de pull-up, ya que si se le pone 0 la va deshabilitar, ahora en el caso de que
esos pines sean configurados como entrada y no les activó la resistencia de pull-up deberá
escribir en PORTX un 0 en los pines que no están activadas las resistencia de pull-up, ya
que de escribirles un 1 las activará.
Ejemplo: B3, B2, B1 y B0 como salidas, B4 y B5 como entradas con resistencia de pull-up
interna y B6 y B7 también de entrada pero sin resistencia interna de pull-up activada.
Y desea escribir de B3 a B0 “1101” deberá usar PORTB así:
Ejemplos:
Project :
Version :
Date : 14/09/2008
Author : Freeware, for evaluation and non-commercial use only
Company :
Comments:
#include <mega48.h>
#include <delay.h>
bit botonp;
bit botona;
unsigned char var; //Ahora la variable se guarda en eeprom
const char tabla7segmentos [10]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7c,0x07,0x7f,0x6f};
eeprom char datoaguardar;
void checa_boton (void); // Aquí se declaran todas las funciones que se van usar
void main(void)
{
// Declare your local variables here
// 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=P State0=P
PORTC=0x03;
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 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
// OC2A output: Disconnected
// OC2B output: Disconnected
ASSR=0x00;
TCCR2A=0x00;
TCCR2B=0x00;
TCNT2=0x00;
OCR2A=0x00;
OCR2B=0x00;
if (datoaguardar>10)
datoaguardar=0;
var=datoaguardar;
while (1)
{
checa_boton();
PORTB=tabla7segmentos [var];
botonp=botona;
}
void checa_boton (void); // Aquí se declaran todas las funciones que se van usar
if (datoaguardar>10)
La razón de ello es que si el datoaguardar que es una variable eeprom tiene un valor inicial
mayor a 10 la hacemos 0, y esto sucedería una sola vez, ya que cuando se guarde un dato el
dato estará entre 0 y 9. Pero un microcontrolador nuevo tiene en la memoria eeprom puros
0xff en todas las localidades, entonces la primera vez hará que ese dato de 0xff se haga 0.
Importante. Si dentro de un programa utiliza una variable eeprom como una variable RAM
puede suceder que dañe esa localidad de memoria eeprom, ya que una eeprom tiene una
vida útil de 100,000 ciclos de escritura y lectura, pero si usa esa variable eeprom como una
variable RAM puede suceder que en cuestión de segundos sucedan esos 100,000 ciclos de
escritura y lectura porque un programa en el microcontrolador ejecuta el código miles de
veces en un segundo, entonces al reescribir esa variable en el programa miles de veces en
un segundo se va a cabar la vida útil de la localidad de memoria. En el programa vemos que
la eeprom sólo se escribe cuando se presiona un botón.
Un ADC convierte una señal analógica a un dato digital de manera lineal, para ello es
necesario identificar tres aspectos importantes y éstos son: el voltaje de referencia (Vref), el
número de bits y si es unipolar o bipolar el ADC.
Por ejemplo si Vref=5 y el vin que va a medir es de 2.5 dará como salida 512 según la
ecuación 2.1; si ahora el vin es de 1 volt la conversión que dará será de 204.
conversión=(Vin*256)/Vref ......................................................................................ec(2.2)
En la figura 2.13 vemos que en las terminales 22 y 20 dicen GND y AVCC, estás son las
términales de tierra y alimentación del periférico del convertidor de analógico a digital.
Normalmente los microcontroladores de otros fabricantes el ADC se alimenta con el mismo
voltaje del microcontrolador, pero en los de ATMEL son alimentados por separado para
disminuir los efectos del ruido. Aunque en nuestro caso y para los programas que vamos a
realizar el AVCC y VCC los conectaremos juntos y los GND también serán conectados
juntos. Pero recuerde que si en su aplicación requiere de una conversión más exacta puede
alimentar el microcontrolador y el periférico del ADC por separado. Solamente tenga en
El vref que se encuentra en las ecuaciones 2.1 y 2.2 puede ser de tres tipos:
1. Vref=Vcc del microcontrolador, en este caso Aref no se conecta (pin 21), vea la
figura 2.14 el circuito de en medio.
2. Vref=Aref (pin 21). En este caso se tiene una referencia externa y puede ser
cualquier voltaje, siempre y cuando no sea superior al Vcc del microcontrolador.
Este se ejemplifica en el primer diagrama de la figura 2.14.
3. Vref=1.1 Volts interno, se debe conectar un capacitor externo de 0.1uf del tipo gota
de tantalo y se muestra en el tercer circuito de la figura 2.14.
Figura 2.14 conexión de las terminales del ADC según la selección del Vref
En las ecuaciones 2.1 y 2.2 se tiene un término llamado Vin que es el voltaje de entrada, es
decir, el voltaje que será convertido a una combinación digital, según su proporción con
Vref. Este Vin se aplica en los canales del ADC que se numeran desde ADC0 hasta ADC5
(pines del 23 al 28), entonces tenemos que esos pines tienen varias funciones ya sean como
pines de entrada o salida, o como entradas del ADC. Entonces si el pin se configura como
entrada del ADC ya no puede funcionar como entrada/salida digital, esto es que las
funciones son excluyentes.
Importante El Avcc no puede ser mayor al Vcc, por eso conéctelos juntos
Importante No aplique Vin mayores a Aref o a Vcc para evitar daños en el pin del ADC.
Programa 9. Haga una conversión en 8 bits sobre el canal 0 del ADC y muestre el
resultado en leds que se conectarán en el Puerto B. Configure como Vref el AVcc del
microcontrolador.
Con el codewizard se hace la configuración del ADC a través de simples clicks, lo único
que debemos hacer en el programa es leer el valor de la conversión del canal que estemos
usando a través de la siguiente función:
variable=read_adc (número_de_canal);
variable=read_adc(3);
El nombre que le di a la variable donde se guardará el resultado fue variable, pero puede
darle cualquier nombre.
Importante. La función read_adc() sólo puede utilizarse si dentro del codevision se habilitó
el ADC, ya que si lo usa en cualquiera de los otros programas que se han realizado y que no
han unicializado el ADC marcará error.
Project :
Version :
Date : 15/09/2008
Author : Freeware, for evaluation and non-commercial use only
Company :
Comments:
#include <mega48.h>
#include <delay.h>
unsigned char x;
void main(void)
{
// Declare your local variables here
// Port C initialization
// Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In
// 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
// Mode: Normal top=FFh
// OC0A output: Disconnected
// OC0B output: Disconnected
TCCR0A=0x00;
TCCR0B=0x00;
TCNT0=0x00;
OCR0A=0x00;
OCR0B=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
// OC2A output: Disconnected
// OC2B output: Disconnected
ASSR=0x00;
TCCR2A=0x00;
TCCR2B=0x00;
TCNT2=0x00;
OCR2A=0x00;
OCR2B=0x00;
// ADC initialization
// ADC Clock frequency: 500,000 kHz
// ADC Voltage Reference: AVCC pin
// ADC Auto Trigger Source: None
// Only the 8 most significant bits of
// the AD conversion result are used
// Digital input buffers on ADC0: On, ADC1: On, ADC2: On, ADC3: On
// ADC4: On, ADC5: On
DIDR0=0x00;
ADMUX=ADC_VREF_TYPE & 0xff;
ADCSRA=0x81;
while (1)
{
x=read_adc(0); //Se hace la conversión sobre el canal 0 del ADC
PORTB=x; //Se despliega en el puerto B el valor digital
// Place your code here
};
}
El programa 9 hace una conversión sobre el canal 0, pero el resultado que da, no es en
voltaje sino en un código binario. Si Vin=0 volts la conversión da 0b0000,0000; si vin=2.5
volts la conversión da 0b1000,0000 (128 decimal); si es 5 Volts=0b1111,1111 (255
decimal). Es decir nos convierte a una proporción binaria que luego debemos interpretar,
pero ese resultado lo podemos convertir a voltaje a través de una regla de 3.
Si Vin=5 da como resultado 0xff, es decir 255, Pero deseamos que muestre un código
nuevo que sea 50 (que sería 5.0 Volts). Entonces se resuleve así:
Note, si Vin=5 Volts, la conversión dará 0b1111,1111 que es 255, que sustituyendo en la ec
1.3 da:
Pero ese código nuevo debemos separarlo en digitos para poderlo desplegar en el display de
7 segmentos o en una LCD. Esto se realiza en el programa 10.
Programa 10. Haga una conversión de 8 bits en el canal 1 y muestre el resultado del
volatje en dos displays que se conectarán al Puerto B. El Vref=Vcc=5 volts. El pin Co
controlará el display de unidades y el C1 el de decenas. Se usará el canal 2 del ADC2
por donde se aplicará un voltaje variable de entre 0 y 5 volts, el cual será desplegado
en los dos displays desde 0.0 hasta 5.0
Usando la ecuación 2.3 tenemos que la conversión máxima =255, el código que deseamos
con esa conversión máxima=50 para mostrar 5.0 Volts.
x=read_adc(1);
codigonuevo=x*50/255;
Importante. x es tipo char, se multiplica por 50 pero ese resultado temporal ocupa más de 8
bits. Para evitar esto se hace el casting, es decir, se le dice al compilador el resultado de
x*50/255 da como resultado un char, ya que no sobrepasa a 255, pero lo obliga a que en las
operaciones intermedias (sobre todo en la multiplicación) se guarde el resultado en algún
lugar ya que ocupa más de 8 bits. El casting se hace codigonuevo=(char)x*50/255
Ejemplo 1.
Suponga que tiene x=y+w+z; y todas son tipo char, en ese caso no existe problema ya que
si y+w+z da como resultado un número menor a 255 se podrá guardar en x.
Ejemplo 2.
x es tipo int; y,w y z son tipo char. Y se escribe x=y+w+z; Pero se sabe que y+w+z van a
dar mas de 255, y que caben en x ya que esta es tipo int. Pero lo de la derecha y+w+z está
declarado como char, entonces cuando la suma dé más de 255 ¿dónde quedan esas
operaciones? Entonces aquí si va existir un problema porque x=int y y+w+z son tipo char
cuya suma da mas de 8 bits y que cabe en x, pero en las sumas parciales las variables son
char y estas no pueden guardar mas de 8 bits, entonces hay que hacer un casting, obligando
al compilador a decirle todas son tipo char, pero el resultado es tipo int para que lo guarde
temporalmente en algún lugar para después asignarlo a x.
x=(int) y+w+z; //Esto ya da un resultado correcto
x=y+w+z //Daría un resultado erróneo ya que y+w+z da mas de 8 bits y estas
variables no pueden manejar más de 8 bits
Importante. Podemos evitar hacer cálculos de las operaciones intermedias para ver si
hacemos o no el casting, y esto dejarlo al compilador. Esta opción se selecciona en el
codevision en project-configure-C Compiler y finalmente dando click en promote char to
int como se muestra en la figura 2.15. Con la selección de la casilla “promote char to int” le
estamos indicando al compilador que cuando ocupe hacer que la variable la haga más
grande lo haga él mismo para evitarnos problemas de casting.
Con las dos instrucciones anteriores ya tenemos representado en voltaje la conversión, pero
debemos separarlo en dos digitos, esto es calcularle la cantidad de decenas y las unidades.
decenas=codigonuevo/10;
unidades=codigonuevo%10;
Recuerde que % es la operación módulo y que da como resultado el residuo. Suponga que
el códigonuevo=48, es decir 4.8 Volts
Entonces decenas=48/10=4
Y unidades=48%10=8 (que es el residuo)
Configuración: PORTB de salidas para conectar los displays. C0 y C1 salidas que serán
usados para manejar los dos transistores: el que controla el display de unidades, y el que
controla el display de decenas. El pin C2 como entrada que es también el canal 2 del ADC
(ADC2).
Project :
Version :
Date : 05/10/2008
Author : Freeware, for evaluation and non-commercial use only
Company :
Comments:
#include <mega48.h>
#include <delay.h>
void despliega(void); //Se va a utilizar una función que se llama despliega sin parámetros
void main(void)
{
// Declare your local variables here
// Port C initialization
// Func6=In Func5=In Func4=In Func3=In Func2=In Func1=Out Func0=Out
// State6=T State5=T State4=T State3=T State2=T State1=0 State0=0
PORTC=0x00;
DDRC=0x03;
// 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
// Mode: Normal top=FFh
// OC0A output: Disconnected
// OC0B output: Disconnected
TCCR0A=0x00;
TCCR0B=0x00;
TCNT0=0x00;
OCR0A=0x00;
OCR0B=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/Counter 2 initialization
// Clock source: System Clock
// Clock value: Timer 2 Stopped
// Mode: Normal top=FFh
// OC2A output: Disconnected
// OC2B output: Disconnected
ASSR=0x00;
TCCR2A=0x00;
TCCR2B=0x00;
TCNT2=0x00;
OCR2A=0x00;
OCR2B=0x00;
// ADC initialization
// ADC Clock frequency: 500,000 kHz
// ADC Voltage Reference: AVCC pin
// ADC Auto Trigger Source: None
// Only the 8 most significant bits of
// the AD conversion result are used
// Digital input buffers on ADC0: On, ADC1: On, ADC2: On, ADC3: On
// ADC4: On, ADC5: On
DIDR0=0x00;
ADMUX=ADC_VREF_TYPE & 0xff;
ADCSRA=0x81;
while (1)
{
var=read_adc(2); //Se lee el valor del Canal 2 del ADC (PIN C2)
codigonuevo=50*255/var; //Convierte el valor del ADC a un código nuevo en voltaje
decenas=codigonuevo/10; //Calcula las decenas
unidades=codigonuevo%10; //Calcula las unidades
};
}
void despliega(void)
{
PORTB=tabla7segmentos [unidades];
tru=1; //Prende display de unidades
delay_ms(4); //Deja prendido display de unidades 4mS
tru=0; //Apaga display de unidades
PORTB=tabla7segmentos[decenas];
trd=1; //Prende display de decenas
delay_ms(4); //Deja prendido display de decenas 4mS
trd=0; //Apaga display de decenas
}
Se inicializó el valor de la tabla que nos dibuja los números en los 7 segmentos del display
y declaramos una función que nombré despliega y que utilizaré en el programa y que no
envía, ni recibe parámetros.
Recuerde que la función para leer el valor de conversión del ADC es read_adc(canal); que
es la primera línea y dicho valor de la conversión se guarda en una variable llamada var que
es de 8 bits, ya que la conversión que escojimos a la hora de inicializar el ADC fue de 8
bits.
Si el voltaje que se le aplica al canal 2 es de 2.5 Volts, el valor de la conversión será de 127,
pero nosotros queremos representarlo en voltaje, así que con la fórmula de 50*255/var y
sustituyendo var=127 nos dará como resultado 25, que ahora si podemos representar como
2.5 Volts. Pero el 25 hay que convertirlo a dos digitos para desplegarlos en el display, por
lo que 25/10=2, y 25%10=5 (recuerde que % es la funcióm módulo hace la división pero el
Programación en C de los microcontroladores ATMEL Autor: David Infante Sánchez
e-mail: dinfante29@hotmail.com www.comunidadatmel.com
resultado es el residuo) y esos valores se guardan en decenas y unidades para desplegarlos
en la función despliega(); Todo lo anterior es el siguiente código agregado al programa:
var=read_adc(2); //Se lee el valor del Canal 2 del ADC (PIN C2)
codigonuevo=50*255/var; //Convierte el valor del ADC a un código nuevo en voltaje
decenas=codigonuevo/10; //Calcula las decenas
unidades=codigonuevo%10; //Calcula las unidades
Posteriormente se manda llamar una función para desplegar los dos digitos del voltaje:
void despliega(void)
{
PORTB=tabla7segmentos [unidades];
tru=1; //Prende display de unidades
delay_ms(4); //Deja prendido display de unidades 4mS
tru=0; //Apaga display de unidades
PORTB=tabla7segmentos[decenas];
trd=1; //Prende display de decenas
delay_ms(4); //Deja prendido display de decenas 4mS
trd=0; //Apaga display de decenas
}
Las pantallas de cristal líquido LCD alfanuméricas sin importar el fabricante se basan en un
circuito integrado de Hitachi que es el HD44780, esto significa que cualquier pantalla que
se utilice funciona de la misma manera, por lo que la programación de la pantalla es
El asistente que tiene el codevision solicita que se le indique de cuántos caracteres es cada
línea de la LCD. Así mismo se indica en el mismo asistente cómo conectar la LCD y a que
pines. Las pantallas se pueden conectar en un bus de datos de 8 bits o de 4, el asistente lo
coloca en un bus de 4 bits para ahorrar pines. El asistente del codevision genera todo el
código necesario para inicializar la LCD y el programador sólo debe preocuparse por
manejar las siguientes funciones:
_lcd_write_data();
_lcd_write_byte(direccion,dato);
Lo primero que debe hacerse es ubicar la posición del cursor, es decirle en cuál fila y en
cual columna. Por ejemplo las LCDs de 2x16 son 2 filas por 16 caracteres. Entonces su se
desea escribir en la segunda fi
_lcd_ready();
Hasta este punto ya sabe como manejar puertos, desplegar datos en displays de 7 segmentos
y LCds, guardar datos en eeprom y además sabe utilizar el ADC. Con este conocimiento