Main.c //1o PASSO - CABEÇALHO · C:\Users\Leandro\Documents\Projeto Relógio Digital\Firmware\Main.c #pragma config LVP = OFF //Low-Voltage Programming (gravação sem necessidade

$Page 1: Main.c //1o PASSO - CABEÇALHO · C:\Users\Leandro\Documents\Projeto Relógio Digital\Firmware\Main.c #pragma config LVP = OFF //Low-Voltage Programming (gravação sem necessidade$
C:\Users\Leandro\Documents\Projeto Relógio Digital\Firmware\Main.c

//1o PASSO - CABEÇALHO//{/************************************************************************** PROGRAMA: Relógio Digital

DESENVOLVIDO POR: Prof. Leandro Poloni Dantas VERSÃO: 1.0

DATA: 18/02/2014 SITE: oprofessorleandro.wordpress.com

REVISÕES:

**************************************************************************///}

//2o PASSO - DIRETIVAS AO PRÉ-PROCESSADOR (SEM POSIÇÃO ESPECÍFICA)//{//*************************************************************************//Definição do tipo do kit utilizado, incluir no arquivo principal do projeto//#define McMaster //Se for o kit da Mosaico#define SENAI //Se for o kit do SENAI//#define SIMULACAO //Quando definido indica uso do programa no simulador ISIS do Proteus#define RTC //Quando não definido facilita a simulação#define PWM //Será usado para economia de energia//#define DEPURA //Quando não definido facilita a depuração//*************************************************************************//}

//3o PASSO - ARQUIVOS DE BIBLIOTECAS //{

1


//*************************************************************************//##### DEFINIÇÃO PIC#include <p18F4550.h> //Definições de registradores (PADRAO MICROCHIP)//##### INCLUDES DAS FUNÇÕES DE PERIFÉRICOS DO PIC#include <pwm.h> //PWM library functions#include <adc.h> //ADC library functions#include <timers.h> //Timer library functions#include <delays.h> //Delay library functions#include <i2c.h> //I2C library functions#include <stdlib.h> //Library functions#include <usart.h> //USART library functions//#include "LCD.c" //Biblioteca de funções para o LCD#include "RTC-DS1307.c"//#include "EEPROM-AT24C32-64.c"//*************************************************************************//}

//4o PASSO - DIRETIVAS DE CONFIGURACAO//{//*************************************************************************//##### Configurações para gravação//#pragma config FOSC = HS //Tipo de oscilador usado - High Speed - freq. >= 4 MHz#pragma config FOSC = INTOSCIO_EC //Oscilador interno, pino RA6 configurado como I/O, EC usado pelo USB#pragma config CPUDIV = OSC1_PLL2 //Divide a freq. do clock - Divisão por 1#pragma config WDT = OFF //Watch Dog Timer - Desabilitado#pragma config WDTPS = 128 //WDTPostscale - 128 x 4 ms (temporização interna) = 512 ms até reset por WDT

2


#pragma config LVP = OFF //Low-Voltage Programming (gravação sem necessidade de alta tensão no MCLR) - desabilitado#pragma config PWRT = ON //Power-up Timer (tempo de espera após a estabilização da energia para ligar o uC (65,5 ms)- habilitado #pragma config BOR = OFF //Brown-out Reset (reset por nível de tensão) - desbilitado por hardware e software#pragma config BORV = 0 //Brown-out Rest Voltage - 4,59 V#pragma config PBADEN = OFF //RB0..3 como entradas analógicas no POR (Power-on Reset) - força como entradas digitais#pragma config DEBUG = OFF //In-Circuit Debugger (pinos BB6 e RB7) - desabilitado#pragma config PLLDIV = 1 //Oscilador de entrada (com PLL habilitado) - 4 MHz sem prescale#pragma config USBDIV = 1 //Oscilador para o USB - origem oscilador primário de 48 MHz#pragma config FCMEN = OFF //Fail-Safe Clock Monitor - desabilitado o monitoramento do sinal de clock#pragma config IESO = OFF //Mudança de oscilador externo para interno em caso de falha - desabilitado#pragma config VREGEN = OFF //Regulador interno de 3,3 V para USB - desabilitado#pragma config MCLRE = ON //RE3 como MCLR - habilitado#pragma config LPT1OSC = OFF //Oscilador Low-Power no Timer1 (32k Hz) - modo de alto consumo (menos sensível a ruído)#pragma config CCP2MX = ON //Multiplexação do pino do módulo CCP2 (Capture/Compare/PWM 2)- RC1 utilizado no CCP2#pragma config STVREN = OFF //Stack Full/Underflow Reset - desabilita o reset#pragma config ICPRT = OFF //Porta dedicada à programação/debugação

3


In-Circuit - desabilitado//*************************************************************************//}

//5o PASSO - DEFINIÇÃO E INICIALIZAÇÃO DE VARIÁVEIS GLOBAIS//{//*************************************************************************

unsigned char dado[20]; //Variável para leitura do RTCunsigned char rel_e_al[20]; //Variável para leitura de hora e minutounsigned char bip; //Define quantidade de bip do alarmeunsigned char bip_hora; //Sinaliza bip de hora certaunsigned char bip_en; //Habilita bip de hora certa

//*************************************************************************//}

//6o PASSO - DEFINIÇÃO DE CONSTANTES INTERNAS//{//*************************************************************************

//RTC - Leitura e gravação de RTC DS1307#define EndRTCw 0b11010000 //ultimo bit 0=Write#define EndRTCr 0b11010001 //ultimo bit 1=Read#define EndEEPROMw 0b10100000 //último bit 0=Write#define EndEEPROMr 0b10100001 //último bit 1=Read#define Relogio 1#define Alarme 0#define N_bips 5

//*************************************************************************//}

4


//7o PASSO - FLAGS UTILIZADAS NO SOFTWARE//{//*************************************************************************//*************************************************************************//}

//8o PASSO - IDENTIFICAÇÃO DE PINOS DE ENTRADA E SAIDA (PORTS)//{//*************************************************************************//##### ENTRADAS#define HORA PORTCbits.RC4#define MINUTO PORTCbits.RC5#define REL_AL PORTCbits.RC6

//##### SAÍDAS#define H1 PORTAbits.RA0#define H2 PORTAbits.RA1#define H3 PORTAbits.RA2#define H4 PORTAbits.RA3#define H5 PORTAbits.RA4#define H6 PORTAbits.RA5#define BUZZER PORTAbits.RA6

#define SDA PORTBbits.RB0#define SCL PORTBbits.RB1#define H7 PORTBbits.RB2#define H8 PORTBbits.RB3#define H9 PORTBbits.RB4#define H10 PORTBbits.RB5

5


#define H11 PORTBbits.RB6#define H12 PORTBbits.RB7

#define M1 PORTCbits.RC0#define AM_PM PORTCbits.RC1#define PWM_HORA PORTCbits.RC2#define M2 PORTCbits.RC7

#define M3 PORTDbits.RD0#define M4 PORTDbits.RD1#define M5 PORTDbits.RD2#define M6 PORTDbits.RD3#define M7 PORTDbits.RD4#define PWM_MINUTO PORTDbits.RD5#define M8 PORTDbits.RD6#define M9 PORTDbits.RD7

#define M10 PORTEbits.RE0#define M11 PORTEbits.RE1#define M12 PORTEbits.RE2//*************************************************************************//}

//9o PASSO - PROTOTIPAGEM DE FUNÇÕES//{//*************************************************************************void incrementa_hora(unsigned char);void incrementa_minuto(unsigned char);void atualiza_relogio(unsigned char,unsigned char);

6


void teste_relogio(void);void bip_buzzer(unsigned char);//*************************************************************************//}

//-------------------------------------------------------------------------//10o PASSO - FUNÇÃO PRINCIPAL |//-------------------------------------------------------------------------void main (){//11o PASSO - DEFINIÇÃO DE VARIÁVEIS LOCAIS//{//*************************************************************************

unsigned int debounce;char press;

//*************************************************************************//}//12o PASSO - CONFIGURAÇÃO DOS REGISTRADORES COM FUNCOES ESPECIAIS (SFRs)//{//************************************************************************* UCONbits.USBEN = 0; //Desabilita módulo USB (RC4 e RC5) UCFGbits.UTRDIS = 1; //Desabilita transceiver USB (RC4 e RC5) PORTA = 0xBF; //Desliga leds do PORTA, apenas buzzer desligado PORTB = 0xFF; //Desliga leds do PORTB PORTC = 0xFF; //Desliga leds do PORTC PORTD = 0xFF; //Desliga leds do PORTD PORTE = 0xFF; //Desliga leds do PORTE

7


LATA = 0xBF; //Desliga leds do PORTA, apenas buzzer desligado LATB = 0xFF; //Desliga leds do PORTB LATC = 0xFF; //Desliga leds do PORTC LATD = 0xFF; //Desliga leds do PORTD LATE = 0xFF; //Desliga leds do PORTE

//76543210 TRISA = 0b00000000; //Configura direção dos pinos do PORTA TRISB = 0b00000000; //Configura direção dos pinos do PORTB TRISC = 0b01110000; //Configura direção dos pinos do PORTC (RC3 NÃO IMPLEMENTADO) TRISD = 0b00000000; //Configura direção dos pinos do PORTD TRISE = 0b00000000; //Configura direção dos pinos do PORTE

ADCON1 = 0b00001111; //Desabilita conversores A/D

INTCON2bits.NOT_RBPU = 0; //Habilita pull-ups no PORTB

RCONbits.IPEN = 0; //Desativa níveis de prioridade de interrupção//*************************************************************************//}//13o PASSO - INICIALIZAÇÃO DO SISTEMA//{//*************************************************************************

//Ajusta oscilador interno para 4MHzOSCCONbits.SCS1 = 1; //Fonte de clock internaOSCCONbits.SCS0 = 0;OSCCONbits.IRCF2 = 1; //Frequência de 4MHzOSCCONbits.IRCF1 = 1;OSCCONbits.IRCF0 = 0;

8


//Configura comunicação I2C com o RTC DS12307//SSPADD - SSP Address Register in I2C//SSPADD<6:0>=Fosc(4*Baud rate)-1//SSPADD<6:0>=4.000.000/(4*100.000)-1//SSPADD<6:0>=9SSPADD = 9; //Define baud rate do I2C = 100 kHzOpenI2C(MASTER,SLEW_OFF); //Configura I2C (mestre,100 kHz)

//Desativa níveis de prioridade de interrupçãoRCONbits.IPEN = 0;

//Configura TIMER0 T0CON = 0b10000011; //Configura TIMER0 (16 bits PS = 1:16)

//t = 65536 x 1us x 16 = 1048msINTCONbits.TMR0IF = 0; //Limpa flag do TIMER0INTCONbits.TMR0IE = 1; //Habilita interrupção do TIMER0

//Configura módulo ECCP1 para geração de sinal PWM#ifdef PWM

//Configura TIMER2 para uso PWMOpenTimer2(TIMER_INT_OFF

&T2_PS_1_4);//Define o período do PWM ~1msOpenPWM1(249);//Ajusta o duty cycle para 0,5ms (máximo calculado = 1000)SetDCPWM1(500);//Define a saída de PWM//SetOutputPWM1(SINGLE_OUT,PWM_MODE_1); //RC2 (apenas HORA)

9


SetOutputPWM1(HALF_OUT,PWM_MODE_1); //RC2 e RD5 (HORA e MINUTO)//RD5 = complemento de RC2

#endif

//Delay de 2 segundosDelay10KTCYx(200);

//Roda o teste dos leds e buzzerteste_relogio();

//Liga o RTC#ifdef RTC

liga_rtc();

//Testa comunicação com o RTCif(!le_todo_rtc(dado)) //Se a função NÃO retorna com sucesso{

while(1) //Em caso de falha...{

AM_PM = ~AM_PM; //Pisca ledBUZZER = ~BUZZER; //Dispara buzzerDelay10KTCYx(50);

}}

#endif

//Define o número de bips do alarmebip = N_bips;

10


//Verifica se haverá bip de hora certaif(REL_AL ==1) //Se a chave REL/AL iniciar na posição RELÓGIO

bip_en = 1; //haverá o bip a cada 1 horaelse

bip_en = 0; //Caso contrário não

//Liga chave geral de interrupçõesINTCONbits.GIE = 1;

//*************************************************************************//}//14o PASSO - ROTINA PRINCIPAL//{//*************************************************************************

while(1) { ClrWdt(); if(!HORA) //Se o botão HORA está pressionado

{press = 1;for(debounce = 0; debounce < 10000; debounce++){

if(HORA) {press = 0; break;}}if(press){

bip_buzzer(10);incrementa_hora((unsigned char)REL_AL); //Chama função de

incremento de hora

11


}while(!HORA); //Aguarda soltar o botão

}else if(!MINUTO) //Se o botão MINUTO está pressionado{

press = 1;for(debounce = 0; debounce < 10000; debounce++){

if(MINUTO) {press = 0; break;}}if(press){

bip_buzzer(10);incrementa_minuto((unsigned char)REL_AL); //Chama função de

incremento de minuto}while(!MINUTO); //Aguarda soltar o botão

} } // FIM DO while(1)//*************************************************************************//} }// FIM DA FUNÇÃO PRINCIPAL

//-------------------------------------------------------------------------//15o PASSO - FUNÇÕES SECUNDÁRIAS |//-------------------------------------------------------------------------//{//*************************************************************************//Incrementa Hora

12


//*************************************************************************void incrementa_hora(unsigned char funcao){

unsigned char hora_dec;unsigned char am_pm;

if(funcao == Relogio){

#ifdef RTCle_rtc(hora,&rel_e_al[hora]); //Lê a hora do RTC e armazena em

rel_e_al[hora]#else

rel_e_al[hora] = 0b01100110; //Formatado para PM 6:00#endif

//Separa AM/PM e hora em decimalam_pm = (rel_e_al[hora]&0b00100000)>>5;hora_dec = ((rel_e_al[hora]&0b00010000)>>4)*10 +

(rel_e_al[hora]&0b00001111);

if(hora_dec < 12){

hora_dec++;if(hora_dec == 12) //Se chegou ao meio dia ou meia noite inverte AM/PM

am_pm = ~am_pm;}else{

hora_dec = 1;}

13


#ifdef DEPURAif(hora_dec > 2){

hora_dec = 1;am_pm = ~am_pm;

}#endif

//Define nova hora (Modo 12h + AM/PM + Hx10 + H)rel_e_al[hora] = 0x40 + (am_pm<<5) + ((hora_dec/10)<<4) + (hora_dec%10);

#ifdef RTCescreve_rtc(hora,rel_e_al[hora]); //Atualiza a hora no RTC

#endif//Atualiza relógio com a nova horaatualiza_relogio(rel_e_al[hora],rel_e_al[minuto]);

}else if(funcao == Alarme){

#ifdef RTCle_rtc(hora+10,&rel_e_al[hora+10]); //Lê a hora do alarme no RTC e armazena

em rel_e_al[hora+10]#else

rel_e_al[hora+10] = 0b01100110; //Formatado para PM 6:00#endif

//Separa AM/PM e hora em decimalam_pm = (rel_e_al[hora+10]&0b00100000)>>5;hora_dec = ((rel_e_al[hora+10]&0b00010000)>>4)*10 +

(rel_e_al[hora+10]&0b00001111);

14


if(hora_dec < 12){

hora_dec++;if(hora_dec == 12) //Se chegou ao meio dia ou meia noite inverte AM/PM

am_pm = ~am_pm;}else{

hora_dec = 0; //Hora 0 no alarme é significa alarme desligado}

#ifdef DEPURAif(hora_dec > 2){

hora_dec = 0;am_pm = ~am_pm;

}#endif

//Define nova hora (Modo 12h + AM/PM + Hx10 + H)rel_e_al[hora+10] = 0x40 + (am_pm<<5) + ((hora_dec/10)<<4) + (hora_dec%10);

#ifdef RTCescreve_rtc(hora+10,rel_e_al[hora+10]); //Atualiza a hora do alrme no RTC

#endif//Atualiza relógio com a nova horaatualiza_relogio(rel_e_al[hora+10],rel_e_al[minuto+10]);

}}//*************************************************************************//Incrementa Minuto

15


//*************************************************************************void incrementa_minuto(unsigned char funcao){

unsigned char minuto_dec;

if(funcao == Relogio){

#ifdef RTCle_rtc(minuto,&rel_e_al[minuto]); //Lê os minutos do RTC e armazena em

rel_e_al[minuto]#else

rel_e_al[minuto] = 0b01010000; //Formatado para 50 minutos#endif

//Converte minuto em decimalminuto_dec = ((rel_e_al[minuto]&0b01110000)>>4)*10 +

(rel_e_al[minuto]&0b00001111);

if(minuto_dec < 55){

minuto_dec = ((minuto_dec+5)/5)*5; //Dessa forma o passo atualizado é de 5 em 5.

//Ex.: 34 --> ((34+5)/5)*5 = 35// 35 --> ((35+5)/5)*5 = 40

}else{

minuto_dec = 0;bip_hora = 0; //Quando ajustado manuamente e bip de hora não é

disparado

16


}#ifdef DEPURA

if(minuto_dec > 10){

minuto_dec = 5;}

#endif//Define novos minutosrel_e_al[minuto] = ((minuto_dec/10)<<4) + (minuto_dec%10);

#ifdef RTCescreve_rtc(minuto,rel_e_al[minuto]); //Atualiza os minutos no RTC

#endif//Atualiza relógio com os mivos minutosatualiza_relogio(rel_e_al[hora],rel_e_al[minuto]);

}else if(funcao == Alarme){

#ifdef RTCle_rtc(minuto+10,&rel_e_al[minuto+10]); //Lê os minutos do alarme no RTC e

armazena em rel_e_al[minutos+10]#else

rel_e_al[minuto+10] = 0b01010001; //Formatado para 51 minutos#endif

//Converte minuto em decimalminuto_dec = ((rel_e_al[minuto+10]&0b01110000)>>4)*10 +

(rel_e_al[minuto+10]&0b00001111);

if(minuto_dec < 55){

17


minuto_dec = minuto_dec+5; //Cálculo direto, porque aqui já é de 5 em 5.

}else{

minuto_dec = 0;}

#ifdef DEPURAif(minuto_dec > 10){

minuto_dec = 5;}

#endif

//Define novos minutosrel_e_al[minuto+10] = ((minuto_dec/10)<<4) + (minuto_dec%10);

#ifdef RTCescreve_rtc(minuto+10,rel_e_al[minuto+10]); //Atualiza os minutos no RTC

#endif//Atualiza relógio com os mivos minutosatualiza_relogio(rel_e_al[hora+10],rel_e_al[minuto+10]);

}}//*************************************************************************//Atualiza Relógio//*************************************************************************void atualiza_relogio(unsigned char H,unsigned char M){

PORTA |= 0b10111111; //Desliga leds do PORTA / conserva BUZZER

18


PORTB = 0xFF; //Desliga leds do PORTB PORTC = 0xFF; //Desliga leds do PORTC PORTD = 0xFF; //Desliga leds do PORTD PORTE = 0xFF; //Desliga leds do PORTE

//Verifica AM/PM (led aceso em PM - led acionados pelo catodo)switch(H&0b00100000){

case 0b00000000: AM_PM = 1; break; //AMcase 0b00100000: AM_PM = 0; break; //PM

}//Verifica a horaswitch(H&0b00011111){

case 0x01: H1 = 0; break;case 0x02: H2 = 0; break;case 0x03: H3 = 0; break;case 0x04: H4 = 0; break;case 0x05: H5 = 0; break;case 0x06: H6 = 0; break;case 0x07: H7 = 0; break;case 0x08: H8 = 0; break;case 0x09: H9 = 0; break;case 0x10: H10 = 0; break;case 0x11: H11 = 0; break;case 0x12: H12 = 0; break;//case 0x00: alarme desligado

}//Verifica os minutos

19


M = (M&0b01110000) + ((M&0b00001111)/5)*5; //Dessa forma terie os minutos de 5 em 5

switch(M){

case 0x00: M12 = 0; break;case 0x05: M1 = 0; break;case 0x10: M2 = 0; break;case 0x15: M3 = 0; break;case 0x20: M4 = 0; break;case 0x25: M5 = 0; break;case 0x30: M6 = 0; break;case 0x35: M7 = 0; break;case 0x40: M8 = 0; break;case 0x45: M9 = 0; break;case 0x50: M10 = 0; break;case 0x55: M11 = 0; break;

}}//*************************************************************************//Teste Leds e Buzzer do Relógio//*************************************************************************void teste_relogio(){

unsigned char T = 30;PORTA |= 0b10111111; //Desliga leds do PORTA / conserva BUZZER

PORTB = 0xFF; //Desliga leds do PORTB PORTC = 0xFF; //Desliga leds do PORTC PORTD = 0xFF; //Desliga leds do PORTD PORTE = 0xFF; //Desliga leds do PORTE

20


BUZZER = 1; Delay10KTCYx(T);BUZZER = 0;

REL_AL = 0; Delay10KTCYx(T); H12 = 0; M12 = 0; Delay10KTCYx(T); H12 = 1; M12 = 1; H1 = 0; M11 = 0; Delay10KTCYx(T); H1 = 1; M11 = 1; H2 = 0; M10 = 0; Delay10KTCYx(T); H2 = 1; M10 = 1; H3 = 0; M9 = 0; Delay10KTCYx(T); H3 = 1; M9 = 1; H4 = 0; M8 = 0; Delay10KTCYx(T); H4 = 1; M8 = 1; H5 = 0; M7 = 0; Delay10KTCYx(T); H5 = 1; M7 = 1; H6 = 0; M6 = 0; Delay10KTCYx(T); H6 = 1; M6 = 1; H7 = 0; M5 = 0; Delay10KTCYx(T); H7 = 1; M5 = 1; H8 = 0; M4 = 0; Delay10KTCYx(T); H8 = 1; M4 = 1; H9 = 0; M3 = 0; Delay10KTCYx(T); H9 = 1; M3 = 1; H10 = 0; M2 = 0; Delay10KTCYx(T); H10 = 1; M2 = 1; H11 = 0; M1 = 0; Delay10KTCYx(T); H11 = 1; M1 = 1; BUZZER =1; Delay10KTCYx(T);

21


BUZZER =0; REL_AL = 1; Delay10KTCYx(T);}//*************************************************************************//Bip do Buzzer//*************************************************************************void bip_buzzer(unsigned char T){

BUZZER =1;Delay10KTCYx(T); //Para freq. = 4MHz -> bip = 10ms*TBUZZER =0;

}//*************************************************************************//}

//-------------------------------------------------------------------------//16o PASSO - TRATAMENTO DE INTERRUPÇÕES |//-------------------------------------------------------------------------//{//*************************************************************************//[[[[[ Tratamento das Interrupções de Alta Prioridade ]]]]]//*************************************************************************#pragma interrupt ISR_alta_prioridade //Declada função ISR (Interrupt Service Routine)void ISR_alta_prioridade(){

//Desta forma trata uma interrupção somente se a flag for ativada E estiver habilitada

if(INTCONbits.INT0IF && INTCONbits.INT0IE)

22


{INTCONbits.INT0IF = 0; //Limpa flag

}if(INTCON3bits.INT1IF && INTCON3bits.INT1IE){

INTCON3bits.INT1IF = 0; //Limpa flag}if(INTCONbits.TMR0IF && INTCONbits.TMR0IE){

//Leitura do relógio (t~1s)#ifdef RTC

le_rtc(hora,&rel_e_al[hora]); //Lê a hora do RTC e armazena em rel_e_al[hora]

le_rtc(minuto,&rel_e_al[minuto]); //Lê os minutos do RTC e armazena em rel_e_al[minuto]

le_rtc(hora+10,&rel_e_al[hora+10]); //Lê a hora do alarme do RTC e armazena em rel_e_al[hora]

le_rtc(minuto+10,&rel_e_al[minuto+10]); //Lê os minutos do alarme do RTC e armazena em rel_e_al[minuto]#else

//rel_e_al[hora] = 0b01100110; //Formatado para PM 6:00//rel_e_al[hora+10] = 0b01100110; //Formatado para PM 6:00//rel_e_al[minuto] = 0b01010001; //Formatado para 51 minutos//rel_e_al[minuto+10] = 0b01010001; //Formatado para 51 minutosrel_e_al[hora] = 0b01100010; //Formatado para PM 2:00rel_e_al[hora+10] = 0b01100010; //Formatado para PM 2:00rel_e_al[minuto] = 0b00000101; //Formatado para 5 minutosrel_e_al[minuto+10] = 0b00000101; //Formatado para 5 minutos

#endif

23


//Atualiza o relógioif(REL_AL) //Se é função Relógio...

atualiza_relogio(rel_e_al[hora],rel_e_al[minuto]);else //Se é função Alarme...

atualiza_relogio(rel_e_al[hora+10],rel_e_al[minuto+10]);//Bip de hora certaif(rel_e_al[minuto]==0 && bip_hora==1 && bip_en==1){

bip_buzzer(10);Delay10KTCYx(10);bip_buzzer(10);bip_hora = 0;

}if(rel_e_al[minuto]>0)

bip_hora = 1;//Verifica o alarme if(rel_e_al[hora]==rel_e_al[hora+10] &&

rel_e_al[minuto]==rel_e_al[minuto+10]){

if(bip>0){

BUZZER = ~BUZZER;if(BUZZER == 0) bip--; //Sempre que o buzzer desliga decrementa 1

em bip}

}else

bip = N_bips;//Finaliza interrupção

24


INTCONbits.TMR0IF = 0; //Limpa flag}if(PIR1bits.TMR1IF && PIE1bits.TMR1IE){

PIR1bits.TMR1IF = 0; //Limpa flag}

}

#pragma code int_alta = 0x08 //Vetor de interrupção de alta prioridadevoid int_alta(void){

_asmGOTO ISR_alta_prioridade //Desvia para rotina de tratamento

_endasm}#pragma code//*************************************************************************//}//}

/*=========================================================================REPRESENTAÇÃO NUMÉRICA NO MPLAB COMPILADOR C18===========================================================================DECIMAL XXHEXADECIMAL 0xXXOCTAL 0XXBINARIO 0bXXXXXXXXCARACTERE ASCII 'X'STRING ASCII "XXXXXXXX"

25


X - VALOR=========================================================================*/

26