PROGRAMACIÓN EN LENGUAJE C

El WinAvr dispone de un compilador compatible con el ANSI C, adicionalmente dispone de librerías

específicas para el manejo de los diferentes recursos.

Se presenta una plantilla genérica para un programa escrito para el compilador C de WinAVR

//*****************************************************************************
//
// Titulo :
// Autor :
// Fecha : 2007-03-29
// Version : 1.0
// Target MCU : Atmel AVR series
//
//
//*****************************************************************************

// -------------------------------------------------------------------------------------------------------------
//************************* Inclusión de Librerías *******************************
// -------------------------------------------------------------------------------------------------------------

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <inttypes.h>
#include "lcd_lib.h"

// -------------------------------------------------------------------------------------------------------------
//*********************** Definiciones de Variables Globales *******************
// -------------------------------------------------------------------------------------------------------------

// -------------------------------------------------------------------------------------------------------------
// ************************* Definiciones y Macros *****************************
// -------------------------------------------------------------------------------------------------------------

// -------------------------------------------------------------------------------------------------------------
// ************************ Rutinas de Interrupción ****************************
// -------------------------------------------------------------------------------------------------------------
// -------------------------------------------------------------------------------------------------------------
// ************************* Declaración de Funciones **************************
// -------------------------------------------------------------------------------------------------------------

// -------------------------------------------------------------------------------------------------------------
// **************************** Cuerpo del Programa ****************************
// -------------------------------------------------------------------------------------------------------------

int main( void )

{

// -------------------------------------------------------------------------------------------------------------
// ********************** DECLARACIÓN DE VARIABLES **********************
// -------------------------------------------------------------------------------------------------------------

// -------------------------------------------------------------------------------------------------------------
// ************** CONFIGURACIÓN DE LOS PUERTOS DE E/S *******************
// -------------------------------------------------------------------------------------------------------------

// -------------------------------------------------------------------------------------------------------------
// ********************* INICIALIZACIÓN DE REGISTROS **********************
// -------------------------------------------------------------------------------------------------------------

// -------------------------------------------------------------------------------------------------------------
// ****************** HABILITACIÓN DE INTERRUPCIONES ********************
// -------------------------------------------------------------------------------------------------------------

// -------------------------------------------------------------------------------------------------------------
// ************** INICIALIZACIÓN DE FUNCIONES Y VARIABLES ***************
// -------------------------------------------------------------------------------------------------------------
// -------------------------------------------------------------------------------------------------------------
// ******************** CICLO PRINCIPAL DE EJECUCIÓN **********************
// -------------------------------------------------------------------------------------------------------------

while (1)
{

} //Fin while

return 0;
}

// -------------------------------------------------------------------------------------------------------------
//********************* DEFINICIÓN DE FUNCIONES **************************
// -------------------------------------------------------------------------------------------------------------

// __________________________________________________________________________

WinAVR dispone de una serie de librerías que pueden incluirse dentro del programa de la cual se
dispone la respectiva documentación, algunas son del estándar C y otras propias del WinAVR.

Como ejemplo

• <alloca.h>: Allocate space in the stack

• <assert.h>: Diagnostics
• <ctype.h>: Character Operations
• <errno.h>: System Errors
• <inttypes.h>: Integer Type conversions
• <math.h>: Mathematics
• <setjmp.h>: Non-local goto
• <stdint.h>: Standard Integer Types
• <stdio.h>: Standard IO facilities
• <stdlib.h>: General utilities
• <string.h>: Strings
• <avr/boot.h>: Bootloader Support Utilities
• <avr/eeprom.h>: EEPROM handling
• <avr/fuse.h>: Fuse Support
• <avr/interrupt.h>: Interrupts
• <avr/io.h>: AVR device-specific IO definitions
• <avr/lock.h>: Lockbit Support
• <avr/pgmspace.h>: Program Space Utilities
• <avr/power.h>: Power Reduction Management
• <avr/sfr_defs.h>: Special function registers
• <avr/sleep.h>: Power Management and Sleep Modes
• <avr/version.h>: avr-libc version macros
• <avr/wdt.h>: Watchdog timer handling

Variables Globales:
Las variables comunes, sólo son accesibles desde la función donde se encuentra definida, si se requiere
que la variable sea accesible desde cualquier parte del programa, es necesario declararla como global.
Para esto simplemente se define antes de la función main().

Ej.

Volatile int var_1, var_2;

Es aconsejable aunque no obligatorio definir las variables globales como volactiles para indicarle al
compilador que no sobreescriba sobre esta posición de memoria.

Definiciones y Macros:
Mediante ciertas directivas se puede asignar a algún símbolo definido por el programador una
determinada expresión.

Ejemplos:

#define s1 2

#define larger( x, y) ( (x)>(y) ? (x) : (y))

#define _BV(bit) (1 << (bit))

#define set_bit(value, bit) (value=((value) | _BV(bit)))

Rutinas de Interrupción:
Son funciones cuyo cuerpo definen lo que se debe ejecutar en el momento que se presente una
determinada interrupción.
Ej.

ISR(TIMER0_OVF_vect)
{

PORTA=PORTA ^ 0x02;

No es necesario hacer un salto explícito a esta función, ni ejecutar alguna instrucción de retorno.

El nombre de los diferentes vectores de interrupción se definen en la librería <avr/io.h>.

/* External Interrupt Request 0 */

INT0_vect

/* External Interrupt Request 1 */

INT1_vect

/* External Interrupt Request 2 */

INT2_vect

/* Timer/Counter0 Overflow */
TIMER0_OVF_vect

/* Timer/Counter0 Compare Match */

TIMER0_COMP_vect

/* Timer/Counter1 Overflow */
TIMER1_OVF_vect

/* Timer/Counter1 Capture Event */

TIMER1_CAPT_vect

/* Timer/Counter1 Compare Match A */

TIMER1_COMPA_vect

/* Timer/Counter1 Compare Match B */

TIMER1_COMPB_vect

/* Timer/Counter2 Overflow */
TIMER2_OVF_vect

/* Timer/Counter2 Compare Match */

TIMER2_COMP_vect
/* Serial Transfer Complete */
SPI_STC_vect

/* USART, Rx Complete */
USART_RXC_vect

/* USART Data Register Empty */

USART_UDRE_vect

/* USART, Tx Complete */
USART_TXC_vect

/* ADC Conversion Complete */

ADC_vect

/* EEPROM Ready */
EE_RDY_vect

/* Analog Comparator */
ANA_COMP_vect

/* 2-wire Serial Interface */

TWI_vect

/* Store Program Memory Ready */

SPM_RDY_vect

Declaración de Funciones:
En este campo debe colocarse la declaración de las funciones a emplear con el prototipo de la función.

Ej.

int mi_funcion(int var1, int var2, float var3);

Cuerpo del Programa:

El cuerpo del programa siempre empieza con la función main() y desde donde el programa empieza
su ejecución.
Declaración de Variables:
Las variables que se definan aquí tienen un ámbito local, no son accesibles desde las funciones.

Configuración de los puertos:

// configura PORTA como salida
PORTA=0;
DDRA = 0xFF;

// configura PORTB como salida

PORTB=0;
DDRB = 0xFF;

// configura PORTC como entrada

PORTC=0;
DDRC = 0x00;

// configura PORTD as entrada

PORTD=0;
DDRD = 0x00;

Inicialización de Registros:
Se establecen los valores de los registros de propósito específico de acuerdo con las configuraciones de
los diferentes recursos.

TCNT1=0xA2B7;

En el archivo cabecera de cada dispositivo se tienen asignados los nombres de los registros.

#define TCNT1 _SFR_IO16(0x2C)

#define TCNT1L _SFR_IO8(0x2C)

#define TCNT1H _SFR_IO8(0x2D)

Habilitación de Interrupciones:
Habilitación de los diferentes bits de interrupción
Ej.

TIMSK=(1<<TOIE0);

sei(); //Habilitación del bit de interrupción global.

Inicialización de funciones y variables

Se debe establecer el estado inicial de las distintas variables y ejecutar las funciones de inicialización
requeridas.

Ej.

LCDinit();

INTRODUCCIÓN AL LENGUAJE C
PARA EL COMPILADOR WINAVR

Tipos de datos básicos:

char

Define variables de 8 bits, empleado especialmente para representación de caracteres.

Enteros: El Ansi C implementa los tipos int y long int, para datos enteros de 16 y 32 bits.

Int (-32768 a 32767)

Unsigned int (0 a 65535)

La librería #include <inttypes.h> implementa otros tipos adicionales:

Int8_t uint8_t
Int16_t uint16_t
Int32_t uint32_t
Int64_t uint64_t

float y double son punto flotante de 32 bits.

Operadores
Operador condicional

expresson1 ? expression2 : expression3

Si expresión1 es verdadera entonces se usa la expresion2, de lo contrario la expresión3.

(x)>(y) ? (x) : (y)

Ejercicios

1. Evaluar las siguientes expresiones:

(a) 5 / 2 + 20 % 6
(b) 4 * 6 / 2 - 15 / 2
(c) 5 * 15 / 2 / (4 - 2)
(d) 8 = = 16 || 7 != 4 && 4 < 1
(e) (4 * 3 < 6 || 3 > 5 - 2) && 3 + 2 < 12

2. Escriba la línea de código en C que corresponda con las siguientes sentencias:

(a) Si el residuo de A dividido B es diferente de 0 y A es mayor o igual que B o B es menor de 100

(b) Y= (AB+(C+D)’)((AB)’+C’)

Estructuras de Control
If - Else
if (expression1)
{
-------;
..-------;
} else if (expression2)
{
--------;
--------;
} else if (expression3)
{
---------;
---------;
}else
{
---------;
---------;
}
Ejemplo:

If (opcion= = 1)
{
Y=A+B;
}else if (opcion= =2)
{
Y=A-B;
} else if (opcion= =3)
{
Y= A*B;
}else
{
Y=A/B;
}

Cuando se tiene una sóla sentecia entre un para de llaves, no es obligación colocar éstas.

If (opcion= = 1)
Y=A+B;
else if (opcion= =2)
Y=A-B;
else if (opcion= =3)
Y= A*B;
else
Y=A/B;

Switch

switch (expression)
{
case constant expression1:
-----------;
-----------;
Break;
case constant expression2:
-----------;
-----------;
Break;
default constant expression2:
-----------;
-----------;
Break;
}
Ejemplo:

switch (opcion)
{

case 1:
Y=A+B;
Break;
case 2:
Y=A-B;
Break;
case 3:
Y=A*B;
Break;
default 3:
Y=A/B;
Break;
}

While

while(expression)
{
---------;
---------;
}

do - While

do
{
------------;
..------------;
} while(expression);

Ejemplo;

while ( i < 128)

{
PORTB = 2*i;
i++;
}
Cual sería el resultado obtenido en cada grupo de instrucciones:

(a) (b)

x=100; x=100;
y=0; y=0;

while ( x < 50) do

{ {
y= 2*x; y= 2*x;
x++; x++;
} } while ( x < 50);

y= ¿? y= ¿?

For

for(expresson1; expression2; expresson3)

{
--------------;
--------------;
}

for(i=0;i<=10;i++)
{
Var=2*i-1;
}

Break y Continue

Estas instrucciones permiten interrumpir una instrucción cíclica. En el caso de la instrucción break,
ésta hace que el bucle más interno que la contenga finalice inmediatamente sin tener en cuenta la
condición. La instrucción continue por su parte, finaliza la iteración actual sin salir del ciclo.

Ejemplo:
 for (i=0; i<100;i++)
{
if(i==10)
continue;

sprintf(s_num,"%d\r",i); // Pasa al string s_num el valor numérico

LCDclr();
LCDGotoXY(0,0);
lcd_puts(s_num,16);
_delay_ms(500);
}

En este caso no se visualiza el valor 10 sino que es saltado.

for (i=0; i<100;i++)

{
if(i==10)
break;

sprintf(s_num,"%d\r",i); // Pasa al string s_num el valor numérico

LCDclr();
LCDGotoXY(0,0);
lcd_puts(s_num,16);
_delay_ms(500);
}

En este caso sólo se visualizan los números del 0 al 9 y termina el ciclo.

PUERTOS DE E/S

Cada Puerto tiene asociado tres registros

DDRx
Para configurar la dirección del puerto.
1 configura como salida
0 Configura como entrada

PORTx
Se emplea para enviar información por el puerto.
En caso que un determinado pin se configure como entrada, y por medio del registro PORTx se
coloque en 1, se habilita la correspondiente resistencia de pull-up.
Se recomienda que los pines que no se utilicen se les habiliten esta resistencia.

PINx
Lee el estado del puerto x

Ej.

DDRB = 0x1F;
DDRB = (1 << DDB0) | (1 << DDB1) | (1 << DDB2) | (1 << DDB3) | (1 << DDB4);

PORTB = 0x04;
PORTB = PORTB | 0x04;
PORTB |= (1<<PB2); Equivalente a la instrucción anterior.
PORTB |= (1<<PB4) | (1<<PB5); Pone los pines 4 y 5 en alto sin alterar los demás.

PORTB &= ~( (1<<PB4) | (1<<PB5) ); Pone los pines 4 y 5 en 0 sin alterar los demás.

Formas de examinar un pin.

if ( PINC & (1<<PINC1) ) { Será verdadero si el pin 1 está en alto.

/* action */
}

if ( !(PINB & (1<<PINB2)) ) { Será verdadero si el pin 1 está en bajo.

/* action */
}

Para simplificar la escritura pueden definirse ciertas macros

#define _BV( bit ) (1 << (bit))

#define E0 ((variable) & _BV(0)) Test sobre el bit 0

#define set_E0 (variable | = _BV(0))
#define clr_E0 (variable &= ~_BV(0))
 INICIALIZACIÓN DE REGISTROS PARA LOS DIFERENTES RECURSOS

Timer 0 como temporizador

TCCR0=(1<<CS02)|(1<<CS00); //Escala 1024

TCNT0=T0_INI; //Inicializa el temporizador

Timer 0 como contador

TCCR0=(1<<CS02)|(1<<CS01)|(1<<CS00); //Contador por flanco de subida

Timer 0 como comparador

OCR0=128;
TCCR0=(1<<WGM01)|(1<<COM00)|(1<<CS01);
//Salida cambia de estado

Timer 0 como PWM

OCR0=128;
TCCR0=(1<<WGM00)|(1<<COM01)|(1<<CS01);

Timer 1 como temporizador

TCCR1B=(1<<CS11)|(1<<CS10); //Escala 64
TCNT1=T1_INI; //Inicializa el temporizador

Timer 1 como contador

TCCR1B=(1<<CS12)|(1<<CS11)|(1<<CS10); //Contador por flanco de subida

Timer 1 como comparador

OCR1A=256;
TCCR1A=(1<<COM1A0); //Salida cambia de estado
TCCR1B=(1<<WGM12)|(1<<CS11); //Escala 8 cambio cada 256us (OCR1A)
 Timer 1 como PWM fase correcta de 10 bits

OCR1A=256;
TCCR1A=(1<<WGM11)|(1<<WGM10)|(1<<COM1A1)|(1<<COM1B1);

TCCR1B=(1<<CS11); //Escala 8 periodo 2048 ciclos con 8M = 2048us

Timer 2 como temporizador

TCCR2=(1<<CS22)|(1<<CS21)|(1<<CS20); //Escala 1024

TCNT2=T2_INI; //Inicializa el temporizador

Timer 2 como comparador

OCR2=128;
TCCR2=(1<<WGM21)|(1<<COM20)|(1<<CS21); //Salida cambia de estado

Timer 2 como PWM

OCR2=128;
TCCR2=(1<<WGM20)|(1<<COM21)|(1<<CS21); //Salida cambia de estado

Timer 2 como contador con oscilador externo

TCCR2=(1<<CS22)|(1<<CS20);
ASSR=(1<<AS2);
 EJEMPLO DE INICIALIZACIÓN DE INTERRUPCIONES

Desbordamiento del TMR0

ISR(TIMER0_OVF_vect)
{
TCNT0=T0_INI;

frac++;
if(frac>=10)
{
segundos++;
frac=0;
PORTA=PORTA ^(1<<2);
}
}

TIMSK= (1<<TOIE0); //Habilita interrupción por desbordamiento TMR0

Desbordamiento del TMR1

ISR(TIMER1_OVF_vect)
{
TCNT1=T1_INI;

frac++;
if(frac>=10)
{
segundos++;
frac=0;
PORTA=PORTA ^(1<<2);
}
}

TIMSK= (1<<TOIE1); //Habilita interrupción por desbordamiento TMR1

 Desbordamiento del TMR2

ISR(TIMER2_OVF_vect)
{
TCNT2=T2_INI;

frac++;
if(frac>=10)
{
segundos++;
frac=0;
PORTA=PORTA ^(1<<2);
}
}

TIMSK= (1<<TOIE2); //Habilita interrupción por desbordamiento TMR2