Dica de Tempo

[Pask]

Amigos, certo dia vi um post aqui sobre alguém perguntando como contar tempos maiores em programas. Então, vai aqui uma dica de um dos modos de se fazer isto.
No compilador CCS, por exemplo, usando a diretiva "delay" é possível escrever a função abaixo e substituir a variável "n" por qualquer número inteiro que o programador queira para contar o tempo desejado:

void tempo ( ){
static int x,n;

while (x < n){
delay_ms(60000);
x++;
}
}

Então, veja que a diretiva "delay" conta um tempo máximo de 60 segundos ou 1 minuto. Substituindo n por 2,3,4,5,6...etc; vc pode multiplicar essa contagem pelo tempo que desejar. Por exemplo, se vc quiser que a função "tempo" conte 10 minutos, faça n=10; se vc quiser que o tempo contado seja de 30 minutos, faça n=30 e assim por diante.
Bom proveito!

[Djalma Toledo Rodrigues]

Esta anotado --Abraço Obrigado

[Pask]

Valeu e espero que esta simples dica possa ser útil para outros amigos programadores como eu.

[turuna]

Tb uso este macete no MICROC, mas ao invés de usar while uso o for que dá no mesmo..........e fiz através de uma função, isso porque economizo memória, pois eu carrego o valor e chamo a função, ai eu fiz duas uma até um minuto e outra para até horas... ficou ótimo.

Turuna

[Pask]

Como é a sua função, Turuna?

[turuna]

Como é a sua função, Turuna?

[

//##############################################################################
//ROTINA DE ESPERA EM mili segundos(1 A 65535 ms) #
//exemplo de chamada: DELAY_MS(500);//duara 500 milisegundos #
void DELAY_MS_2(unsigned int a)// #
{// #
unsigned int i;// #
for (i = 0; i < a; i++){//executa a quantidade de loop conforme valor de "i" #
{// #
delay_ms(1);// #
}//fecha loop delay #
}//fecha loop for #
}//fecha função "DELAY_MS_2" #
//##############################################################################]

[/code]

[Pask]

A sua função é praticamente idêntica a minha. A única diferença é que você envia o parâmetro "a" para a função para determinar o tempo desejado.
Nesse caso, a minha função também poderia ser assim:

void tempo (unsigned int n){
static int x;

while (x < n){
delay_ms(60000);
x++;
}
}

[Pask]

Então, ficaria assim:

void tempo(unsigned int n){
static int y;
while (y < n){
delay_ms(60000);
y++;
}
}

void main() {

tempo (5);
.
.
.
}

Nesse caso, chama-se a função tempo com o parâmetro que o programador quiser. Neste exemplo, o valor 5 fará a função tempo contar um tempo de 5 minutos.

tempo(60);

Nesse segundo caso, o tempo contado será de 1 hora ! Haja paciência para esperar....rsrsrsrs

[turuna]

Isso mesmo Pask são caminhos diferente que levam ao mesmo lugar.Atualmente estou utilizando ela num equipamento de telemetria que colhe valores a cada 4 horas.

Turuna

[ze]

taquigrafia?

void tempo(uint t)
{
while(t--) delay(60000);
}

[helton]

sei lá...mas travar um processador por 60 segundos...parece um estranho...sei lá...

...um timer sempre me ajuda nessas horas difíceis:

Código: Selecionar todos

#include "at89c52.h"

#define DEF_TH0      0xDB
#define DEF_TL0      0xFF

/*

    deltaT = 12 / ( 11.0592 * 10^6 )
   
    T0(TH0/TL0) = 65535 - (IntTempo / deltaT);
    Para um IntTempo = 10ms
    T0 = 0xDBFF


*/

void init_hardware(void)
{
    SCON = 0x50;
    TMOD = 0x21;
    TCON = 0x11;
}

void init_timer( void )
{       
    TR0 = 0;   
    TH0 = DEF_TH0;
    TL0 = DEF_TL0;   
    TR0 = 1;   
    ET0 = 1;
}

void timer0_isr( void ) interrupt 1
{
    TR0 = 0;   /* timer 0 stop timer */
   
    /* update time counter 0 (th0, tl0 ) */
    TH0 = DEF_TH0;
    TL0 = DEF_TL0;
   
    TR0 = 1;   /* timer 0 run */   
    /* Decrease Variables and Setting Flags */
}

void main( void )
{
    init_hardware();
    init_timer();
   
    while(1)
    {   
    }
}

[\code]


[Pask]

De fato, essas temporizações de horas, seguram o processamento naquele ponto e somente ali. É por isso que alguém inventou as "interrupções". Talvez seja mais prudente, quando se tratar de horas, usar uma interrupção de timer para contar todo esse tempo. Nesse caso, a temporização também poderá ser de horas, porém sem atrapalhar outros processamentos.

[turuna]

Mas e se o processador não tem mais nada a fazer e é elimentado a rede elétrica, tipo daqui a x minutos/horas execute isso e depois vá fazer nada de novo, que fique contando carnerinhos..................um loop desses se torna mais simples.

turuna

[Pask]

Sim Turuna. É óbvio que se o micro não tiver nada melhor para fazer, ele pode ficar sentado esperando o tempo passar sem problemas.
Eu mencionei as interrupções apenas naqueles casos em que se deseja que ele faça outras coisas além de contar o tempo. Por exemplo, eu posso criar um programa em que eu desejo que um tempo de 4 horas seja aguardado enquanto um led fica piscando o tempo todo. Nesse caso, eu terei que criar uma interrupção ou para fazer o led piscar ou para aguardar 4 horas! Eu também posso criar um programa em que eu desejo que apenas o tempo de 4 horas seja aguardado. Nesse caso, não haverá necessidade de uma interrupção!

[Djalma Toledo Rodrigues]

Nesse caso, melhor será botar ele para dormir.