ESCUELA POLITCNICA NACIONAL

LABORATORIO DE CONTROL CON MICROPROCESADORES

Prctica # 3
1. Tema: Respaldo de alimentacin y de datos
2. Objetivo: Familiarizar al estudiante con el manejo de la
memoria EEPROM de datos y las tcnicas de respaldo de
alimentacin.
3. Trabajo Preparatorio
3.1.
Consultar 2 circuitos que sirvan para realizar respaldo de
alimentacin.

Circuito 1

Circuito 2

3.2.

Consultar la Subrutina (lenguaje ensamblador) para escribir y leer

en la memoria EEPROM (datos) de un microcontrolador.

Para escritura

Para lectura

3.3.

Realizar el circuito completo y el programa de control que permite

contar el nmero de pasajeros en un bus, que funciona de la siguiente
manera:
El sistema debe contar el nmero de personas que han ingresado al bus y
mostrar en displays.
El sistema debe contar el nmero de veces que se ha desconectado la
alimentacin primaria, en cuyo caso deber conmutar a alimentacin
secundaria.
Si el sistema esta alimentado con alimentacin secundaria se debe mostrar
una alarma visual intermitente.
Adicionalmente el sistema debe contar el nmero de veces que ha sido
reseteado el sistema de manera manual.
Al resetear el microcontrolador se debe encerar el contador de pasajeros del
bus y almacenar el dato antes del reset en un contador auxiliar (el cual solo
puede ser visto desde el pc).
En cualquier momento el Administrador del sistema puede saber el nmero
de veces que se ha desconectado la alimentacin primaria, el nmero de
veces que ha sido reseteado de forma manual, revisar el contador del
nmero de personas que han ingresado y encerar cada uno de los
contadores. Los contadores no se deben borrar si el microcontrolador est
sin alimentacin.

Cdigo

/*
* prepa3_ulloa.c
*
* Created: 05/11/2015 19:22:25
* Author: franciscoulloa
*/
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#define F_CPU 8000000UL
void inicio_micro(void);
void barrido (int numero, char n);
void conf_serial(unsigned char baud);
//transmitir y recibir datos
unsigned char Recibe_dato( void );
void Transmite_dato( unsigned char data );
//funciones de EEPROM
void EEPROM_write(unsigned int uiAddress, unsigned char var);
unsigned char EEPROM_read(unsigned int uiAddress);
//VARIABLES
int cont_personas;
int cont_reset;
int cont_desco;
int leer_per;
//variables comunicacin
unsigned char dato;
unsigned char person_tx;
unsigned char reset_tx;
unsigned char desconexion_tx;
char aux;
char displays[10]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F};
int main(void)
{
if(MCUSR &(1<<EXTRF)) //Observo banderas para ver si se reseteo el micro

{
cont_reset=EEPROM_read(9);//lectura del contador de reset
cont_reset++; //incremento de reset
EEPROM_write(9,cont_reset); //guardar en EEPROM el cont_reset
MCUSR &=~(1<<EXTRF); //pongo cero en extrf
}
inicio_micro(); //llamo a subrutina de inicio
conf_serial(51); //subrutina de configuracion serial
while(1)
{
barrido(cont_personas,3);
}

}
void inicio_micro(void)
{
DDRB=DDRC=255; //configuracin de puertos
DDRA=255;
PORTB=PORTC=0;
PORTA=0;
DDRD=0b00000010;
PORTD=~DDRD;
//configuracin de interrupciones
EICRA=0b00001010;
EIMSK=0b00000011;
EIFR=1;
//MODO CAPTURA
TCCR1A=0;
TCCR1B=0b11000011;
TIMSK1=0b00100000;
sei();
}
void conf_serial(unsigned char baud)
{
UBRR0=0;
UCSR0B|=(1<<RXCIE0)|(1<<RXEN0)|(1<<TXEN0);
UCSR0C|=(3<<1);
UBRR0=baud;
sei();
}
ISR(USART0_RX_vect)
{
dato=Recibe_dato(); //se recibe dato
if(dato==1)
{
person_tx=EEPROM_read(5); //se lee dato de EEPROM
Transmite_dato(person_tx); //Transmisin de dato
}
else if(dato==2)
{
reset_tx=EEPROM_read(9);
Transmite_dato(reset_tx);
}
else if(dato==4)
{
desconexion_tx=EEPROM_read(2);
Transmite_dato(desconexion_tx);
}
else if(dato==8)
{
//todos los contadores en cero

EEPROM_write(5,0);
EEPROM_write(9,0);
EEPROM_write(2,0);
cont_personas=0;

else if(dato==0)
{
Transmite_dato(0);
}
}
unsigned char Recibe_dato( void ){ //Funcin para recibir un byte
while(!(UCSR0A&(1<<RXC0)));// espera, mientras no este limpio el buffer
return UDR0; //Retornar dato
}
void Transmite_dato( unsigned char data ) //Funcion para transmitir un byte
{
while(!(UCSR0A&(1<<UDRE0))); //Espero, que este limpio el buffer
UDR0=data;
//transmisin de dato
}
ISR(INT0_vect)
{
leer_per=EEPROM_read(5); //lectura de EEPROM
leer_per++; //incremento de variable
cont_personas++;
EEPROM_write(5,leer_per); //guerdar en EEPROM
}
ISR(TIMER1_CAPT_vect)
{
if(ICR1>1000 && ICR1<1125) //comparo para saber que fuente usa
{
//fuente principal
PORTA=1;
TCNT1=0;
// Encero contador timer1
}
else
{
cont_desco++;
EEPROM_write(2,cont_desco);
PORTA=2;
TCNT1=0;
//contador de fuente
}
}
void EEPROM_write(unsigned int uiAddress, unsigned char ucData)
{
while(EECR & (1<<EEPE));
EEAR=uiAddress;
EEDR=ucData;
EECR|=(1<<EEMPE);
EECR|=(1<<EEPE);
}
unsigned char EEPROM_read(unsigned int uiAddress)
{
while(EECR & (1<<EEPE));
EEAR = uiAddress;
EECR |= (1<<EERE);
return EEDR;
}

void barrido(int numero,char n)

{
int auxiliar;
for (int i=0;i<=n;i++)
{
auxiliar=numero;
auxiliar=numero%10;
numero=numero/10;
PORTC=255;
//apago todo
PORTB=displays[auxiliar];
PORTC=(PORTC&~(1<<i));
_delay_us(100);
}
}

Circuito

Labview

Diagramas de flujo

Bibliografa:
Manual de microcontrolador Atmega 164p.