Projeto de um semforo com interrupo do pedestre em um

microcontrolador de 8 bits (MC9S08AW60)

Everton Luiz de Aguiar
everton.eie@gmail.com
Laure M. da Silva Palma
laure.eie@gmail.com
Lucas Santolin
lucasantolin.eie@gmail.com
Rodrigo Pizzatto
pizzatto.eie@gmail.com

Universidade Tecnolgica Federal do Paran UTFPR
Campus Pato Branco
Via do Conhecimento, Km 1 CEP 85503-390 Pato Branco PR
Disciplina: Sistemas Microcontrolados
Professor: Fbio Bertotti


Resumo Este projeto tem por objetivo propor um sistema
microcontrolado (semforo), com interrupo gerada pelo
pedestre, apresentando as caractersticas do microcontrolador
e tambm o fluxograma do semforo completo, e a
implementao prtica do semforo em uma matriz de contatos
utilizando leds.

Palavras-chave Interrupo; Microcontrolador
MC9S08AW60; CodeWarrior.

I. INTRODUO

A. MICROCONTROLADORES
Com o avano da tecnologia, e consequentemente
popularizao da micro-eletrnica, cada vez mais comum o
uso de microprocessadores em aplicaes de controle de
processos em geral.
Na realidade, com o intuito de otimizar a relao de
custo/benefcio na hora de implementao de um sistema
digital, surgiu o microcontrolador, que um encapsulamento
contendo todos os dispositivos bsicos para funcionamento de
um sistema processado. Os dispositivos includos em um
microcontrolador basicamente so: processador, memria e
mdulos de entrada e sada.
Alm dos dispositivos bsicos citados, o
microcontrolador ainda conta com diversas outras
caractersticas, que variam de modelo para modelo. Nesse
sentido, os microcontroladores possuem uma ampla variedade
de configuraes, que vo desde os mais simples (e mais
baratos) at os mais sofisticados (e mais caros), sendo que o
projetista do sistema deve estar ciente de optar pelo modelo
que melhor se adapte s suas necessidades, resolvendo o
problema em questo com o mnimo de investimento.
Os microcontroladores possuem grande aplicabilidade
na rea de automao e controle de processos. Exemplos so
eletrodomsticos (forno de microondas, condicionadores de ar,
televisores e etc), sistemas de controle automotivos (injeo
eletrnica), alm de muitos outros dispositivos eletrnicos em
geral.

B. O MICROCONTROLADOR MC9S08AW60
Neste projeto foi utilizado o microcontrolador
MC9S08AW60 e o seu kit de programao.
Para a programao foi utilizado o aplicativo
CodeWarrior para Microcontrollers da Freescale.
Esse microcontrolador da famlia HCS08, a seguir
ser apresentadas algumas caractersticas deste
microcontrolador:
20 MHz de frequncia do barramento interno;
60 Kbytes de memria flash;
2 Kbytes de memria RAM;
16 canais 10 bits do conversor ADC;
2 mdulos SCI;
Mdulo SPI;
8 pinos de interrupo do teclado (KBI);
54 pinos de uso geral entrada / sada (I / O);
Soquete de 64 pinos pacote LQFP;
40 pinos de expanso;
Porta serial RS-232;
Boto de master reset.
Para efetuar o controle dos leds (semforo), sero
utilizados 2 portas de sada e 10 bits para o acionamento dos
leds dos semforos.

C. SEMFORO COM INTERRUPO DO TECLADO
Um semforo normal tem como objetivo o trfego de
veculos e de pedestres. O controle semafrico permite alternar
o direito de passagem na zona de trafego de uma interseo
de ruas. Neste projeto utilizando microcontrolador os tempos,
so especificaes do projeto e so esses, para os carros:
Tempo do sinal aberto (verde): 8s;
Tempo do sinal fechado (vermelho): 10s;
Tempo do sinal amarelo (amarelo): 2s;
Para os semforos dos pedestres os tempos so os
seguintes:
Tempo do sinal aberto (verde): 10s;
Tempo do sinal fechado (vermelho): 10s;
Mas cada vez que o sinal estiver verde para os carros
de uma rua, e um pedestre quiser passar pela rua pode apertar
o boto que gera a interrupo e com isso o semforo ficar
mais 2 segundos no estado amarelo e depois ir fechar o sinal
vermelho dos carros, liberando a passagem dos pedestres
desta rua. E como a lgica inversa para os semforos
quando um estiver verde o outro tem o estado contrrio, ou
seja, estar vermelho.
Se acaso nenhum boto for apertado o semforo
continua seguindo sua rotina de execuo, no sendo gerada
nenhuma interrupo.
A figura 1 mostra como seria o semforo utilizando
microcontrolador, se fosse implementado em uma rua com
fluxo de carros e pedestres.

Figura 1 Ilustrao do semforo proposto implementado em uma
travessia de carros e pedestres.

II. METODOLOGIA

A. DESCRIO DA PROBLEMTICA
Considere-se o sistema de sinalizao de trnsito em
duas vias de mo nica mostrado na figura 1.
Tendo por base a figura 1, o semforo deve funcionar
normalmente at que algum pedestre aperte um dos botes pn
solicitando a passagem pela faixa de pedestres. Quando
solicitada a travessia de uma via pelo pedestre, o sinal para
carro que controla o trfego de veculos nesta rua deve
imediatamente ir para amarelo, no caso de estar verde neste
instante. Caso este semforo para carros esteja fechado, ou
vermelho, o pedestre no deve conseguir interferir no
funcionamento cclico sistema.
No funcionamento normal do sistema de sinalizao,
podem ser citados 4 estados, ou configuraes diferentes para
as luzes, e estes estados so apresentados na tabela 1. Nesta
tabela, a notao 0 representa que a luz est desligada e a
notao 1 que est ligada.

Tabela 1 Configurao das Luzes para os Estados dos Semforos
Veculos Pedestres
Verde Amarelo Vermelho Verde Vermelho
ESTADO 1
S1 0 0 1 P1 0 1
S2 0 1 0 P2 0 1
ESTADO 2
S1 1 0 0 P1 0 1
S2 0 0 1 P2 1 0

Tabela 1 Configurao das Luzes para os Estados dos Semforos
(Continuao)
ESTADO 3
S1 0 1 0 P1 0 1
S2 0 0 1 P2 0 1
ESTADO 4
S1 0 0 1 P1 1 0
S2 1 0 0 P2 0 1

A primeira etapa da elaborao do projeto foi o
desenvolvimento de um fluxograma, mostrado na figura 2, que
ilustra as transies de estados do sistema, e os
temporizadores. Defina-se estado do sistema, como a
configurao instantnea de todos os semforos.
Passou
2s?
Sim
Estado1
Incrementa
Contador
No
Passou
8s?
Estado2
Incrementa
Contador
No
Zera contador
anterior.
Dispara
prximo timer
Passou
2s?
Estado3
Incrementa
Contador
No
Zera contador
anterior.
Dispara
prximo timer
Passou
8s?
Estado4
Incrementa
Contador
No
Zera contador
anterior.
Dispara
prximo timer
Pedestre 2
pressionou a
tecla?
Sim No
cont>=3?
Sim
Zera
contador
auxiliar
(cont=0)
Sim
No
Zera contador
anterior.
Dispara
prximo timer
Pedestre 1
pressionou a
tecla?
Sim
No
cont>=3?
Zera
contador
auxiliar
(cont=0)
Sim
Sim
Sim
Incrementar
contador
auxiliar
(cont++)
No

Figura 2 Fluxograma do Semforo

Ainda, algum mecanismo deve ser implementado para
impedir que os pedestres interrompam o fluxo de veculos mais
que uma vez em um curto perodo de tempo. Na figura 1,
notam-se quatro botes para pedestres. Como h somente
dois semforos para veculos, os botes bp1 e bp3 tm a
mesma funo, assim como bp2 e bp4. colocado em cada
lado da rua um semforo para pedestre, e sendo assim, o
semforo P1=P3, e P2=P4. Por esse motivo tanto no cdigo
quanto no fluxograma da figura 3, s foram representados os
botes bp1 e bp2 e os semforos de pedestre P1 e P2.
No fluxograma notado que, mesmo que os semforos
de carro necessitem ficar 10s fechados (vermelhos), com a
transio de estados, garante-se que esse intervalo de 10s
seja obtido, utilizando temporizadores de 8s e 2s. Por exemplo,
se S1 passou 8s em verde, S2 passou 8s em vermelho.
Quando S1 se tornar amarelo, durante um tempo de 2s, S2
ainda estar vermelho. Sendo assim, somando 8s+2s obtm-
se os 10s de sinal vermelho requeridos. A mesma anlise pode
ser feita para S2 8s em verde.

B. IMPLEMENTAO NO MICROCONTROLADOR

(i) Implementao dos Timers
Como mencionado anteriormente, para mudana de um
estado para outro, deve-se decorrer um determinado instante
de tempo. Esse instante de tempo pode ser 8s ou 2s,
dependendo da transio. Ento, necessria a configurao
de 2 contadores de tempo no microcontrolador: um que retorne
um flag de estouro de tempo em 8s e outro que gere um flag
por estouro de tempo em 2s. Para isso o registrador TPM1SC1
foi configurado com um fator de diviso de 64, criando uma
bases de tempo de 100ms. Assim, dentro da rotina de
interrupo do timer TPM1, os dois contadores de tempo foram
gerados, o de 8s contando at 80 e o de 2s contando at 20.
Para essa configurao, necessrio ter em vista:
A freqncia do barramento, que neste caso de
20MHz por cristal externo;
O fator de diviso de clock;
A resoluo do registrador de mdulo de contagem de
tempo.
Para o TPM1SC de 8s:
Freqncia do barramento: 20MHz;
Fator de diviso: 64;
Perodo do ciclo: 3,2us;
Base de tempo: 100ms;
Contagem mxima: 31250;
O registrador de mdulo de contagem possui 16 bits, e
portanto pode contar at 65356. Ento para gerar um estouro
de tempo a cada 8s, necessrio um contador auxiliar via
software, que conte 80 vezes o estouro de tempo de 100ms.
Para o temporizador de 2s:
Freqncia do barramento: 20MHz;
Fator de diviso: 64;
Perodo do ciclo: 3,2us;
Base de tempo: 100ms;
Contagem mxima: 31250;
Para gerar um estouro de tempo a cada 2s,
necessrio um contador auxiliar via software, que conte 20
vezes o estouro de tempo de 100ms.
O mecanismo de estouro de tempo deve funcionar da
seguinte maneira: Inicialmente, forada a entrada no estado
5. Neste ponto, uma varivel diparoT1 setada em 1. Na rotina
de interrupo do timer 1, existem dois comandos de seleo,
um para disparoT1 (disparo do contador de 8s) e um para
disparoT2 (disparo do contador de 2s). Estando disparoT1 em
1, o contador de 8s incrementado na rotina de interrupo
por overflow do timer1. Quando o contador extrapolar 80, uma
varivel de estouro de tempo de 8s setada em 1, retornando
esse valor ao programa principal, e culminando na troca de
estados para o estado 1. Entrando no estgio 1, a flag de
estouro de tempo de 8s deve ser zerada, e a contagem de
tempo de transio entre o estado 1 e estado 2 deve ser
iniciada, atravs da configurao de disparoT2. O estado 2
somente ser alcanado quando a rotina de interrupo de
timer1 retornar o estouro de tempo de 2s em 1.



(ii) Configurao das Portas
Foram utilizados 10 pinos (Trs para cada sinal de
veculo e dois para cada sinal de pedestre, totalizando dez)
habilitados em alta capacidade de corrente como sadas para
acionamento dos indicadores. Os indicadores utilizados, como
prottipo, foram leds.
As portas de sada do microcontrolador utilizadas foram
as portas A e D. A porta A possui 8 bits, e 6 deles foram
utilizados como sadas para os leds indicadores dos sinais de
veculos. J da porta G, que a nica no microcontrolador que
gera interrupo em pinos de entrada, foram utilizados os pinos
0 e 1 como entradas dos botes dos pedestres.
Quatro bits da porta D foram utilizados como sada para
os semforos de pedestres. (dessa forma, totalizaram-se as 10
portas de sada necessrias)
importante ressaltar que durante a execuo do
cdigo, em qualquer momento o pedestre pode requisitar a
interrupo, cabendo ao cdigo selecionar a ao decorrente
desta interrupo.

(iii) Inicializao da CPU
A inicializao da CPU foi feita tendo em base o projeto do
multmetro, realizado com auxlio do professor.

(iv) Configurao do timer do teclado
Os botes para os pedestres utilizados foram do tipo
push bottons. Como esses botes so chaves mecnicas, e a
porta G foi inicializada para gerar uma interrupo por borda,
possvel que seus aspectos construtivos gerem mais que uma
interrupo a cada pressionamento. Para corrigir esse
problema, neste projeto foi utilizado o Timer 2 do
microcontrolador para validar a tecla pressionada. O
mecanismo prov que uma flag para cada bit de entrada de
chave seja setada 1ms depois que a primeira interrupo por
pressionamento aconteceu, verificando novamente se est
pressionada ainda, ou se a primeira interrupo ocorreu
somente por imperfeio mecnica na chave. Assim, valida-se
a pressionada da tecla na segunda interrupo consecutiva do
timer 2.
Para o contador de Bounce do teclado, foi configurado o
timer 2 do microcontrolador, com uma base de tempo de 2ms,
fator de diviso de clock de 32 e mxima contagem at 625.

(v) Interrupo por tecla pressionada
O pedestre pode apertar o boto para interromper o
trnsito em qualquer momento. Para no truncar o fluxo de
veculos, um contador no final do 4 estado foi implementado,
de modo a permitir inverso da lgica do semforo a cada 3
ciclos completos
Quando uma tecla pressionada, esta verificada
somente no final do 4 estado, desde que j tenham ocorrido 3
ciclos completos de funcionamento normal do semforo sem
interrupes.

(vi) Cdigo no Microcontrolador
Com base na problemtica, e tendo em vista a
apostila referente utilizao do kit de programao e a
folha de dados do microcontrolador, foi possvel
desenvolver o cdigo comentado mostrado abaixo. Com o
cdigo feito, este rodado do prprio microcontrolador
com ajuda do kit de programao. Desta maneira, simula-
se o comportamento de um semforo real em um prottipo
com leds. O cdigo desenvolvido apresentado no anexo
1.

III DESENVOLVIMENTO PRTICO E CONCLUSO

Com a inicializao das portas de sada do
microcontrolador e cada um dos bits ligado corretamente ao
led correspondente na matriz de contatos foram feitos testes
no programa e na montagem do circuito montado na prtica,
para a montagem do circuito implementado na prtica foi
utilizado o seguinte esquemtico, que est na figura 3.

Figura 3 Esquemtico do semforo implementado na prtica.

Feita a programao do microcontrolador foram feitas
as ligaes com os led e os elementos passivos do circuito, e
com isso foram feitos os testes do funcionamento do
semforo, que se comportou de forma correta, e obedecendo
a lgica de funcionamento do semforo com interrupo de
teclado.

IV - REFERNCIAS
[1] Datasheet do Microcontrolador Freescale MC9S08AW60
http://www.freescale.com. Acessado em 20/06/2010.
[2] G.W Denardini, Tutorial para Programao da Placa
MC9S08AW60.
ANEXO 1 CDIGO FONTE

#include "derivative.h" /* include peripheral declarations */
#include <MC9S08AW60.h>

//reconfigurar de acordo com a biblioteca
#define C1verde _PTAD.Bits.PTAD0
#define C1amarelo _PTAD.Bits.PTAD1
#define C1vermelho _PTAD.Bits.PTAD2
#define C2verde _PTAD.Bits.PTAD3
#define C2amarelo _PTAD.Bits.PTAD4
#define C2vermelho _PTAD.Bits.PTAD5
#define P1verde _PTAD.Bits.PTAD6
#define P1vermelho _PTAD.Bits.PTAD7
#define P2verde _PTDD.Bits.PTDD2
#define P2vermelho _PTDD.Bits.PTDD3


// definicao dos timers

//#define Timer8s _TPM1SC.Bits.TOF // configurar os registradores para
contar at 8 e 10s
//#define Timer2s _TPM2SC.Bits.TOF
//#define disparoT1 0x4E // define o bit para disparar T1
//#define disparoT2 0x4E // define o bit para disparar T2

#define Tecla1 _PTGD.Bits.PTGD0
#define Tecla2 _PTGD.Bits.PTGD1

void C1(void){ // passa 2s nesta condicao

C1verde = 0;
C1amarelo = 0;
C1vermelho = 1;
C2verde = 0;
C2amarelo = 1;
C2vermelho = 0;
P1verde = 0;
P1vermelho = 1;
P2verde = 0;
P2vermelho = 1;

// chama o timer
}

void C2(void){ // passa 8s nesta condicao

C1verde = 1;
C1amarelo = 0;
C1vermelho = 0;
C2verde = 0;
C2amarelo = 0;
C2vermelho =1;
P1verde = 0;
P1vermelho = 1;
P2verde=1;
P2vermelho=0;
}






void C3(void){ // passa 2s nesta condicao

C1verde = 0;
C1amarelo = 1;
C1vermelho = 0;
C2verde = 0;
C2amarelo = 0;
C2vermelho =1;
P1verde = 0;
P1vermelho = 1;
P2verde=0;
P2vermelho=1;
}

void C4(void){ // passa 8s nesta condicao

C1verde = 0;
C1amarelo = 0;
C1vermelho = 1;
C2verde = 1;
C2amarelo = 0;
C2vermelho =0;
P1verde = 1;
P1vermelho = 0;
P2verde=0;
P2vermelho=1;
}

void C5(void){
C1verde = 0;
C1amarelo = 0;
C1vermelho = 1;
C2verde = 0;
C2amarelo = 0;
C2vermelho =1;
P1verde = 0;
P1vermelho = 1;
P2verde=0;
P2vermelho=1;
}


unsigned int u1=0,u2=0,estourou_8s=0,estourou_2s=0; disparoT1; disparoT2;
unsigned char Tecla1_pressionada=0, Tecla2_pressionada=0, tecla_pressionada=0;
// chamada dos vetores de interrupcao

interrupt 22 void teclado(void);
interrupt 11 void int_Timer1(void);
interrupt 14 void int_Timer2(void);

void ini_cpu(void);
void ini_Timer1(void);
void ini_Timer2(void);
void ini_pta(void);
void ini_ptg(void);

//-------------------------------------------------------------------------------------
//------------------------------- M A I N ---------------------------------------------

void main(void) {


unsigned int cond1=0, cond2=0, cond3=0, cond4=0;
unsigned int T1press=0, T2press=0, cont=0;

// chamada de funcoes de inicializacao

ini_cpu();
ini_Timer1();
ini_Timer2();
ini_pta();
ini_ptg();


C5(); // condicao inicial de tudo vermelho
cond4=1;
disparoT1 = 1;

while(1){

if((cond4==1) && (estourou_8s==1) && (cond2==0)&&(cond3==0)&&(cond1==0)) {
C1();
cond1=1;
cond4=0;
estourou_8s=0;
disparoT2=1;

}

if((cond1==1)&&(estourou_2s==1)&&(cond2==0)&&(cond3==0)&&(cond4==0)){
C2();
cond1=0;
cond2=1;
estourou_2s=0;
disparoT1=1;
// liga timer de 8s e zera timer2s
}

if((cond2==1)&&(estourou_8s==1)&&(cond3==0)&&(cond4==0)&&(cond1==0)){
C3();
cond3=1;
cond2=0;
estourou_8s=0;
disparoT2=1;
// liga timer de 2s e zera timer8s
}

if((cond3==1)&&(estourou_2s==1)&&(cond2==0)&&(cond4==0)&&(cond1==0)){
C4();
cond3=0;
cond4=1;
estourou_2s=0;
disparoT1=1;
cont++;

if(cont>=3){
cont=0;
T1press=0;
T2press=0;
}
// liga timer de 8s e zera timer2s
}

if((Tecla2_pressionada==1)&&(T2press==0)) {
C1();
cond1=1; cond2=0;cond3=0; cond4=0;
//TPM1CNT=0; // reseta timer de 8s
//TPM2CNT=0; // reseta timer de 2s
disparoT2=1; // liga timer de 2s
T2press=1;

cont=0;

Tecla2_pressionada=0;


}

if((Tecla1_pressionada==1)&&(T1press==0)){
C3();
cond3=1; cond2=0; cond4=0; cond1=0;
// TPM1CNT=0;
//TPM2CNT=0;
disparoT2=1;// liga timer de 2s
Tecla1_pressionada=0;
T1press=1;
cont=0;
}


}


for(;;) {
__RESET_WATCHDOG(); /* feeds the dog */
} /* loop forever */
/* please make sure that you never leave main */
}


//-------------------------------------------------------------------------------------
//-------------------------- inicializacao de portas e CPU ----------------------------

void ini_cpu(void){


/* SOPT: COPE=0,COPT=1,STOPE=0,??=1,??=0,??=0,??=1,??=1 */
SOPT = 0x53;

/* SPMSC1: LVDF=0,LVDACK=0,LVDIE=0,LVDRE=1,LVDSE=1,LVDE=1,??=0,BGBE=0 */
SPMSC1 = 0x1C;

/* SPMSC2: LVWF=0,LVWACK=0,LVDV=0,LVWV=0,PPDF=0,PPDACK=0,??=0,PPDC=0 */
SPMSC2 = 0x00;

// Sada de Clock Externo do pino PTC2 desabilitado
/* SMCLK: MPE=0,MCSEL=0 */
SMCLK = 0;

/* Inicializao do sistema de clock */
/* ICGC1: HGO=1,RANGE=1,REFS=1,CLKS1=1,CLKS0=1,OSCSTEN=0,LOCD=0,??=0 */
ICGC1 = 0xF8;

/* ICGC2: LOLRE=0,MFD2=0,MFD1=1,MFD0=1,LOCRE=0,RFD2=0,RFD1=0,RFD0=0 */
ICGC2 = 0x30;
while(!ICGS1_LOCK) { /* Espera o mdulo ICG estabilizar o clock configurado */
}
EnableInterrupts; /* enable interrupts */
/* include your code here */


}

void ini_Timer1(void) { // base de 100ms
TPM1CNT = 0x0000;
TPM1MOD = 31250;
TPM1SC = 0x4E;
}


void ini_Timer2(void){ // base de 1ms
TPM2CNT = 0x0000;
TPM2MOD = 625;
TPM2SC = 0x4D;
}


void ini_pta(void){ // porta para saida de veiculos

PTADD = 0xFF; // configurado para saida

PTADS = 0xFF; // corrente de saida, 1 para alta
PTAPE = 0x00; // pull up
PTASE = 0x00; // slew rate

PTAD_PTAD0 = 0; // VERDE SEMAFORO 1
PTAD_PTAD1 = 0; // AMARELO SEMAFORO 1
PTAD_PTAD2 = 0; // VERMELHO SEMAFORO 1
PTAD_PTAD3 = 0; // VERDE SEMAFORO 2
PTAD_PTAD4 = 0; // AMARELO SEMAFORO 2
PTAD_PTAD5 = 0; // VERMELHO SEMAFORO 2
PTAD_PTAD6 = 0;
PTAD_PTAD7 = 0;
}


void ini_ptg(){

PTDDD_PTDDD2=1; // BITS DA PORTA G COMO SAIDAS, SEM AFETAR OS BITS 0 E 1 QUE SAO DO
TECLADO
PTDDD_PTDDD3=1;





PTDDS_PTDDS2=1; // ALTA CAPACIDADE DE CORRENTE PARA PODER ACENDER OS LEDS.
PTDDS_PTDDS3=1;


PTDD_PTDD2=0; // VERDE SEMAFORO PEDESTRE 1
PTDD_PTDD3=0; // VERMELHO SEMAFORO PEDESTRE 1

PTGDD_PTGDD0 = 0;
PTGDD_PTGDD1 = 0;

PTGPE_PTGPE0 = 1;
PTGPE_PTGPE1 = 1;

PTGD_PTGD0 = 0;
PTGD_PTGD1 = 0;

// Pinos do mdulo de teclado da porta G configurados para pull-up

PTGPE = 0x03;
// Inicia a latch da porta D com todos os bits em zero


// 8 pinos associados ao mdulo KBI configurados para teclado
KBI1PE = 0b00000011;

/* KBEDG7=0,KBEDG6=0,KBEDG5=0,KBEDG4=0,KBF=0,KBACK=0,KIE=1,KBIMOD */
// Mdulo de teclado com interrupo ativa e acionada por borda de descida
KBI1SC = 0x06;



}

//---------------------------------------------------------------------------------------//-
----------------------------- Interrupcoes -------------------------------------------

interrupt 22 void teclado(void){
KBI1SC_KBACK = 1; // Limpa flag de teclado
KBI1SC_KBIE = 0; // desabilita para processar a tecla

tecla_pressionada=1;


}

interrupt 11 void Timer1(void){
TPM1SC_TOF=0;
if(disparoT1==1){
u1++;
if(u1==80){
estourou_8s=1;
u1=0;
disparoT1=0;
}
}

if(disparoT2==1){
u2++;
if(u2==20){
estourou_2s=1;
u2=0;
disparoT2=0;
}
}

TPM1SC=0x4E;
}

interrupt 14 void Timer2(void){ // contador de Bounce
static char k=0;
TPM2SC_TOF=0;

if(tecla_pressionada==1){
k++;
if(k==2){
if(Tecla1==0) Tecla1_pressionada=1;
if(Tecla2==0) Tecla2_pressionada=1;
tecla_pressionada=0; k=0;
KBI1SC_KBIE = 1;
}

}

TPM2SC=0x4D;

}