ASM51

eu gostaria de medir a largura de pulso de uma frequencia de 1khz, isto é 1ms, atraves do pino INT0 na borda de descida?estou usando timer0 de 16 bits!
como eu faço para obter esse tempo de 1ms no registradores do timer0
(TH0 e TL0) e jogar numa variavel int e depois verificar se é 1ms?esses valores que estao dentro do TH0 e TL0 são em hex??

A soluçao é bem simples.
Só não é mais simples porque TH0 e TL0 não são "vizinhos", então não dá pra jogar direto pra uma int.
Se é HEX ou Bin ou Dec não importa, isso é só a forma como é mostrado, o conteudo (valor) é o mesmo.

para ler TH0 e TL0:
unsigned int VALOR;
...
VALOR = (TH0 >> + TL0;

A sua pergunta não esta bem clara, mas para fazer um timer de 1 ms precisamos saber qual o valor do cristal usado.
você pode conseguir estes calculos nos livros

para escreve o valor em TH0 e TL0 é bem fácil usar algo como
TH0 = HIGH VALOR;
TL0 = LOW VALOR;

Não tenho certeza se funciona em todos os compiladores, pode fazer assim também:
TH0 = VALOR <<8;
TL0 = VALOR;

Observe que quando copia um inteiro de 16 bits para 8 bits ele copia a parte baixa, por isso não precisa colocar nenhum mascaramento.
Alguns compiladores como o KEIL interpreta o <<8 para pegar a parte alta do valor, o código fica bem otimizado, ele não vai realmente fazer os 8 deslocamentos.


Para medir a largura do pulso você tem de saber quantos pulsos corresponde a 1ms em um determinado tempo, o resto é só regrinha de três.

avecasella
eu acho que coloquei mal minha pergunta.

eu gostaria de medir a largura de pulso de uma frequencia de 1khz, atraves do pino INT0 na borda de descida, usando timer0 de 16 bits!nessa frequencia a parte baixa é de 500us e parte alta desse pulso é 500us para fechar o periodo de T=1ms.

minha pergunta é a seguinte:como eu faço para obter esse tempo de 500us nos registradores do timer0 (TH0 e TL0) e jogar numa variavel int e depois verificar se é 500us?

obs:quando minha entrada for 0 , la na interrupção INT0 eu reseto os registatradores TH0=0 e TL0=0 e aguardo o pino ficar 1 para verficar os registradores do timer TH0 TL0. outra pergunta enquanto eu tiver aguardando o pino ficar em 1 o timer zero fica contando(isto é ,fica incrementando os registradores TH0 e TL0)??

O valor calculado nao é exatamente o valor real, tendo em vista que o tratamento da interrupcao consome alguns ciclos de maquina.

Aqui vai uma regra de calculo que utilizo para os timers do 51 ( baud-rate e interrupcao de timer ) : É tudo parametrizado para facilitar :

Código: Selecionar todos


/*=========  Parametros Configuraveis  ===========*/

#define  BAUDRATE                  9600   // bps
#define  FREQUENCIA_CRISTAL 24000000 // Hz
#define  FREQ_TIMER_0             100  // Hz
#define  FREQ_TIMER_1             48  // Hz
#define  CICLOS_DE_MAQUINA  12

/*=======================================*/

#define  DIVIDENDO_BAUDRATE FREQUENCIA_CRISTAL
#define  DIVSOR_BAUDRATE    (unsigned long)((unsigned long)32*(unsigned long)BAUDRATE)
#define  QUOCIENTE_BAUDRATE (unsigned int)((unsigned long)DIVIDENDO_BAUDRATE/(unsigned long)DIVSOR_BAUDRATE)
#define  CARGABAUD          (unsigned int)((unsigned long)65536-(unsigned long)QUOCIENTE_BAUDRATE)
#define  CARGABAUD_L        (char)(CARGABAUD%256)
#define  CARGABAUD_H        (char)(CARGABAUD>>8)

#define  DIVIDENDO_TIMER (unsigned long)((unsigned long)FREQUENCIA_CRISTAL/(unsigned long)CICLOS_DE_MAQUINA)

#define  DIVISOR_TIMER_0 (unsigned long)FREQ_TIMER_1
#define  CARGA_TIMER_0   (unsigned int)((unsigned long)65536-(DIVIDENDO_TIMER/DIVISOR_TIMER_0))-1
#define  CARGA_TIMER_0_L (char)(CARGA_TIMER_0%256)
#define  CARGA_TIMER_0_H (char)(CARGA_TIMER_0>>8)

#define  DIVISOR_TIMER_1 (unsigned long)FREQ_TIMER_1
#define  CARGA_TIMER_1   (unsigned int)((unsigned long)65536-(DIVIDENDO_TIMER/DIVISOR_TIMER_1))-1
#define  CARGA_TIMER_1_L (char)(CARGA_TIMER_0%256)
#define  CARGA_TIMER_1_H (char)(CARGA_TIMER_0>>8)

/*----------------------------------------------------------------*/

#define  BUFFER_SERIAL                   SBUF
#define  FLAG_INTERRUPCAO_TRANSMISSAO    TI
#define  FLAG_INTERRUPCAO_RECEPCAO       RI

#define  BYTE_H_TMR0                     CARGA_TIMER_0_H
#define  BYTE_L_TMR0                     CARGA_TIMER_0_L
#define  BYTE_H_TMR1                     CARGA_TIMER_1_H
#define  BYTE_L_TMR1                     CARGA_TIMER_1_L
#define  BYTE_H_TMR2                     CARGABAUD_H
#define  BYTE_L_TMR2                     CARGABAUD_L
//---------------------------------------------
#define  _RECARGATIMER0   TH0 = BYTE_H_TMR0 ; \
                          TL0 = BYTE_L_TMR0 ;

#define  _RECARGATIMER1   TH1 = BYTE_H_TMR1; \
                          TL1 = BYTE_L_TMR1;
/*----------------------------------------------------------------*/


/************************************************/
void Disable(void)
{
  interrupcoes++;
  EA=0;
}
/************************************************/
void Enable(void)
{
  interrupcoes--;
  if( ! interrupcoes ) EA=1;
}
/***********************interrupt void IntTimer1( )*/
/* void interrupt void IntTimer0( )                               */
/**********************************************/
void timer0 (void) interrupt TIMER_0 using BANK_0
{
   Disable();
   _RECARGATIMER0
   OKTOTMR0ON;   
   Enable();
}
/************************interrupt void IntTimer1( )*/
/* void interrupt void IntTimer1( )                                 */
/***********************************************/
void timer1 (void) interrupt TIMER_1 using BANK_0
{
   Disable();
   _RECARGATIMER1
   OKTOTMR1ON;   
   Enable(); 
}
/**************************interrupt void IntSerial( )*/
/* void interrupt void IntSerial( )                                    */
/************************************************/
void serial (void) interrupt SERIAL using BANK_2
{
//// rotina da serial
}