AULA 24 - Programação 1 - Graduação

Objetivos

• Representando o tempo em uma forma apropriada para comparação de hora, minuto e segundo;
• Uso de signal para execução periódica de handlers.

Representando o tempo em uma forma apropriada para comparação de hora, minuto e segundo

#include <stdio.h>
#include <time.h>

main()
{

   time_t rawtime; 
	struct tm *tminfo; 

   time ( &rawtime ); 
   tminfo = localtime ( &rawtime ); 
   printf ( "hora: %d minuto: %d segundo: %d \n", tminfo->tm_hour, tminfo->tm_min, tminfo->tm_sec);
   printf ( "%d:%d:%d \n", tminfo->tm_hour, tminfo->tm_min, tminfo->tm_sec);
   printf ( "%dh%dmin%ds \n", tminfo->tm_hour, tminfo->tm_min, tminfo->tm_sec);
}

Exemplo

#include <stdio.h>
#include <time.h>
#include <stdlib.h>
 
 
typedef struct tipo_sala{
  int  salaId;
  int  hora_ent;
  int  hora_sai;
} TSala;
 
 
main()
{
   time_t rawtime; 
   struct tm *tminfo; 
   TSala Lab1;
 
   TSala *pSala;
 
   pSala = malloc(sizeof(TSala));
 
   pSala->salaId = 5;
   pSala->hora_ent = 10;   
   pSala->hora_sai = 12; 
 
 
   /* Ler o tempo real no momento */
 
   time ( &rawtime ); 
   tminfo = localtime ( &rawtime ); 
   printf ( "hora: %d minuto: %d segundo: %d \n", tminfo->tm_hour, tminfo->tm_min, tminfo->tm_sec); 
 
   if(pSala->hora_ent <= tminfo->tm_hour && pSala->hora_sai >= tminfo->tm_hour) {
       printf("Tempo atual dentro da faixa de restrição\n");
   } else {
       printf("Tempo atual FORA da faixa de restrição \n");
   }
   free(pSala);
}

Execução Periódica de Handlers

Um Handlers, também chamado de manipulador de sinal, é apenas uma função que você compila em conjunto com o resto do programa. Em vez de invocar directamente a função, você usa signal ou sigaction que diz ao sistema operacional para chamá-lo quando um sinal chega. Isto é conhecido como "estabelecer o manipulador".

Há duas estratégias básicas que você pode usar em funções do manipulador de sinal:

• Você pode ter a função do manipulador de perceber que o sinal chegou por ajustes, algumas estruturas de dados globais, e em seguida, retornar normalmente.
• Você pode ter a função de manipulador que ao terminar o programa, transfere o controle a um ponto onde ele pode recuperar da situação que provocou o sinal.

Você precisa ter um cuidado especial em funções do identificador de escrita, porque eles podem ser chamados de forma assíncrona. Isto é, um manipulador pode ser chamado em qualquer ponto do programa, de forma imprevisível. Se dois sinais chegam durante um intervalo muito curto, um manipulador pode ser executado dentro do outro.

Exemplo

#include <stdio.h>
#include <signal.h>
#include <sys/time.h>
#include <unistd.h>

static signal_recv_count;

void sigalrm_handler(int signum)
{
  
  signal_recv_count++;
}

void init_timer(int tempo)
{
  struct itimerval timer={0};
  char a[200];
  /* Initial timeout value */
  timer.it_value.tv_sec = tempo;

  /* We want a repetitive timer */
  timer.it_interval.tv_sec = tempo;

  /* Register Signal handler
   * And register for periodic timer with Kernel*/
  signal(SIGALRM, &sigalrm_handler);
  setitimer(ITIMER_REAL, &timer, NULL);
}

int main()
{
  init_timer(10);

  while(1) {
  		printf("imprimindo  :%d\n", signal_recv_count);
  		sleep(1);
  }
}

Decompondo string com delimitadores

#include <string.h>
#include <stdio.h>

int main()
{
   const char string_delimitada[80] = "alfa:beta:delta:epson";
   const char s[2] = ":";
   char *token;
   
   /* Ler o primeiro campo passando a string em str e o delimitador em s */
   token = strtok(string_delimitada, s);
   
   /* Ler os pŕoximos campos - passar primeiro parâmetro NULL */
   while( token != NULL ) 
   {
      printf( " %s\n", token );
    
      token = strtok(NULL, s);
   }
   
   return(0);
}

<<	Aula 24	<>