timer.c

Ir a la documentación de este archivo.

//******************************************************************************
//  Nombre:       timer.c
//  Versión:      1.0
//  Descripción:  Módulo encargado del control de tiempos del sistema. El mismo 
//                se usa tanto para medir el tiempo entre las distintas notificaciones,
//                como también para implementar los time out en caso de que el sistema
//                tenga algún problema imprevisto.
//  Autores:      Juan Martín Ortega, Ramiro Barrón, Andrea Cukerman
//                IIE, Facultad de Ingeniería, UdelaR
//                Uruguay
//  Fecha:        Junio 2012
//******************************************************************************

#include "timer.h"
#include <stdlib.h>
#include <io430x22x4.h>
#include "car-app.h"
#include "uart.h"

/*
 * Definición de Constantes Privadas
 */
#define MINUTE_TO_SECOND 60

/*
 * Declaración de variables Privadas
 */

static int control_time_counter;

static int control_time = 60;

static int timeout_counter = 0;

extern int alarm_control_state;


void control_counter()
  {
  control_time_counter++;                         //
  if(control_time_counter >= control_time)        //
    {                                             //
    TACCTL1 &= 0xEF;                              //
    if(P2IN_bit.P4)                               //
      {                                           //
        P1OUT ^= 0x02;                            //
        set_control_flag();                       //
      }
    else
      {                                           //
      P2IE |= 0x10;                               // P1.2 interrupt enabled
      alarm_control_state = 0;                    //
      set_control_flag();                         //
      }
    }
  }

void control_timeout()
  {
  timeout_counter++;              //
  if(timeout_counter>5)           //
    {                             //
    TBCCTL1 &= 0xEF;              //
    cargarTXbuffer("\x1B");       //
    //reiniciar sistema;          //
    set_eofl('\n');               //
    set_number_eofl(3);           //
    reset_sendingFlag();          //
    }
  }

void set_control_time(char* time)
  {
  int time_aux = atoi(time);                  // Convierte el tiempo recibido como char a int
  control_time = time_aux * MINUTE_TO_SECOND; // Guarda el tiempo en segundos
  }

int get_control_time()
  {
  return control_time/MINUTE_TO_SECOND; // Retorna el tiempo en minutos
  }

void init_control_timer()
  {
  control_time_counter = 0;             // Reinicia el contador del tiempo entre avisos
  TACCTL1 |= CCIE;                      // Habilita interrupcion del timer A
  }

void conf_control_timer()
  {  
  P1DIR |= 0x01;                          // Selecciona P1.0 luz roja salida
  P1OUT &= 0xFE;                          // Apaga luz roja
  BCSCTL3 |= LFXT1S_2;                    // Configura VLO del timer en 12000Hz
  TACCR1 = 12000;                         // Configura frecuencia de interrupción del timer
  TACTL |= TASSEL_1 + MC_2;               // Configura modo del timer en ACLK, modo continuo
  TACCTL1 = 0x00;                         // Deshabilita interrupción del timer
  }

void conf_timeout()
  {  
  TBCCR1 = 48000;                         // Configura frecuencia de interrupción del timer
  TBCTL |= TBSSEL_1 + MC_2;               // Configura modo del timer en ACLK, modo continuo
  TBCCTL1 = 0x00;                         // Deshabilita interrupción del timer
  }

void init_timeout()
  {
  timeout_counter = 0;                  // Reinicia contador de timeout
  TBCCTL1 |= CCIE;                      // Habilita interrupcion del timer B
  }


#pragma vector=TIMERA1_VECTOR
__interrupt void Timer_A(void)
  {
  switch (TAIV)                   //
    {
    case 2: P1OUT ^= 0x01;        //
            TACCR1 += 12000;      //
            control_counter();    //
    case 4: break;                // TACCR2 not used
    case 10: break;               // overflow not used
    default: break;        
    }
  }

#pragma vector=TIMERB1_VECTOR
__interrupt void Timer_B(void)
  {
  switch (TBIV)                   //
    {
    case 2: TBCCR1 += 48000;      //
            control_timeout();    //
    case 4: break;                // TACCR2 not used
    case 10: break;               // Overflow not used
    default: break;        
    }
  }